另一个简洁的lombok实现

import lombok.Value;

@Value(staticConstructor = "of")
public class Pair<F, S> {
    private final F first;
    private final S second;
}

最大的问题可能是不能确保A和B上的不可变(参见如何确保类型参数是不可变的)，因此hashCode()在插入到集合后可能会为相同的Pair给出不一致的结果(这将给出未定义的行为，参见定义可变字段中的equals)。对于一个特定的(非泛型的)Pair类，程序员可以通过仔细选择a和B为不可变来确保不可变性。

不管怎样，从@PeterLawrey的回答中清除泛型的警告(java 1.7):

public class Pair<A extends Comparable<? super A>,
                    B extends Comparable<? super B>>
        implements Comparable<Pair<A, B>> {

    public final A first;
    public final B second;

    private Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }

    public static <A extends Comparable<? super A>,
                    B extends Comparable<? super B>>
            Pair<A, B> of(A first, B second) {
        return new Pair<A, B>(first, second);
    }

    @Override
    public int compareTo(Pair<A, B> o) {
        int cmp = o == null ? 1 : (this.first).compareTo(o.first);
        return cmp == 0 ? (this.second).compareTo(o.second) : cmp;
    }

    @Override
    public int hashCode() {
        return 31 * hashcode(first) + hashcode(second);
    }

    // TODO : move this to a helper class.
    private static int hashcode(Object o) {
        return o == null ? 0 : o.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Pair))
            return false;
        if (this == obj)
            return true;
        return equal(first, ((Pair<?, ?>) obj).first)
                && equal(second, ((Pair<?, ?>) obj).second);
    }

    // TODO : move this to a helper class.
    private boolean equal(Object o1, Object o2) {
        return o1 == o2 || (o1 != null && o1.equals(o2));
    }

    @Override
    public String toString() {
        return "(" + first + ", " + second + ')';
    }
}

补充/更正非常欢迎:)特别是我不太确定我使用Pair<?, ? >。

有关为什么这种语法的更多信息，请参阅确保对象实现可比和详细解释如何在Java中实现一个通用的max(可比a，可比b)函数?

http://www.javatuples.org/index.html怎么样?我发现它非常有用。

javatuples提供了从一到十个元素的元组类:

Unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)
Quartet<A,B,C,D> (4 elements)
Quintet<A,B,C,D,E> (5 elements)
Sextet<A,B,C,D,E,F> (6 elements)
Septet<A,B,C,D,E,F,G> (7 elements)
Octet<A,B,C,D,E,F,G,H> (8 elements)
Ennead<A,B,C,D,E,F,G,H,I> (9 elements)
Decade<A,B,C,D,E,F,G,H,I,J> (10 elements)

这取决于你想用它来做什么。这样做的典型原因是在地图上迭代，为此你可以简单地这样做(Java 5+):

Map<String, Object> map = ... ; // just an example
for (Map.Entry<String, Object> entry : map.entrySet()) {
  System.out.printf("%s -> %s\n", entry.getKey(), entry.getValue());
}

如果有人想要一个简单易用的版本，我在https://github.com/lfac-pt/Java-Pair上提供了我的版本。此外，非常欢迎改进!

在comp.lang.java的一个线程中。帮助，Hunter Gratzner给出了一些反对在Java中存在Pair结构的论点。主要的论点是类Pair不传递关于两个值之间关系的任何语义(您如何知道“first”和“second”的意思?)

一个更好的实践是为每个应用程序编写一个非常简单的类，就像Mike建议的那样。地图。Entry是一个在名称中包含其含义的对的例子。

总而言之，在我看来，最好有一个类Position(x,y)，一个类Range(begin,end)和一个类Entry(key,value)，而不是一个通用的Pair(first,second)，它不告诉我它应该做什么。