Question

我需要一个HashMap （1）通过Object引用匹配键，和（2）在迭代时保持插入顺序

这些功能分别在IdentityHashMap和LinkedHashMap中实现。

有没有办法获得适合我需要的数据结构？ Java标准或第三方库（如Guava）中存在的那个，或者通过在LinkedHashMap上使用一些技巧，或者它使用对象引用来匹配键？

Answer 1

您可以使用Guava的Equivalence：

Equivalence<Object> equivalence = Equivalence.identity();
Map<Equivalence.Wrapper<Object>, Object> map = new LinkedHashMap<>();
map.put(equivalence.wrap(a), b);

Answer 2

它让我感兴趣，所以我写了一个实现。

public class IdentityLinkedHashMap<K, T>  extends AbstractMap<K,T> {

    static Equivalence<Object> equivalence = Equivalence.identity();

    private IdentityLinkedHashSet set = new IdentityLinkedHashSet();

    @Override
    public Set<Entry<K, T>> entrySet() {
        return set;
    }

    @Override
    public T put(K k, T t) {
        return set.innerMap.put( equivalence.wrap(k), t);
    }

    @Override
    public boolean containsKey(Object arg0) {
        return set.contains(arg0);
    }

    @Override
    public T remove(Object arg0) {
        return set.innerMap.remove(equivalence.wrap(arg0));
    }


    @Override
    public T get(Object arg0) {
        return set.innerMap.get(equivalence.wrap(arg0));
    }


    public class MyEntry implements Entry<K, T> {

        final Entry<Equivalence.Wrapper<K>, T> entry;

        public MyEntry(Entry<Wrapper<K>, T> entry) {
            this.entry = entry;
        }

        @Override
        public K getKey() {
            return entry.getKey().get();
        }

        @Override
        public T getValue() {
            return entry.getValue();
        }

        @Override
        public T setValue(T value) {
            return entry.setValue(value);
        }

    }


    public class IdentityLinkedHashSet extends AbstractSet<Entry<K,T>> {

        Map<Equivalence.Wrapper<K>, T> innerMap = new LinkedHashMap<>();

        @Override
        public Iterator<Entry<K, T>> iterator() {
            return Iterators.transform(innerMap.entrySet().iterator(), entry -> new MyEntry(entry));
        }

        @Override
        public boolean add(Entry<K, T> entry) {
            Wrapper<K> wrap = equivalence.wrap(entry.getKey());
            innerMap.put(wrap, entry.getValue());
            return true;
        }

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

        @Override
        public boolean contains(Object arg0) {
            return innerMap.containsKey(equivalence.wrap(arg0));
        }
    }

是否有IdentityHashMap实现维护插入顺序？

2 个答案: