diff --git a/hutool-core/src/main/java/cn/hutool/core/map/DefaultedMap.java b/hutool-core/src/main/java/cn/hutool/core/map/DefaultedMap.java
new file mode 100644
index 000000000..d8960c1d2
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/map/DefaultedMap.java
@@ -0,0 +1,175 @@
+package cn.hutool.core.map;
+
+import java.io.Serializable;
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * @author pantao
+ * @since 2020/1/3
+ */
+public class DefaultedMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable {
+
+    private final Map<K, V> map;
+
+    private final V defaultValue;
+
+    public DefaultedMap(V defaultValue) {
+        this(new HashMap<>(), defaultValue);
+    }
+
+    public DefaultedMap(int initialCapacity, float loadFactor, V defaultValue) {
+        this(new HashMap<>(initialCapacity, loadFactor), defaultValue);
+    }
+
+    public DefaultedMap(int initialCapacity, V defaultValue) {
+        this(new HashMap<>(initialCapacity), defaultValue);
+    }
+
+    public DefaultedMap(Map<K, V> map, V defaultValue) {
+        this.map = map;
+        this.defaultValue = defaultValue;
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return map.containsValue(value);
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return map.containsKey(key);
+    }
+
+    @Override
+    public V get(Object key) {
+        return getOrDefault(key, defaultValue);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        return map.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        return map.remove(key);
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        map.putAll(m);
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return map.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return map.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return map.entrySet();
+    }
+
+    @Override
+    public V getOrDefault(Object key, V defaultValue) {
+        return map.getOrDefault(key, defaultValue);
+    }
+
+    @Override
+    public void forEach(BiConsumer<? super K, ? super V> action) {
+        map.forEach(action);
+    }
+
+    @Override
+    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+        map.replaceAll(function);
+    }
+
+    @Override
+    public V putIfAbsent(K key, V value) {
+        return map.putIfAbsent(key, value);
+    }
+
+    @Override
+    public boolean remove(Object key, Object value) {
+        return map.remove(key, value);
+    }
+
+    @Override
+    public boolean replace(K key, V oldValue, V newValue) {
+        return map.replace(key, oldValue, newValue);
+    }
+
+    @Override
+    public V replace(K key, V value) {
+        return map.replace(key, value);
+    }
+
+    @Override
+    public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+        return map.computeIfAbsent(key, mappingFunction);
+    }
+
+    @Override
+    public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        return map.computeIfPresent(key, remappingFunction);
+    }
+
+    @Override
+    public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        return map.compute(key, remappingFunction);
+    }
+
+    @Override
+    public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+        return map.merge(key, value, remappingFunction);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+        DefaultedMap<?, ?> that = (DefaultedMap<?, ?>) o;
+        return map.equals(that.map) && Objects.equals(defaultValue, that.defaultValue);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(map, defaultValue);
+    }
+
+    @Override
+    public String toString() {
+        return "DefaultedMap{" + "map=" + map + ", defaultValue=" + defaultValue + '}';
+    }
+}