如何使用不可修改的键创建Java映射？

Question

在java中，如何创建映射

我想把这张地图递给你

较高级别问题的背景是，我有变量名的列表/集合（具有树状结构）（表示为java String），我希望java接口另一侧的代码能够为每个变量填充别名（也是Strings）变量名。我希望有这个接口的多种实现，这样命名树层次结构可以是别名，以适应不同的情况。让接口实现填充Map

回到下层问题。我希望我的代码类似于：

    public class MyClass
    {
        public interface IMyMapper
        {
            void build(Map<String,String> mapping);
        }

        IMyMapper mapper;

        // How I'd like to use it
        void work()
        {
            Map<String,String> map ;
            // Magic something like Collections unmodifiableMap, but only for keys
            // Maybe my question should be how this magic for UnmodifiableMap works, so I could reproduce it??
            mapper.build(map); 
            // Because Maps<> are by reference, changed they made (to the values) would be reflected here
        }
    }

    public class TheirClass implements MyClass.IMyMapper
    {
        @Override
        public void build(Map<String,String> mapping)
        {
            // use mapping like Map<String,String> without extra/foreign classes
            // but not be able to modify the Map keys
            // only be able to change the Map values
            // Should be able to use all of the awesome Map stuff, like foreach, values, compute
        }
    }

我知道有集合不可修改Map（Map

又名，我想避免创建我自己的可变类值，并使用集合不可修改映射（）使键和值引用不可修改：

    // mutable reference to a String
    public class ExtraWorkForForEveryone
    {
        public String value;

        public void setValue(String value) { ... }
        public String getValue() { ... }
    }

    // and then use:
    void work()
    {            
        Map<String,ExtraWorkForEveryone> map;
        map = Collections.unmodifiableMap( ... );
        // because Collections.unmodifiableMap() only stops them from changing the Map references,
        // the interfacer could still change the ExtraWorkForEveryone internals.
        // so they could not change keys refs or value refs, but they could change value data.
        mapper.build(map); 
        // Because Maps<> are by reference, changed they made (to the values) would be reflected here
    }

我可以扩展或实现我自己的映射，然后（比如如何Collections unmodifiableMap（））覆盖所有可能更改键的方法抛出UnsupportedOperationException。但是在Java8中，有大量使用Lambda函数添加的方法，只要接口实现者不能更改密钥，就可以访问这些方法。

AKA，我想避免这种冗长且容易出错的技术：

    public final class FinalHashMap extends HashMap
    {
        @Override // anything that might be able to change the Map Keys
        so_many_methods_and_edge_cases()
        { throws UnsupportedOperationException }
    }

是否存在只允许更改映射值数据的现有接口

创建类似于Map的东西的其他选项是什么？




Answer 1

您可能需要限制地图的大小

你可以用你的看跌方法

if (map.size() == maxEntries) {
             throw some exception;

Answer 2

看起来你在寻找代理模式。

详细回答：

其思想是使用所谓的代理与地图交互。代理将拦截对映射的所有调用；您应该只能通过代理与地图交互。它充当客户端和映射之间的接口。

代理是您正在“包装”的内容的骨架。由于您正在为地图创建代理，因此代理应实现map界面：

class ImmutableMap<K, V> implements Map<K, V> {
    private Map<K, V> map;

    public ImmutableMap(Map<K, V> map) {
        this.map = new HashMap<>(map); // detach reference
    }

    //implement methods from Map
}

大多数方法只需伸缩到地图。修改所需的方法以防止删除键或向地图添加新键，例如put、putAll和remove：

final class ImmutableMap<K, V> implementsMap<K, V> {
    private Map<K, V> map;

    public ImmutableMap(Map<K, V> map) {
        this.map = 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) {
        if(!map.containsKey(key)) {
            throw new IllegalArgumentException("Cannot add new keys!");
        }

        return map.put(key, value);
    }

    @Override
    public V remove(Object key) {
        throw new UnsupportedOperationException("You cannot remove entries from this map!");
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {
        for(K key : map.keySet()) {
            if(!this.map.containsKey(key)) {
                throw new IllegalArgumentException("Cannot add new keys to this map!");
            }
        }

        this.map.putAll(map);
    }

    @Override
    public void clear() {
        throw new UnsupportedOperationException("You cannot remove entries from this map!");
    }

    @Override
    public Set<K> keySet() {
        return Collections.unmodifiableSet(map.keySet());
    }

    @Override
    public Collection<V> values() {
        return Collections.unmodifiableSet(map.values()); //prevebt changing values to null
    }

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        //to allow modification of values, create your own ("immutable") entry set and return that
        return Collections.unmodifiableSet(map.entrySet()); 
    }
}

基调：

>

集合。从地图返回集合时，应使用unmodifiableSet。这确保了如果一个人试图修改从映射返回的集合，它将抛出一个UnsupportedOperationException

创建一个新的映射，其中包含传递到构造函数中的映射的值，可防止客户端使用传递到构造函数中的映射修改不可变映射。