diff --git a/plusone-commons/src/main/java/xyz/zhouxy/plusone/commons/collection/MapModifier.java b/plusone-commons/src/main/java/xyz/zhouxy/plusone/commons/collection/MapModifier.java
new file mode 100644
index 0000000..a0dfa74
--- /dev/null
+++ b/plusone-commons/src/main/java/xyz/zhouxy/plusone/commons/collection/MapModifier.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package xyz.zhouxy.plusone.commons.collection;
+
+import static xyz.zhouxy.plusone.commons.util.AssertTools.checkArgumentNotNull;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import com.google.common.annotations.Beta;
+
+/**
+ * Map 修改器
+ *
+ * <p>
+ * 封装一系列对 Map 数据的修改操作，修改 Map 的数据。可以用于 Map 的数据初始化等操作。
+ *
+ * <pre>
+ * // MapModifier
+ * MapModifier<String, Object> modifier = new MapModifier<String, Object>()
+ *     .putAll(commonProperties)
+ *     .put("username", "Ben")
+ *     .put("accountStatus", LOCKED);
+ *
+ * // 从 Supplier 中获取 Map，并修改数据
+ * Map<String, Object> map = modifier.getAndModify(HashMap::new);
+ *
+ * // 可以灵活使用不同 Map 类型的不同构造器
+ * Map<String, Object> map = modifier.getAndModify(() -> new HashMap<>(8));
+ * Map<String, Object> map = modifier.getAndModify(() -> new HashMap<>(anotherMap));
+ * Map<String, Object> map = modifier.getAndModify(TreeMap::new);
+ * Map<String, Object> map = modifier.getAndModify(ConcurrentHashMap::new);
+ *
+ * // 修改已有的 Map
+ * modifier.modify(map);
+ *
+ * // 创建一个有初始化数据的不可变的 Map
+ * Map<String, Object> map = modifier.getUnmodifiableMap();
+ *
+ * // 链式调用创建并初始化数据
+ * Map<String, Object> map = new MapModifier<String, Object>()
+ *     .putAll(commonProperties)
+ *     .put("username", "Ben")
+ *     .put("accountStatus", LOCKED)
+ *     .getAndModify(HashMap::new);
+ * </pre>
+ *
+ * @author ZhouXY108 <luquanlion@outlook.com>
+ * @since 1.1.0
+ */
+@Beta
+public class MapModifier<K, V> {
+
+    @Nonnull
+    private Consumer<Map<K, V>> operators;
+
+    /**
+     * 创建一个空的 MapModifier
+     */
+    public MapModifier() {
+        this.operators = m -> {
+            // do nothing
+        };
+    }
+
+    /**
+     * 添加一个键值对
+     *
+     * @param key 要添加的 {@code key}
+     * @param value 要添加的 {@code value}
+     * @return MapModifier
+     */
+    public MapModifier<K, V> put(K key, V value) {
+        return addOperationInternal(map -> map.put(key, value));
+    }
+
+    /**
+     * 添加一个键值对，如果 key 已经存在，则不添加
+     *
+     * @param key 要添加的 {@code key}
+     * @param value 要添加的 {@code value}
+     * @return MapModifier
+     */
+    public MapModifier<K, V> putIfAbsent(K key, V value) {
+        return addOperationInternal(map -> map.putIfAbsent(key, value));
+    }
+
+    /**
+     * 添加多个键值对
+     *
+     * @param otherMap 要添加的键值对集合
+     * @return MapModifier
+     */
+    public MapModifier<K, V> putAll(Map<? extends K, ? extends V> otherMap) {
+        return addOperationInternal(map -> map.putAll(otherMap));
+    }
+
+    /**
+     * 添加多个键值对
+     *
+     * @param entries 要添加的键值对集合
+     * @return MapModifier
+     */
+    @SafeVarargs
+    public final MapModifier<K, V> putAll(Map.Entry<? extends K, ? extends V>... entries) {
+        return addOperationInternal(map -> {
+            for (Map.Entry<? extends K, ? extends V> entry : entries) {
+                map.put(entry.getKey(), entry.getValue());
+            }
+        });
+    }
+
+    /**
+     * 当 {@code key} 不存在时，计算对应的值，并添加到 {@code map} 中
+     * 调用 {@link Map#computeIfAbsent(Object, Function)}
+     *
+     * @param key 要添加的 {@code key}
+     * @param mappingFunction 计算 {@code key} 对应的值
+     * @return MapModifier
+     */
+    public MapModifier<K, V> computeIfAbsent(K key,
+            Function<? super K, ? extends V> mappingFunction) {
+        return addOperationInternal(map -> map.computeIfAbsent(key, mappingFunction));
+    }
+
+    /**
+     * 当 {@code key} 存在时，计算对应的值，并添加到 {@code map} 中
+     * 调用 {@link Map#computeIfPresent(Object, BiFunction)}
+     *
+     * @param key 要添加的 {@code key}
+     * @param remappingFunction 计算 {@code key} 对应的值
+     * @return MapModifier
+     */
+    public MapModifier<K, V> computeIfPresent(K key,
+            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        return addOperationInternal(map -> map.computeIfPresent(key, remappingFunction));
+    }
+
+    /**
+     * 删除 {@code key}
+     *
+     * @param key 要删除的 {@code key}
+     * @return MapModifier
+     */
+    public MapModifier<K, V> remove(K key) {
+        return addOperationInternal(map -> map.remove(key));
+    }
+
+    /**
+     * 清空 {@code map}
+     *
+     * @return MapModifier
+     */
+    public MapModifier<K, V> clear() {
+        return addOperationInternal(Map::clear);
+    }
+
+    /**
+     * 修改 {@code map}
+     *
+     * @param map 要修改的 {@code map}
+     * @return 修改后的 {@code map}。当入参是 {@code null} 时，返回 {@code null}。
+     */
+    public <T extends Map<K, V>> void modify(@Nullable T map) {
+        if (map != null) {
+            this.operators.accept(map);
+        }
+    }
+
+    /**
+     * 修改 {@code map}
+     *
+     * @param mapSupplier {@code map} 的 {@link Supplier}
+     * @return 修改后的 {@code map}。
+     *         当从 {@code mapSupplier} 获取的 {@code map} 为 {@code null} 时，返回 {@code null}。
+     */
+    @CheckForNull
+    public <T extends Map<K, V>> T getAndModify(Supplier<T> mapSupplier) {
+        checkArgumentNotNull(mapSupplier, "The map supplier cannot be null.");
+        T map = mapSupplier.get();
+        modify(map);
+        return map;
+    }
+
+    /**
+     * 创建一个有初始化数据的不可变的 {@code Map}
+     *
+     * @return 不可变的 {@code Map}
+     */
+    public Map<K, V> getUnmodifiableMap() {
+        return Collections.unmodifiableMap(getAndModify(HashMap::new));
+    }
+
+    private MapModifier<K, V> addOperationInternal(Consumer<Map<K, V>> operator) {
+        this.operators = this.operators.andThen(operator);
+        return this;
+    }
+}
diff --git a/plusone-commons/src/test/java/xyz/zhouxy/plusone/commons/collection/MapModifierTests.java b/plusone-commons/src/test/java/xyz/zhouxy/plusone/commons/collection/MapModifierTests.java
new file mode 100644
index 0000000..d1117d3
--- /dev/null
+++ b/plusone-commons/src/test/java/xyz/zhouxy/plusone/commons/collection/MapModifierTests.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package xyz.zhouxy.plusone.commons.collection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.junit.jupiter.api.Test;
+
+import com.google.common.collect.ImmutableMap;
+
+import lombok.extern.slf4j.Slf4j;
+
+// TODO 完善单元测试
+@Slf4j
+public class MapModifierTests {
+
+    private static final String APP_START_ID = UUID.randomUUID().toString();
+    private static final String LOCKED = "LOCKED";
+
+    private static final Map<String, Object> commonProperties = ImmutableMap.<String, Object>builder()
+            .put("channel", "MOBILE")
+            .put("appStartId", APP_START_ID)
+            .build();
+
+    @Test
+    void initMap() {
+        Map<String, Object> expected = new HashMap<String, Object>() {
+            {
+                put("channel", "MOBILE");
+                put("appStartId", APP_START_ID);
+                put("username", "Ben");
+                put("accountStatus", LOCKED);
+            }
+        };
+
+        // MapModifier
+        MapModifier<String, Object> modifier = new MapModifier<String, Object>()
+                .putAll(commonProperties)
+                .put("username", "Ben")
+                .put("accountStatus", LOCKED);
+
+        // 从 Supplier 中获取 Map，并修改数据
+        HashMap<String, Object> hashMap1 = modifier.getAndModify(HashMap::new);
+        assertEquals(expected, hashMap1);
+
+        // 可以灵活使用不同 Map 类型的不同构造器
+        HashMap<String, Object> hashMap2 = modifier.getAndModify(() -> new HashMap<>(8));
+        assertEquals(expected, hashMap2);
+
+        // HashMap<String, Object> hashMap3 = modifier.getAndModify(() -> new HashMap<>(anotherMap));
+        TreeMap<String, Object> treeMap = modifier.getAndModify(TreeMap::new);
+        assertEquals(expected, treeMap);
+        ConcurrentHashMap<String, Object> concurrentHashMap = modifier.getAndModify(ConcurrentHashMap::new);
+        assertEquals(expected, concurrentHashMap);
+
+        // 修改已有的 Map
+        Map<String, Object> srcMap = new HashMap<>();
+        srcMap.put("srcKey1", "srcValue1");
+        srcMap.put("srcKey2", "srcValue2");
+        modifier.modify(srcMap);
+        assertEquals(new HashMap<String, Object>() {
+            {
+                putAll(commonProperties);
+                put("username", "Ben");
+                put("accountStatus", LOCKED);
+                put("srcKey1", "srcValue1");
+                put("srcKey2", "srcValue2");
+            }
+        }, srcMap);
+
+        // 创建一个有初始化数据的不可变的 {@code Map}
+        Map<String, Object> unmodifiableMap = modifier.getUnmodifiableMap();
+        assertEquals(expected, unmodifiableMap);
+        assertThrows(UnsupportedOperationException.class,
+                () -> unmodifiableMap.put("key", "value"));
+    }
+
+    @Test
+    void createAndInitData() {
+        // 链式调用创建并初始化数据
+        HashMap<String, Object> map = new MapModifier<String, Object>()
+                .putAll(commonProperties)
+                .put("username", "Ben")
+                .put("accountStatus", LOCKED)
+                .getAndModify(HashMap::new);
+
+        HashMap<String, Object> expected = new HashMap<String, Object>() {
+            {
+                put("channel", "MOBILE");
+                put("appStartId", APP_START_ID);
+                put("username", "Ben");
+                put("accountStatus", LOCKED);
+            }
+        };
+        assertEquals(expected, map);
+    }
+}