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

我需要一个HashMap （1） 按对象引用匹配关键帧，以及 （2） 在迭代时保持插入顺序

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

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

您可以使用Guava的：

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

equality=equality.identity（）；
Map Map=newlinkedhashmap（）；
map.put（等价包装（a），b）；

您可以使用番石榴汁：

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

equality=equality.identity（）；
Map Map=newlinkedhashmap（）；
map.put（等价包装（a），b）；

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

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

public类identitylinkdhashmap扩展了AbstractMap{
静态等价=等价。标识（）；
私有identitylinkdhasset=新identitylinkdhasset（）；
@凌驾
公共集入口集（）{
返回集；
}
@凌驾
公共T put（K，T）{
返回set.innerMap.put（equivalence.wrap（k），t）；
}
@凌驾
公共布尔containsKey（对象arg0）{
返回集合.contains（arg0）；
}
@凌驾
无法删除公共对象（对象arg0）{
返回set.innerMap.remove（equality.wrap（arg0））；
}
@凌驾
公共T获取（对象arg0）{
返回set.innerMap.get（equality.wrap（arg0））；
}
公共类MyEntry实现了输入{
最终入围；
公共MyEntry（入口）{
this.entry=entry；
}
@凌驾
公共K getKey（）{
返回条目.getKey（）.get（）；
}
@凌驾
公共T getValue（）{
返回条目.getValue（）；
}
@凌驾
公共T设置值（T值）{
返回条目。设置值（值）；
}
}
公共类identitylinkhashset扩展了抽象集{
Map innerMap=新建LinkedHashMap（）；
@凌驾
公共迭代器迭代器（）{
返回Iterators.transform（innerMap.entrySet（）.iterator（），entry->newmyentry（entry））；
}
@凌驾
公共布尔添加（条目）{
包装包装=equality.wrap（entry.getKey（））；
put（wrap，entry.getValue（））；
返回true；
}
@凌驾
公共整数大小（）{
返回innerMap.size（）；
}
@凌驾
公共布尔包含（对象arg0）{
返回innerMap.containsKey（equality.wrap（arg0））；
}
}

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

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

public类identitylinkdhashmap扩展了AbstractMap{
静态等价=等价。标识（）；
私有identitylinkdhasset=新identitylinkdhasset（）；
@凌驾
公共集入口集（）{
返回集；
}
@凌驾
公共T put（K，T）{
返回set.innerMap.put（equivalence.wrap（k），t）；
}
@凌驾
公共布尔containsKey（对象arg0）{
返回集合.contains（arg0）；
}
@凌驾
无法删除公共对象（对象arg0）{
返回set.innerMap.remove（equality.wrap（arg0））；
}
@凌驾
公共T获取（对象arg0）{
返回set.innerMap.get（equality.wrap（arg0））；
}
公共类MyEntry实现了输入{
最终入围；
公共MyEntry（入口）{
this.entry=entry；
}
@凌驾
公共K getKey（）{
返回条目.getKey（）.get（）；
}
@凌驾
公共T getValue（）{
返回条目.getValue（）；
}
@凌驾
公共T设置值（T值）{
返回条目。设置值（值）；
}
}
公共类identitylinkhashset扩展了抽象集{
Map innerMap=新建LinkedHashMap（）；
@凌驾
公共迭代器迭代器（）{
返回Iterators.transform（innerMap.entrySet（）.iterator（），entry->newmyentry（entry））；
}
@凌驾
公共布尔添加（条目）{
包装包装=equality.wrap（entry.getKey（））；
put（wrap，entry.getValue（））；
返回true；
}
@凌驾
公共整数大小（）{
返回innerMap.size（）；
}
@凌驾
公共布尔包含（对象arg0）{
返回innerMap.containsKey（equality.wrap（arg0））；
}
}

为什么需要身份比较？这本身就很不寻常。我正在尝试为第三方库中的类维护对象到对象的映射。这是为了我正在开发的复杂算法，而不是简单的过程代码，并且使用此映射加快了处理速度。这些类覆盖了

equals

？哇！L就像有人在我之前就需要它一样。谢谢Paul！虽然仅仅为此包含HyperGraphDB会很奇怪；希望这个类是孤立的，我可以在我的代码中使用它。我会研究它…为什么需要身份比较？这本身是非常不寻常的。我正在尝试为m第三方库。这是我正在开发的一个复杂算法，而不是简单的过程代码，使用此映射可以加快处理速度。这些类覆盖

equals

？哇！似乎有人在我之前就需要它。谢谢Paul！尽管仅为此包含HyperGraphDB会很奇怪；希望该类是孤立的，我可以在我的代码中使用它。我会研究它…我可以在紧要关头，但代码在眼睛上绝对不容易…谢谢，不过-学到了关于番石榴的一个新东西！@NK你当然可以通过自己做番石榴来让它更漂亮