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

Question

我想创建类似于 Util.Map.Entry 的新项目，其中将包含结构 key、value。

问题是我无法实例化 Map.Entry 因为它是一个接口。

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

Answer 1

有 公共静态类 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 本身，因为显然它是一个只读对象，我无法实例化新的 instanceof

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

---

警告和提示

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

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

接口映射.Entry

所有已知的实现类：

• 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.SimpleImmutableEntry 或 AbstractMap.SimpleEntry 代替。

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

Answer 3

您可以自己实现 Map.Entry 接口：

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

尝试 Maps.immutableEntry 来自 Guava

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

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

你实际上可以选择：
Map.Entry<字符串，字符串> en= Maps.immutableEntry(key, value);

Answer 7

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

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

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

构造函数和描述
AbstractMap.SimpleEntry(K键, V值)
创建一个条目，表示从指定键到
的映射
指定值。
AbstractMap.SimpleEntry(Map.Entryentry)
创建一个表示与指定条目相同映射的条目。

一个示例用例：

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 并且也可以独立使用。

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

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

Answer 10

如果您使用 Clojure，您还有另一种选择：

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

Answer 11

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

}