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

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

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

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

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

你说：

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

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

警告和提示

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

要查找 implements Map.Entry 的另一个已知类，您实际上可以直接转到 javadoc。来自the Java 6 version

接口 Map.Entry 所有已知的实现类：AbstractMap.SimpleEntry、AbstractMap.SimpleImmutableEntry

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

---

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

这是一个简单的例子：

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

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

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

---

您可以自己实现 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());

---

从 Guava 尝试 Maps.immutableEntry

这具有与 Java 5 兼容的优点（与需要 Java 6 的 AbstractMap.SimpleEntry 不同。）

---

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

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

---

您实际上可以使用：Map.Entry<String, String> en= Maps.immutableEntry(key, value);

---

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

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

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

构造函数和描述 AbstractMap.SimpleEntry(K key, V value) 创建一个表示从指定键到指定值的映射的条目。 AbstractMap.SimpleEntry(Map.Entry 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());
    }
}

---

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

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

---

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

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

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

---

我定义了一个我一直使用的通用 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);
    }

}

---

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

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

---