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

}

试着地图。immutableEntry来自Guava

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

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

它很好地定义了图结构的边。就像你大脑中神经元之间的那些。

有一个公共静态类AbstractMap.SimpleEntry<K,V>。不要让名称的抽象部分误导您:它实际上不是抽象类(但它的顶层AbstractMap是)。

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

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

正如在另一个回答中提到的，Guava也有一个方便的静态工厂方法Maps。你可以使用的immutableEntry。

你说:

我不会用地图。Entry本身，因为显然它是一个只读对象，我不能实例化new instanceof

这并不完全准确。为什么你不能直接实例化它(即用new)是因为它是一个接口Map.Entry。

警告和提示

如文档中所述，AbstractMap。SimpleEntry是从1.6开始使用的，所以如果您坚持使用5.0，那么它对您是不可用的。

寻找另一个实现Map的已知类。入口，实际上可以直接到javadoc。来自Java 6版本

接口映射。条目 所有已知的实现类: AbstractMap。SimpleEntry AbstractMap。SimpleImmutableEntry

不幸的是，1.5版本没有列出任何已知的可以使用的实现类，所以您可能不得不实现自己的类。

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