java - Java - 如何创建新条目（键、值）

Question

我想创建一个与它类似的新项目，Util.Map.Entry它将包含结构key, value。

问题是我不能实例化 aMap.Entry因为它是一个接口。

有谁知道如何为 Map.Entry 创建一个新的通用键/值对象？

Answer 1

有public static class AbstractMap.SimpleEntry<K,V>。不要让Abstract名字的一部分误导你：它实际上不是一个abstract类（但它的顶层AbstractMap是）。

它是一个嵌套类的事实static意味着你不需要一个封闭的AbstractMap实例来实例化它，所以像这样的东西编译得很好：

Map.Entry<String,Integer> entry =
    new AbstractMap.SimpleEntry<String, Integer>("exmpleString", 42);

正如另一个答案中所述，Guava 还有一个方便的static工厂方法Maps.immutableEntry供您使用。

---

你说：

我不能使用Map.Entry自己，因为显然它是一个我无法实例化 new 的只读对象instanceof

这并不完全准确。您不能直接实例化它（即使用new）的原因是因为它是一个interface Map.Entry.

---

警告和提示

如文档中所述，AbstractMap.SimpleEntryis @since 1.6，因此如果您坚持使用 5.0，那么您将无法使用它。

要查找另一个已知的类，implements Map.Entry实际上可以直接转到 javadoc。从Java 6 版本开始

接口映射.入口

所有已知的实现类：

• AbstractMap.SimpleEntry,AbstractMap.SimpleImmutableEntry

不幸的是，1.5 版本没有列出任何您可以使用的已知实现类，因此您可能一直无法实现自己的。

Answer 2

从Java 9 开始，有一个新的实用方法允许创建一个不可变的条目，即Map#entry(Object, Object).

这是一个简单的例子：

Entry<String, String> entry = Map.entry("foo", "bar");

由于它是不可变的，调用setValue将抛出一个UnsupportedOperationException. 其他限制是它不可序列化，并且null由于键或值是被禁止的，如果它不被您接受，您将需要使用AbstractMap.SimpleImmutableEntryorAbstractMap.SimpleEntry代替。

注意：如果您需要直接创建Map具有 0 到最多 10 个（键、值）对的 a，则可以改用 type 的方法Map.of(K key1, V value1, ...)。

Answer 3

您可以Map.Entry<K, V>自己实现接口：

import java.util.Map;

final class MyEntry<K, V> implements Map.Entry<K, V> {
    private final K key;
    private V value;

    public MyEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V value) {
        V old = this.value;
        this.value = value;
        return old;
    }
}

然后使用它：

Map.Entry<String, Object> entry = new MyEntry<String, Object>("Hello", 123);
System.out.println(entry.getKey());
System.out.println(entry.getValue());

Answer 4

Try Maps.immutableEntry from Guava

This has the advantage of being compatible with Java 5 (unlike AbstractMap.SimpleEntry which requires Java 6.)

Answer 5

AbstractMap.SimpleEntry 示例：

import java.util.Map; 
import java.util.AbstractMap;
import java.util.AbstractMap.SimpleEntry;

实例化：

ArrayList<Map.Entry<Integer, Integer>> arr = 
    new ArrayList<Map.Entry<Integer, Integer>>();

添加行：

arr.add(new AbstractMap.SimpleEntry(2, 3));
arr.add(new AbstractMap.SimpleEntry(20, 30));
arr.add(new AbstractMap.SimpleEntry(2, 4));

获取行：

System.out.println(arr.get(0).getKey());
System.out.println(arr.get(0).getValue());
System.out.println(arr.get(1).getKey());
System.out.println(arr.get(1).getValue());
System.out.println(arr.get(2).getKey());
System.out.println(arr.get(2).getValue());

应该打印：

2
3
20
30
2
4

它适用于定义图结构的边缘。就像你头脑中的神经元之间的那些。

Answer 6

You could actually go with: Map.Entry<String, String> en= Maps.immutableEntry(key, value);

Answer 7

如果您查看 Map.Entry 的文档，您会发现它是一个静态接口（在 Map 接口内部定义的接口，可以通过 Map.Entry 访问），它有两个实现

所有已知的实现类：
AbstractMap.SimpleEntry、AbstractMap.SimpleImmutableEntry

AbstractMap.SimpleEntry类提供了 2 个构造函数：

构造函数和描述
AbstractMap.SimpleEntry(K key, V value)
创建一个表示从指定键到
指定值的映射的条目。
AbstractMap.SimpleEntry(Map.Entry<? extends K,? extends V> entry)
创建一个表示与指定条目相同的映射的条目。

一个示例用例：

import java.util.Map;
import java.util.AbstractMap.SimpleEntry;

public class MyClass {
    public static void main(String args[]) {
      Map.Entry e = new SimpleEntry<String, String>("Hello","World");

      System.out.println(e.getKey()+" "+e.getValue());
    }
}

Answer 8

为什么Map.Entry？我想像键值对这样的东西适合这种情况。

使用java.util.AbstractMap.SimpleImmutableEntry或java.util.AbstractMap.SimpleEntry

Answer 9

org.apache.commons.lang3.tuple.Pair实现java.util.Map.Entry，也可以独立使用。

也正如其他人提到的那样，番石榴com.google.common.collect.Maps.immutableEntry(K, V)可以解决问题。

我更喜欢Pair它流畅的Pair.of(L, R)语法。

Answer 10

我定义了一个我一直使用的通用 Pair 类。这很棒。作为奖励，通过定义静态工厂方法 (Pair.create)，我只需编写一半的类型参数。

public class Pair<A, B> {

    private A component1;
    private B component2;

    public Pair() {
            super();
    }

    public Pair(A component1, B component2) {
            this.component1 = component1;
            this.component2 = component2;
    }

    public A fst() {
            return component1;
    }

    public void setComponent1(A component1) {
            this.component1 = component1;
    }

    public B snd() {
            return component2;
    }

    public void setComponent2(B component2) {
            this.component2 = component2;
    }

    @Override
    public String toString() {
            return "<" + component1 + "," + component2 + ">";
    }

    @Override
    public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result
                            + ((component1 == null) ? 0 : component1.hashCode());
            result = prime * result
                            + ((component2 == null) ? 0 : component2.hashCode());
            return result;
    }

    @Override
    public boolean equals(Object obj) {
            if (this == obj)
                    return true;
            if (obj == null)
                    return false;
            if (getClass() != obj.getClass())
                    return false;
            final Pair<?, ?> other = (Pair<?, ?>) obj;
            if (component1 == null) {
                    if (other.component1 != null)
                            return false;
            } else if (!component1.equals(other.component1))
                    return false;
            if (component2 == null) {
                    if (other.component2 != null)
                            return false;
            } else if (!component2.equals(other.component2))
                    return false;
            return true;
    }

    public static <A, B> Pair<A, B> create(A component1, B component2) {
            return new Pair<A, B>(component1, component2);
    }

}

Answer 11

如果你使用 Clojure，你还有另一个选择：

(defn map-entry
  [k v]
  (clojure.lang.MapEntry/create k v))