【JAVA花里胡哨】链式操作MAP

 抽象自定义Map

首先先来个抽象类，用来注入一个Map的真正实现来代理Map接口方法。同时能让继承它的类更简洁（其子类不用实现Map接口方法）。

package com.kovizone.util;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 抽象自定义Map
 *
 * @author KV
 * @since 2022/12/08
 */
public abstract class AbstractCustomMap<K, V> implements Map<K, V> {

    /**
     * 静态代理对象
     * <p>
     * 真正实现接口的对象
     */
    private final Map<K, V> map;

    protected AbstractCustomMap() {
        this.map = new HashMap<>();
    }

    protected AbstractCustomMap(Map<K, V> map) {
        this.map = map == null ? new HashMap<>() : map;
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
        return map.containsValue(value);
    }

    @Override
    public V get(Object key) {
        return map.get(key);
    }

    @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();
    }
}

链式操作Map

 再来一个链式操作Map，扩展Map功能，支持链式操作

package com.kovizone.util;

import java.util.Map;
import java.util.function.Consumer;

/**
 * 链式MAP
 *
 * @author KV
 * @since 2022/12/08
 */
public class ChainMap<K, V> extends AbstractCustomMap<K, V> {

    public ChainMap() {
        super();
    }

    public ChainMap(Map<K, V> map) {
        super(map);
    }

    public ChainMap(Map.Entry<K, V> entry) {
        this(entry.getKey(), entry.getValue());
    }

    public ChainMap(K key, V value) {
        this();
        put(key, value);
    }

    public ChainMap(Map<K, V> map, K key, V value) {
        this(map);
        put(key, value);
    }

    /**
     * 快速构建
     *
     * @param key   键
     * @param value 值
     * @param <K>   键类型
     * @param <V>   值类型
     * @return FluentMap
     */
    public static <K, V> ChainMap<K, V> of(K key, V value) {
        return new ChainMap<K, V>().set(key, value);
    }


    /**
     * 增加节点
     *
     * @param key   键
     * @param value 值
     * @return {@link ChainMap}
     */
    public ChainMap<K, V> set(K key, V value) {
        return set(true, key, value);
    }


    /**
     * 增加节点
     *
     * @param condition 执行条件
     * @param key       键
     * @param value     值
     * @return {@link ChainMap}
     */
    public ChainMap<K, V> set(boolean condition, K key, V value) {
        if (condition) {
            put(key, value);
        }
        return this;
    }

    /**
     * 执行自定义逻辑
     *
     * @param function 自定义逻辑
     * @return FluentMap
     */
    public ChainMap<K, V> func(Consumer<ChainMap<K, V>> function) {
        return func(true, function);
    }

    /**
     * 执行自定义逻辑
     *
     * @param condition 执行条件
     * @param function  自定义逻辑
     * @return FluentMap
     */
    public ChainMap<K, V> func(boolean condition, Consumer<ChainMap<K, V>> function) {
        if (condition && function != null) {
            function.accept(this);
        }
        return this;
    }
}