Spring数据有一个Pair，可以像下面这样使用，

Pair<S, T> pair = Pair.of(S type data, T type data)

地图。入口界面非常接近c++对。看看具体的实现，比如AbstractMap。SimpleEntry和AbstractMap。SimpleImmutableEntry 第一项是getKey()，第二项是getValue()。

在我看来，Java中没有Pair，因为如果你想直接在Pair上添加额外的功能(例如Comparable)，你必须绑定类型。在c++中，我们不在乎，如果组成一个pair的类型没有操作符<，则pair::operator <也不会被编译。

Comparable的一个例子:

public class Pair<F, S> implements Comparable<Pair<? extends F, ? extends S>> {
    public final F first;
    public final S second;
    /* ... */
    public int compareTo(Pair<? extends F, ? extends S> that) {
        int cf = compare(first, that.first);
        return cf == 0 ? compare(second, that.second) : cf;
    }
    //Why null is decided to be less than everything?
    private static int compare(Object l, Object r) {
        if (l == null) {
            return r == null ? 0 : -1;
        } else {
            return r == null ? 1 : ((Comparable) (l)).compareTo(r);
        }
    }
}

/* ... */

Pair<Thread, HashMap<String, Integer>> a = /* ... */;
Pair<Thread, HashMap<String, Integer>> b = /* ... */;
//Runtime error here instead of compile error!
System.out.println(a.compareTo(b));

Comparable与编译时检查类型参数是否可比较的示例:

public class Pair<
        F extends Comparable<? super F>, 
        S extends Comparable<? super S>
> implements Comparable<Pair<? extends F, ? extends S>> {
    public final F first;
    public final S second;
    /* ... */
    public int compareTo(Pair<? extends F, ? extends S> that) {
        int cf = compare(first, that.first);
        return cf == 0 ? compare(second, that.second) : cf;
    }
    //Why null is decided to be less than everything?
    private static <
            T extends Comparable<? super T>
    > int compare(T l, T r) {
        if (l == null) {
            return r == null ? 0 : -1;
        } else {
            return r == null ? 1 : l.compareTo(r);
        }
    }
}

/* ... */

//Will not compile because Thread is not Comparable<? super Thread>
Pair<Thread, HashMap<String, Integer>> a = /* ... */;
Pair<Thread, HashMap<String, Integer>> b = /* ... */;
System.out.println(a.compareTo(b));

这很好，但是这次您不能在Pair中使用不可比较的类型作为类型参数。 你可能会在一些实用程序类中使用很多comparator for Pair，但是c++的人可能不会理解。另一种方法是在类型层次结构中编写很多类，在类型参数上有不同的边界，但是有太多可能的边界和它们的组合……

简单的方法Object[] -可以作为一个几何体元组使用

许多人都张贴对代码，可用作地图中的键…如果您试图使用一对作为哈希键(常用习语)，请务必查看Guava的Table<R,C,V>: http://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained#Table。对于图边，他们给出了下面的用法示例:

Table<Vertex, Vertex, Double> weightedGraph = HashBasedTable.create();
weightedGraph.put(v1, v2, 4);
weightedGraph.put(v1, v3, 20);
weightedGraph.put(v2, v3, 5);

weightedGraph.row(v1); // returns a Map mapping v2 to 4, v3 to 20
weightedGraph.column(v3); // returns a Map mapping v1 to 20, v2 to 5

Table将两个键映射到一个值，并单独为这两种类型的键提供有效的查找。我已经开始使用这个数据结构，而不是Map<Pair<K1,K2>， V>在我的代码的许多部分。有数组、树和其他用于密集和稀疏使用的实现，可以指定您自己的中间映射类。

我能想到的最短的一对是以下，使用Lombok:

@Data
@AllArgsConstructor(staticName = "of")
public class Pair<F, S> {
    private F first;
    private S second;
}

它拥有@arturh答案的所有好处(除了可比性)，它有hashCode, equals, toString和一个静态“构造函数”。