您可以使用谷歌的AutoValue库- https://github.com/google/auto/tree/master/value。

您创建一个非常小的抽象类，并使用@AutoValue注释它，注释处理器为您生成一个具有值语义的具体类。

尽管语法相似，但Java和c++有非常不同的范例。像Java一样写c++是糟糕的c++，像c++一样写Java是糟糕的Java。

使用像Eclipse这样基于反射的IDE，编写“pair”类的必要功能是快速而简单的。创建类，定义两个字段，使用各种“Generate XX”菜单选项在几秒钟内填写类。如果你想要Comparable界面，也许你必须很快地输入一个“compareTo”。

由于c++语言中有单独的声明/定义选项，代码生成器并不是很好，所以手工编写小的实用程序类更加费时乏味。由于pair是一个模板，您不必为不使用的函数付费，并且typedef功能允许为代码分配有意义的类型名，因此关于“无语义”的反对意见并不成立。

在我看来，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++的人可能不会理解。另一种方法是在类型层次结构中编写很多类，在类型参数上有不同的边界，但是有太多可能的边界和它们的组合……

android提供了Pairclass (http://developer.android.com/reference/android/util/Pair.html)，这里实现:

public class Pair<F, S> {
    public final F first;
    public final S second;

    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

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

    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    public static <A, B> Pair <A, B> create(A a, B b) {
        return new Pair<A, B>(a, b);
    }
}

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

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

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

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