Java代码重构实践：利用BiConsumer统一处理异构容器的put操作

public void method1(Map<String, String> map, String key, String value) {
  map.put(key, value);
}

public void method2(GenericRecord recordMap, String key, String value) {
  recordMap.put(key, value);
}

import java.util.function.BiConsumer;
import java.util.Map;
import java.util.HashMap;

// 假设 GenericRecord 是一个自定义接口或类，支持 put 方法
// 为演示目的，我们定义一个简单的GenericRecord接口及实现
interface GenericRecord<K, V> {
    void put(K key, V value);
}

public class RefactorExample {

    /**
     * 通用的添加方法，接受一个BiConsumer来执行具体的put操作。
     *
     * @param consumer 执行put操作的BiConsumer实例
     * @param key      要添加的键
     * @param value    要添加的值
     * @param <K>      键的类型
     * @param <V>      值的类型
     */
    public static <K, V> void add(BiConsumer<K, V> consumer, K key, V value) {
        consumer.accept(key, value);
    }

    public static void main(String[] args) {
        Map<String, String> myMap = new HashMap<>();
        // GenericRecord的匿名实现，用于演示
        GenericRecord<String, String> myRecord = new GenericRecord<String, String>() {
            private final Map<String, String> internalMap = new HashMap<>(); // 内部存储
            @Override
            public void put(String key, String value) {
                internalMap.put(key, value + " (from record)");
                System.out.println("GenericRecord 内部处理: " + key + "=" + value + " -> " + internalMap.get(key));
            }
        };

        String key = "name";
        String value = "Alice";

        System.out.println("--- 使用通用的add方法 ---");
        // 使用方法引用将Map的put方法传递给通用的add方法
        add(myMap::put, key, value);
        System.out.println("Map after add: " + myMap); // Output: {name=Alice}

        // 使用方法引用将GenericRecord的put方法传递给通用的add方法
        add(myRecord::put, "city", "New York");
        // Output for GenericRecord put: GenericRecord 内部处理: city=New York -> New York (from record)
    }
}

import java.util.function.BiConsumer;
import java.util.Map;
import java.util.HashMap;

// GenericRecord接口定义同上
interface GenericRecord<K, V> {
    void put(K key, V value);
}

public class RefactorExample {

    /**
     * 通用的添加方法，接受一个BiConsumer来执行具体的put操作。
     *
     * @param consumer 执行put操作的BiConsumer实例
     * @param key      要添加的键
     * @param value    要添加的值
     * @param <K>      键的类型
     * @param <V>      值的类型
     */
    public static <K, V> void add(BiConsumer<K, V> consumer, K key, V value) {
        consumer.accept(key, value);
    }

    /**
     * 为Map类型提供的便利添加方法。
     * 内部调用通用的add方法。
     *
     * @param map   要操作的Map
     * @param key   要添加的键
     * @param value 要添加的值
     * @param <K>   键的类型
     * @param <V>   值的类型
     */
    public static <K, V> void add(Map<K, V> map, K key, V value) {
        add(map::put, key, value);
    }

    /**
     * 为GenericRecord类型提供的便利添加方法。
     * 内部调用通用的add方法。
     *
     * @param record 要操作的GenericRecord
     * @param key    要添加的键
     * @param value  要添加的值
     * @param <K>    键的类型
     * @param <V>    值的类型
     */
    public static <K, V> void add(GenericRecord<K, V> record, K key, V value) {
        add(record::put, key, value);
    }

    public static void main(String[] args) {
        Map<String, String> myMap = new HashMap<>();
        GenericRecord<String, String> myRecord = new GenericRecord<String, String>() {
            private final Map<String, String> internalMap = new HashMap<>();
            @Override
            public void put(String key, String value) {
                internalMap.put(key, value + " (from record)");
                System.out.println("GenericRecord 内部处理: " + key + "=" + value + " -> " + internalMap.get(key));
            }
        };

        System.out.println("--- 使用重载的便利方法 ---");
        // 使用重载的便利方法
        add(myMap, "age", "30"); // 调用 add(Map<K,V> map, K key, V value)
        System.out.println("Map after overloaded add: " + myMap); // Output: {age=30}

        add(myRecord, "country", "USA"); // 调用 add(GenericRecord<K,V> record, K key, V value)
        // Output for GenericRecord put: GenericRecord 内部处理: country=USA -> USA (from record)
    }
}