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

}

你可以只实现Map。入口<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());

从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类型的方法。(K键1,V值1，…)

如果你看一下Map的文档。Entry你会发现它是一个静态接口(在Map接口中定义的接口，可以通过Map.Entry访问)，它有两个实现

所有已知的实现类: AbstractMap。SimpleEntry AbstractMap。SimpleImmutableEntry

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

构造函数和描述 AbstractMap。SimpleEntry(K键，V值) 属性的映射 指定的值。 AbstractMap.SimpleEntry (map . entry < ?扩展了K, ?扩展V>条目) 创建表示与指定项相同映射的项。

一个示例用例:

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

你可以这样说: 地图。条目<字符串，字符串> en=映射。immutableEntry(关键字,值);

试着地图。immutableEntry来自Guava

这具有与Java 5兼容的优点(不像AbstractMap。SimpleEntry需要Java 6。)