blocks|key|1193072|text|这取决于你想用它做什么。这样做的典型原因是迭代映射，您只需这样做(Java+5%2B)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1193073|Map<String,+Object>+map+=+...+;+//+just+an+example
for+(Map.Entry<String,+Object>+entry+:+map.entrySet())+{
++System.out.printf("%25s+->+%25s\n",+entry.getKey(),+entry.getValue());
}|code-block|syntax|javascript|1193074|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It depends on what you want to use it for. The typical reason to do so is to iterate over maps, for which you simply do this (Java 5+):

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

blocks|key|864074|text|在comp.lang.java.help中，Hunter给出了反对Pair构造在Java中存在的一些论点。主要的论点是，类Pair并不表示关于两个值之间关系的任何语义(您如何知道“第一”和“第二”是什么意思?)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|864075|一个更好的实践是为每个应用程序编写一个非常简单的类，就像Mike建议的那样，每个应用程序都会使用Pair类。Map.Entry是一对以其名称表示其含义的对的一个例子。|864076|总之，在我看来，最好有一个类Position(x,y)、一个类Range(begin,end)和一个类Entry(key,value)，而不是一个不告诉我它应该做什么的通用Pair(first,second)。|864077|entityMap|0|LINK|mutability|MUTABLE|url|http://groups.google.com/group/comp.lang.java.help/browse_thread/thread/f8b63fc645c1b487/1d94be050cfc249b^0|1|J|X|4|1P|4|1|J|0|0|1C|4|1I|9|0|E|D|V|G|1F|G|2E|I|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

In <a href="http://groups.google.com/group/comp.lang.java.help/browse_thread/thread/f8b63fc645c1b487/1d94be050cfc249b" rel="noreferrer">a thread on <code>comp.lang.java.help</code></a>, Hunter Gratzner gives some arguments against the presence of a <code>Pair</code> construct in Java. The main argument is that a class <code>Pair</code> doesn't convey any semantics about the relationship between the two values (how do you know what "first" and "second" mean ?).

A better practice is to write a very simple class, like the one Mike proposed, for each application you would have made of the <code>Pair</code> class. <code>Map.Entry</code> is an example of a pair that carry its meaning in its name.

To sum up, in my opinion it is better to have a class <code>Position(x,y)</code>, a class <code>Range(begin,end)</code> and a class <code>Entry(key,value)</code> rather than a generic <code>Pair(first,second)</code> that doesn't tell me anything about what it's supposed to do.

blocks|key|859733|text|HashMap兼容对类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|859734|public+class+Pair<A,+B>+{
++++private+A+first;
++++private+B+second;

++++public+Pair(A+first,+B+second)+{
++++++++super();
++++++++this.first+=+first;
++++++++this.second+=+second;
++++}

++++public+int+hashCode()+{
++++++++int+hashFirst+=+first+!=+null+?+first.hashCode()+:+0;
++++++++int+hashSecond+=+second+!=+null+?+second.hashCode()+:+0;

++++++++return+(hashFirst+%2B+hashSecond)+*+hashSecond+%2B+hashFirst;
++++}

++++public+boolean+equals(Object+other)+{
++++++++if+(other+instanceof+Pair)+{
++++++++++++Pair+otherPair+=+(Pair)+other;
++++++++++++return+
++++++++++++((++this.first+==+otherPair.first+%7C%7C
++++++++++++++++(+this.first+!=+null+&&+otherPair.first+!=+null+&&
++++++++++++++++++this.first.equals(otherPair.first)))+&&
+++++++++++++(++this.second+==+otherPair.second+%7C%7C
++++++++++++++++(+this.second+!=+null+&&+otherPair.second+!=+null+&&
++++++++++++++++++this.second.equals(otherPair.second)))+);
++++++++}

++++++++return+false;
++++}

++++public+String+toString()
++++{+
+++++++++++return+"("+%2B+first+%2B+",+"+%2B+second+%2B+")";+
++++}

++++public+A+getFirst()+{
++++++++return+first;
++++}

++++public+void+setFirst(A+first)+{
++++++++this.first+=+first;
++++}

++++public+B+getSecond()+{
++++++++return+second;
++++}

++++public+void+setSecond(B+second)+{
++++++++this.second+=+second;
++++}
}|code-block|syntax|javascript|859735|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

HashMap compatible Pair class:

<pre><code>public class Pair&lt;A, B&gt; {
 private A first;
 private B second;

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

 public int hashCode() {
 int hashFirst = first != null ? first.hashCode() : 0;
 int hashSecond = second != null ? second.hashCode() : 0;

 return (hashFirst + hashSecond) * hashSecond + hashFirst;
 }

 public boolean equals(Object other) {
 if (other instanceof Pair) {
 Pair otherPair = (Pair) other;
 return 
 (( this.first == otherPair.first ||
 ( this.first != null &amp;&amp; otherPair.first != null &amp;&amp;
 this.first.equals(otherPair.first))) &amp;&amp;
 ( this.second == otherPair.second ||
 ( this.second != null &amp;&amp; otherPair.second != null &amp;&amp;
 this.second.equals(otherPair.second))) );
 }

 return false;
 }

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

 public A getFirst() {
 return first;
 }

 public void setFirst(A first) {
 this.first = first;
 }

 public B getSecond() {
 return second;
 }

 public void setSecond(B second) {
 this.second = second;
 }
}
</code></pre>

blocks|key|1193180|text|对于一个复杂的泛型来说，成对将是一个很好的工具，例如，这是我的代码中的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1193181|WeakHashMap<Pair<String,+String>,+String>+map+=+...|code-block|syntax|javascript|1193182|和Haskell's+Tuple一样|1193183|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Pair would be a good stuff, to be a basic construction unit for a complex generics, for instance, this is from my code:

<pre><code>WeakHashMap&lt;Pair&lt;String, String&gt;, String&gt; map = ...
</code></pre>

It is just the same as Haskell's Tuple

blocks|key|859743|text|这是爪哇。您必须使用描述性类名和字段名来定制自己的对对类，而不必担心您将通过编写hashCode()/equals()或一次又一次地实现可比较性来重新发明轮子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|859744|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

This is Java. You have to make your own tailored Pair class with descriptive class and field names, and not to mind that you will reinvent the wheel by writing hashCode()/equals() or implementing Comparable again and again.

blocks|key|859749|text|另一种实现对的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|859750|公共不可变字段，即简单的数据结构。|unordered-list-item|859751|可比较。|859752|简单的散列和等号。|859753|简单的工厂，所以你不必提供类型。例如Pair.of("hello"，1)；
公共类Pair实现Comparable>+{公共最终第一；公共最后第二；私有对(第一，第二){+this.first+=第一；this.second+=第二；}公共静态<第一，第一，第二，SECOND>+Pair的(第一，第二){返回新Pair(第一，第二)；}@覆盖公共int+compareTo(Pair+o)+{+int+=比较(首先，o.first)；返回cmp+==+0？比较(第二，o.second)：cmp；}+//+todo将其移动到帮助类。私有静态int比较(+Object+o1，Object+o2)+{返回o1+==空？o2+==+null？-1+:+o2+==+null？%2B1：((可比较)+o1).compareTo(o2)；}@==+int+hashCode()+{返回31+*hashcode(第一)%2Bhashcode(第二)；}+//+todo将其移动到帮助器类。私有静态int+hashcode(对象o)+{返回o+==+null+?0:+o.hashCode()；}@重写公共布尔值等于(Object+obj)+{+if+((obj+instanceof+==+))返回false；if+(==+obj)返回true；返回相等(第一，((对)+obj).first)+&等(第二，((对)+obj).second)；}+//+todo将它移到帮助类中。私有布尔值等于(+Object+o1，Object+o2)+{返回o1+==空？o2+==+null：(o1+==+o2等人(O2))；}@重写公共字符串toString()+{返回"(“%2B+first+%2B+"，”%2B+second+%2B+')'；}|859754|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|O|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Q|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|L|$]]

Another way to implement Pair with.

<ul>
<li>Public immutable fields, i.e. simple data structure.</li>
<li>Comparable.</li>
<li>Simple hash and equals.</li>
<li>Simple factory so you don't have to provide the types. e.g. Pair.of("hello", 1);

<pre><code>public class Pair&lt;FIRST, SECOND&gt; implements Comparable&lt;Pair&lt;FIRST, SECOND&gt;&gt; {

 public final FIRST first;
 public final SECOND second;

 private Pair(FIRST first, SECOND second) {
 this.first = first;
 this.second = second;
 }

 public static &lt;FIRST, SECOND&gt; Pair&lt;FIRST, SECOND&gt; of(FIRST first,
 SECOND second) {
 return new Pair&lt;FIRST, SECOND&gt;(first, second);
 }

 @Override
 public int compareTo(Pair&lt;FIRST, SECOND&gt; o) {
 int cmp = compare(first, o.first);
 return cmp == 0 ? compare(second, o.second) : cmp;
 }

 // todo move this to a helper class.
 private static int compare(Object o1, Object o2) {
 return o1 == null ? o2 == null ? 0 : -1 : o2 == null ? +1
 : ((Comparable) o1).compareTo(o2);
 }

 @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)
 &amp;&amp; equal(second, ((Pair) obj).second);
 }

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

 @Override
 public String toString() {
 return "(" + first + ", " + second + ')';
 }
}
</code></pre></li>
</ul>

blocks|key|1193288|text|简单的方法对象[]+-可以用作у维元组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1193289|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Simple way Object [] - can be use as anу dimention tuple

blocks|key|1193307|text|在我看来，Java中没有对，因为如果您想直接在这对上添加额外的功能(例如，可比较的)，您必须绑定这些类型。在C%2B%2B中，我们只是不在乎，如果组成一对的类型没有operator+<，那么pair::operator+<也不会编译。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1193308|没有界限的可比较的例子：|1193309|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));|code-block|syntax|javascript|1193310|可与编译时检查类型参数是否具有可比性的示例：|1193311|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));|1193312|这是好的，但这一次，您可能不会使用不可比较的类型作为类型参数的配对。在某些实用程序类中，可以使用大量的比较器来实现对，但C%2B%2B用户可能无法得到它。另一种方法是在类型层次结构中编写许多类，对类型参数具有不同的界限，但是有太多可能的界限及其组合.|1193313|entityMap^0|26|A|2J|G|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

In my opinion, there is no Pair in Java because, if you want to add extra functionality directly on the pair (e.g. Comparable), you must bound the types. In C++, we just don't care, and if types composing a pair do not have <code>operator &lt;</code>, the <code>pair::operator &lt;</code> will not compile as well.

An example of Comparable with no bounding:

<pre><code>public class Pair&lt;F, S&gt; implements Comparable&lt;Pair&lt;? extends F, ? extends S&gt;&gt; {
 public final F first;
 public final S second;
 /* ... */
 public int compareTo(Pair&lt;? extends F, ? extends S&gt; 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&lt;Thread, HashMap&lt;String, Integer&gt;&gt; a = /* ... */;
Pair&lt;Thread, HashMap&lt;String, Integer&gt;&gt; b = /* ... */;
//Runtime error here instead of compile error!
System.out.println(a.compareTo(b));
</code></pre>

An example of Comparable with compile-time check for whether type arguments are comparable:

<pre><code>public class Pair&lt;
 F extends Comparable&lt;? super F&gt;, 
 S extends Comparable&lt;? super S&gt;
&gt; implements Comparable&lt;Pair&lt;? extends F, ? extends S&gt;&gt; {
 public final F first;
 public final S second;
 /* ... */
 public int compareTo(Pair&lt;? extends F, ? extends S&gt; 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 &lt;
 T extends Comparable&lt;? super T&gt;
 &gt; 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&lt;? super Thread&gt;
Pair&lt;Thread, HashMap&lt;String, Integer&gt;&gt; a = /* ... */;
Pair&lt;Thread, HashMap&lt;String, Integer&gt;&gt; b = /* ... */;
System.out.println(a.compareTo(b));
</code></pre>

This is good, but this time you may not use non-comparable types as type arguments in Pair.
One may use lots of Comparators for Pair in some utility class, but C++ people may not get it. Another way is to write lots of classes in a type hierarchy with different bounds on type arguments, but there are too many possible bounds and their combinations...

blocks|key|1193336|text|我能找到的最短的一对是使用隆布克实现的|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1193337|@Data
@AllArgsConstructor(staticName+=+"of")
public+class+Pair<F,+S>+{
++++private+F+first;
++++private+S+second;
}|code-block|syntax|javascript|1193338|它拥有来自@arturh的答案的所有优点(除了可比性)，它还有hashCode、equals、toString和一个静态的“构造函数”。|style|CODE|1193339|entityMap|0|LINK|mutability|MUTABLE|url|http://projectlombok.org/|1|https://stackoverflow.com/a/677248/383414^0|D|3|0|0|0|V|8|14|6|1B|8|3|C|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]|$A|14|B|15|K|L]|$A|16|B|17|K|L]]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

The shortest pair that I could come up with is the following, using <a href="http://projectlombok.org/" rel="noreferrer">Lombok</a>:

<pre><code>@Data
@AllArgsConstructor(staticName = "of")
public class Pair&lt;F, S&gt; {
 private F first;
 private S second;
}
</code></pre>

It has all the benefits of <a href="https://stackoverflow.com/a/677248/383414">the answer from @arturh</a> (except the comparability), it has <code>hashCode</code>, <code>equals</code>, <code>toString</code> and a static “constructor”.

blocks|key|194123|text|正如许多其他人已经说过的那样，它实际上取决于用例是否有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194124|我认为对于私有助手函数来说，使用对类是完全合法的，如果这样可以提高代码的可读性，并且不值得用它的所有锅炉板代码创建另一个值类。|194125|另一方面，如果抽象级别要求您清楚地记录包含两个对象或值的类的语义，那么您应该为它编写一个类。通常，如果数据是业务对象，就会出现这种情况。|194126|一如既往，这需要熟练的判断力。|194127|对于第二个问题，我推荐中的结对类。这些可能被认为是Java的扩展标准库：|194128|https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html|offset|length|194129|您可能还想看看的EqualsBuilder、HashCodeBuilder和ToStringBuilder，它们简化了编写业务对象的值类。|194130|entityMap|0|LINK|mutability|MUTABLE|url|1|https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/EqualsBuilder.html|2|https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/HashCodeBuilder.html|3|https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/ToStringBuilder.html^0|0|0|0|0|0|0|2N|0|0|8|D|1|M|F|2|12|F|3|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@$L|18|M|19|1|1A]]|A|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@$L|1C|M|1D|1|1E]|$L|1F|M|1G|1|1H]|$L|1I|M|1J|1|1K]]|A|$]]|$1|P|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|K]]|W|$5|S|T|U|A|$V|X]]|Y|$5|S|T|U|A|$V|Z]]|10|$5|S|T|U|A|$V|11]]]]

As many others have already stated, it really depends on the use case if a Pair class is useful or not.

I think for a private helper function it is totally legitimate to use a Pair class if that makes your code more readable and is not worth the effort of creating yet another value class with all its boiler plate code.

On the other hand, if your abstraction level requires you to clearly document the semantics of the class that contains two objects or values, then you should write a class for it. Usually that's the case if the data is a business object.

As always, it requires skilled judgement.

For your second question I recommend the Pair class from the Apache Commons libraries. Those might be considered as extended standard libraries for Java:

<a href="https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html" rel="nofollow">https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html</a>

You might also want to have a look at Apache Commons' <a href="https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/EqualsBuilder.html" rel="nofollow">EqualsBuilder</a>, <a href="https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/HashCodeBuilder.html" rel="nofollow">HashCodeBuilder</a> and <a href="https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/ToStringBuilder.html" rel="nofollow">ToStringBuilder</a> which simplify writing value classes for your business objects.

blocks|key|194151|text|我注意到所有的对实现都散落在这里，属性意味着两个值的顺序。当我想到一对时，我想到两个项目的组合，其中两个项目的顺序不重要。下面是一个无序对的实现，它使用hashCode和equals重写，以确保集合中所需的行为。也是克隆的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|194152|/**
+*+The+class+<code>Pair</code>+models+a+container+for+two+objects+wherein+the
+*+object+order+is+of+no+consequence+for+equality+and+hashing.+An+example+of
+*+using+Pair+would+be+as+the+return+type+for+a+method+that+needs+to+return+two
+*+related+objects.+Another+good+use+is+as+entries+in+a+Set+or+keys+in+a+Map
+*+when+only+the+unordered+combination+of+two+objects+is+of+interest.
+*+The+term+"object"+as+being+a+one+of+a+Pair+can+be+loosely+interpreted.+A
+*+Pair+may+have+one+or+two+<code>null</code>+entries+as+values.+Both+values
+*+may+also+be+the+same+object.
+*+Mind+that+the+order+of+the+type+parameters+T+and+U+is+of+no+importance.+A
+*+Pair&lt;T,+U>+can+still+return+<code>true</code>+for+method+<code>equals</code>
+*+called+with+a+Pair&lt;U,+T>+argument.
+*+Instances+of+this+class+are+immutable,+but+the+provided+values+might+not+be.
+*+This+means+the+consistency+of+equality+checks+and+the+hash+code+is+only+as
+*+strong+as+that+of+the+value+types.
+*/
public+class+Pair<T,+U>+implements+Cloneable+{

++++/**
+++++*+One+of+the+two+values,+for+the+declared+type+T.
+++++*/
++++private+final+T+object1;
++++/**
+++++*+One+of+the+two+values,+for+the+declared+type+U.
+++++*/
++++private+final+U+object2;
++++private+final+boolean+object1Null;
++++private+final+boolean+object2Null;
++++private+final+boolean+dualNull;

++++/**
+++++*+Constructs+a+new+<code>Pair&lt;T,+U&gt;</code>+with+T+object1+and+U+object2+as
+++++*+its+values.+The+order+of+the+arguments+is+of+no+consequence.+One+or+both+of
+++++*+the+values+may+be+<code>null</code>+and+both+values+may+be+the+same+object.
+++++*
+++++*+@param+object1+T+to+serve+as+one+value.
+++++*+@param+object2+U+to+serve+as+the+other+value.
+++++*/
++++public+Pair(T+object1,+U+object2)+{

++++++++this.object1+=+object1;
++++++++this.object2+=+object2;
++++++++object1Null+=+object1+==+null;
++++++++object2Null+=+object2+==+null;
++++++++dualNull+=+object1Null+&&+object2Null;

++++}

++++/**
+++++*+Gets+the+value+of+this+Pair+provided+as+the+first+argument+in+the+constructor.
+++++*
+++++*+@return+a+value+of+this+Pair.
+++++*/
++++public+T+getObject1()+{

++++++++return+object1;

++++}

++++/**
+++++*+Gets+the+value+of+this+Pair+provided+as+the+second+argument+in+the+constructor.
+++++*
+++++*+@return+a+value+of+this+Pair.
+++++*/
++++public+U+getObject2()+{

++++++++return+object2;

++++}

++++/**
+++++*+Returns+a+shallow+copy+of+this+Pair.+The+returned+Pair+is+a+new+instance
+++++*+created+with+the+same+values+as+this+Pair.+The+values+themselves+are+not
+++++*+cloned.
+++++*
+++++*+@return+a+clone+of+this+Pair.
+++++*/
++++@Override
++++public+Pair<T,+U>+clone()+{

++++++++return+new+Pair<T,+U>(object1,+object2);

++++}

++++/**
+++++*+Indicates+whether+some+other+object+is+"equal"+to+this+one.
+++++*+This+Pair+is+considered+equal+to+the+object+if+and+only+if
+++++*+<ul>
+++++*+<li>the+Object+argument+is+not+null,
+++++*+<li>the+Object+argument+has+a+runtime+type+Pair+or+a+subclass,
+++++*+</ul>
+++++*+AND
+++++*+<ul>
+++++*+<li>the+Object+argument+refers+to+this+pair
+++++*+<li>OR+this+pair's+values+are+both+null+and+the+other+pair's+values+are+both+null
+++++*+<li>OR+this+pair+has+one+null+value+and+the+other+pair+has+one+null+value+and
+++++*+the+remaining+non-null+values+of+both+pairs+are+equal
+++++*+<li>OR+both+pairs+have+no+null+values+and+have+value+tuples+&lt;v1,+v2>+of
+++++*+this+pair+and+&lt;o1,+o2>+of+the+other+pair+so+that+at+least+one+of+the
+++++*+following+statements+is+true:
+++++*+<ul>
+++++*+<li>v1+equals+o1+and+v2+equals+o2
+++++*+<li>v1+equals+o2+and+v2+equals+o1
+++++*+</ul>
+++++*+</ul>
+++++*+In+any+other+case+(such+as+when+this+pair+has+two+null+parts+but+the+other
+++++*+only+one)+this+method+returns+false.
+++++*+The+type+parameters+that+were+used+for+the+other+pair+are+of+no+importance.
+++++*+A+Pair&lt;T,+U>+can+return+<code>true</code>+for+equality+testing+with
+++++*+a+Pair&lt;T,+V>+even+if+V+is+neither+a+super-+nor+subtype+of+U,+should
+++++*+the+the+value+equality+checks+be+positive+or+the+U+and+V+type+values
+++++*+are+both+<code>null</code>.+Type+erasure+for+parameter+types+at+compile
+++++*+time+means+that+type+checks+are+delegated+to+calls+of+the+<code>equals</code>
+++++*+methods+on+the+values+themselves.
+++++*
+++++*+@param+obj+the+reference+object+with+which+to+compare.
+++++*+@return+true+if+the+object+is+a+Pair+equal+to+this+one.
+++++*/
++++@Override
++++public+boolean+equals(Object+obj)+{

++++++++if(obj+==+null)
++++++++++++return+false;

++++++++if(this+==+obj)
++++++++++++return+true;

++++++++if(!(obj+instanceof+Pair<?,+?>))
++++++++++++return+false;

++++++++final+Pair<?,+?>+otherPair+=+(Pair<?,+?>)obj;

++++++++if(dualNull)
++++++++++++return+otherPair.dualNull;

++++++++//After+this+we're+sure+at+least+one+part+in+this+is+not+null

++++++++if(otherPair.dualNull)
++++++++++++return+false;

++++++++//After+this+we're+sure+at+least+one+part+in+obj+is+not+null

++++++++if(object1Null)+{
++++++++++++if(otherPair.object1Null)+//Yes:+this+and+other+both+have+non-null+part2
++++++++++++++++return+object2.equals(otherPair.object2);
++++++++++++else+if(otherPair.object2Null)+//Yes:+this+has+non-null+part2,+other+has+non-null+part1
++++++++++++++++return+object2.equals(otherPair.object1);
++++++++++++else+//Remaining+case:+other+has+no+non-null+parts
++++++++++++++++return+false;
++++++++}+else+if(object2Null)+{
++++++++++++if(otherPair.object2Null)+//Yes:+this+and+other+both+have+non-null+part1
++++++++++++++++return+object1.equals(otherPair.object1);
++++++++++++else+if(otherPair.object1Null)+//Yes:+this+has+non-null+part1,+other+has+non-null+part2
++++++++++++++++return+object1.equals(otherPair.object2);
++++++++++++else+//Remaining+case:+other+has+no+non-null+parts
++++++++++++++++return+false;
++++++++}+else+{
++++++++++++//Transitive+and+symmetric+requirements+of+equals+will+make+sure
++++++++++++//checking+the+following+cases+are+sufficient
++++++++++++if(object1.equals(otherPair.object1))
++++++++++++++++return+object2.equals(otherPair.object2);
++++++++++++else+if(object1.equals(otherPair.object2))
++++++++++++++++return+object2.equals(otherPair.object1);
++++++++++++else
++++++++++++++++return+false;
++++++++}

++++}

++++/**
+++++*+Returns+a+hash+code+value+for+the+pair.+This+is+calculated+as+the+sum
+++++*+of+the+hash+codes+for+the+two+values,+wherein+a+value+that+is+<code>null</code>
+++++*+contributes+0+to+the+sum.+This+implementation+adheres+to+the+contract+for
+++++*+<code>hashCode()</code>+as+specified+for+<code>Object()</code>.+The+returned
+++++*+value+hash+code+consistently+remain+the+same+for+multiple+invocations
+++++*+during+an+execution+of+a+Java+application,+unless+at+least+one+of+the+pair
+++++*+values+has+its+hash+code+changed.+That+would+imply+information+used+for+
+++++*+equals+in+the+changed+value(s)+has+also+changed,+which+would+carry+that
+++++*+change+onto+this+class'+<code>equals</code>+implementation.
+++++*
+++++*+@return+a+hash+code+for+this+Pair.
+++++*/
++++@Override
++++public+int+hashCode()+{

++++++++int+hashCode+=+object1Null+?+0+:+object1.hashCode();
++++++++hashCode+%2B=+(object2Null+?+0+:+object2.hashCode());
++++++++return+hashCode;

++++}

}|code-block|syntax|javascript|194153|这个实现已经经过了适当的单元测试，并且在集合和地图中的使用已经过尝试。|194154|请注意，我并没有声称在公共领域发布这个。这是我刚刚编写的用于应用程序的代码，所以如果您要使用它，请不要直接复制，不要把注释和名称搞得乱七八糟。明白我的意思了吗？|194155|entityMap^0|24|8|2D|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

I noticed all the Pair implementations being strewn around here attribute meaning to the order of the two values. When I think of a pair, I think of a combination of two items in which the order of the two is of no importance. Here's my implementation of an unordered pair, with <code>hashCode</code> and <code>equals</code> overrides to ensure the desired behaviour in collections. Also cloneable.

<pre><code>/**
 * The class &lt;code&gt;Pair&lt;/code&gt; models a container for two objects wherein the
 * object order is of no consequence for equality and hashing. An example of
 * using Pair would be as the return type for a method that needs to return two
 * related objects. Another good use is as entries in a Set or keys in a Map
 * when only the unordered combination of two objects is of interest.&lt;p&gt;
 * The term "object" as being a one of a Pair can be loosely interpreted. A
 * Pair may have one or two &lt;code&gt;null&lt;/code&gt; entries as values. Both values
 * may also be the same object.&lt;p&gt;
 * Mind that the order of the type parameters T and U is of no importance. A
 * Pair&amp;lt;T, U&gt; can still return &lt;code&gt;true&lt;/code&gt; for method &lt;code&gt;equals&lt;/code&gt;
 * called with a Pair&amp;lt;U, T&gt; argument.&lt;p&gt;
 * Instances of this class are immutable, but the provided values might not be.
 * This means the consistency of equality checks and the hash code is only as
 * strong as that of the value types.&lt;p&gt;
 */
public class Pair&lt;T, U&gt; implements Cloneable {

 /**
 * One of the two values, for the declared type T.
 */
 private final T object1;
 /**
 * One of the two values, for the declared type U.
 */
 private final U object2;
 private final boolean object1Null;
 private final boolean object2Null;
 private final boolean dualNull;

 /**
 * Constructs a new &lt;code&gt;Pair&amp;lt;T, U&amp;gt;&lt;/code&gt; with T object1 and U object2 as
 * its values. The order of the arguments is of no consequence. One or both of
 * the values may be &lt;code&gt;null&lt;/code&gt; and both values may be the same object.
 *
 * @param object1 T to serve as one value.
 * @param object2 U to serve as the other value.
 */
 public Pair(T object1, U object2) {

 this.object1 = object1;
 this.object2 = object2;
 object1Null = object1 == null;
 object2Null = object2 == null;
 dualNull = object1Null &amp;&amp; object2Null;

 }

 /**
 * Gets the value of this Pair provided as the first argument in the constructor.
 *
 * @return a value of this Pair.
 */
 public T getObject1() {

 return object1;

 }

 /**
 * Gets the value of this Pair provided as the second argument in the constructor.
 *
 * @return a value of this Pair.
 */
 public U getObject2() {

 return object2;

 }

 /**
 * Returns a shallow copy of this Pair. The returned Pair is a new instance
 * created with the same values as this Pair. The values themselves are not
 * cloned.
 *
 * @return a clone of this Pair.
 */
 @Override
 public Pair&lt;T, U&gt; clone() {

 return new Pair&lt;T, U&gt;(object1, object2);

 }

 /**
 * Indicates whether some other object is "equal" to this one.
 * This Pair is considered equal to the object if and only if
 * &lt;ul&gt;
 * &lt;li&gt;the Object argument is not null,
 * &lt;li&gt;the Object argument has a runtime type Pair or a subclass,
 * &lt;/ul&gt;
 * AND
 * &lt;ul&gt;
 * &lt;li&gt;the Object argument refers to this pair
 * &lt;li&gt;OR this pair's values are both null and the other pair's values are both null
 * &lt;li&gt;OR this pair has one null value and the other pair has one null value and
 * the remaining non-null values of both pairs are equal
 * &lt;li&gt;OR both pairs have no null values and have value tuples &amp;lt;v1, v2&gt; of
 * this pair and &amp;lt;o1, o2&gt; of the other pair so that at least one of the
 * following statements is true:
 * &lt;ul&gt;
 * &lt;li&gt;v1 equals o1 and v2 equals o2
 * &lt;li&gt;v1 equals o2 and v2 equals o1
 * &lt;/ul&gt;
 * &lt;/ul&gt;
 * In any other case (such as when this pair has two null parts but the other
 * only one) this method returns false.&lt;p&gt;
 * The type parameters that were used for the other pair are of no importance.
 * A Pair&amp;lt;T, U&gt; can return &lt;code&gt;true&lt;/code&gt; for equality testing with
 * a Pair&amp;lt;T, V&gt; even if V is neither a super- nor subtype of U, should
 * the the value equality checks be positive or the U and V type values
 * are both &lt;code&gt;null&lt;/code&gt;. Type erasure for parameter types at compile
 * time means that type checks are delegated to calls of the &lt;code&gt;equals&lt;/code&gt;
 * methods on the values themselves.
 *
 * @param obj the reference object with which to compare.
 * @return true if the object is a Pair equal to this one.
 */
 @Override
 public boolean equals(Object obj) {

 if(obj == null)
 return false;

 if(this == obj)
 return true;

 if(!(obj instanceof Pair&lt;?, ?&gt;))
 return false;

 final Pair&lt;?, ?&gt; otherPair = (Pair&lt;?, ?&gt;)obj;

 if(dualNull)
 return otherPair.dualNull;

 //After this we're sure at least one part in this is not null

 if(otherPair.dualNull)
 return false;

 //After this we're sure at least one part in obj is not null

 if(object1Null) {
 if(otherPair.object1Null) //Yes: this and other both have non-null part2
 return object2.equals(otherPair.object2);
 else if(otherPair.object2Null) //Yes: this has non-null part2, other has non-null part1
 return object2.equals(otherPair.object1);
 else //Remaining case: other has no non-null parts
 return false;
 } else if(object2Null) {
 if(otherPair.object2Null) //Yes: this and other both have non-null part1
 return object1.equals(otherPair.object1);
 else if(otherPair.object1Null) //Yes: this has non-null part1, other has non-null part2
 return object1.equals(otherPair.object2);
 else //Remaining case: other has no non-null parts
 return false;
 } else {
 //Transitive and symmetric requirements of equals will make sure
 //checking the following cases are sufficient
 if(object1.equals(otherPair.object1))
 return object2.equals(otherPair.object2);
 else if(object1.equals(otherPair.object2))
 return object2.equals(otherPair.object1);
 else
 return false;
 }

 }

 /**
 * Returns a hash code value for the pair. This is calculated as the sum
 * of the hash codes for the two values, wherein a value that is &lt;code&gt;null&lt;/code&gt;
 * contributes 0 to the sum. This implementation adheres to the contract for
 * &lt;code&gt;hashCode()&lt;/code&gt; as specified for &lt;code&gt;Object()&lt;/code&gt;. The returned
 * value hash code consistently remain the same for multiple invocations
 * during an execution of a Java application, unless at least one of the pair
 * values has its hash code changed. That would imply information used for 
 * equals in the changed value(s) has also changed, which would carry that
 * change onto this class' &lt;code&gt;equals&lt;/code&gt; implementation.
 *
 * @return a hash code for this Pair.
 */
 @Override
 public int hashCode() {

 int hashCode = object1Null ? 0 : object1.hashCode();
 hashCode += (object2Null ? 0 : object2.hashCode());
 return hashCode;

 }

}
</code></pre>

This implementation has been properly unit tested and the use in a Set and Map has been tried out. 

Notice I'm not claiming to release this in the public domain. This is code I've just written for use in an application, so if you're going to use it, please refrain from making a direct copy and mess about with the comments and names a bit. Catch my drift?

blocks|key|864206|text|public+class+Pair<K,+V>+{

++++private+final+K+element0;
++++private+final+V+element1;

++++public+static+<K,+V>+Pair<K,+V>+createPair(K+key,+V+value)+{
++++++++return+new+Pair<K,+V>(key,+value);
++++}

++++public+Pair(K+element0,+V+element1)+{
++++++++this.element0+=+element0;
++++++++this.element1+=+element1;
++++}

++++public+K+getElement0()+{
++++++++return+element0;
++++}

++++public+V+getElement1()+{
++++++++return+element1;
++++}

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|864207|用法：|unstyled|864208|Pair<Integer,+String>+pair+=+Pair.createPair(1,+"test");
pair.getElement0();
pair.getElement1();|864209|一成不变，只有一对！|864210|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>public class Pair&lt;K, V&gt; {

 private final K element0;
 private final V element1;

 public static &lt;K, V&gt; Pair&lt;K, V&gt; createPair(K key, V value) {
 return new Pair&lt;K, V&gt;(key, value);
 }

 public Pair(K element0, V element1) {
 this.element0 = element0;
 this.element1 = element1;
 }

 public K getElement0() {
 return element0;
 }

 public V getElement1() {
 return element1;
 }

}
</code></pre>

usage :

<pre><code>Pair&lt;Integer, String&gt; pair = Pair.createPair(1, "test");
pair.getElement0();
pair.getElement1();
</code></pre>

Immutable, only a pair !

blocks|key|1193491|text|如果有人想要一个简单易用的版本，我在https://github.com/lfac-pt/Java-Pair上提供了我的版本。此外，改进是非常欢迎的！|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1193492|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/lfac-pt/Java-Pair^0|I|10|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If anyone wants a dead-simple and easy to use version I made my available at <a href="https://github.com/lfac-pt/Java-Pair" rel="nofollow">https://github.com/lfac-pt/Java-Pair</a>. Also, improvements are very much welcome!

blocks|key|1193505|text|http://www.javatuples.org/index.html怎么样?我发现它很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1193506|javatuples提供了从一个元素到十个元素的元组类：|1193507|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)|code-block|syntax|javascript|1193508|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javatuples.org/index.html^0|0|10|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

How about <a href="http://www.javatuples.org/index.html" rel="noreferrer">http://www.javatuples.org/index.html</a> I have found it very useful.

The javatuples offers you tuple classes from one to ten elements:

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

blocks|key|859878|text|Apache+3.0%2B有几个对类：http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|859879|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html^0|H|2X|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Apache Commons Lang 3.0+ has a few Pair classes: 
<a href="http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html" rel="noreferrer">http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html</a>

blocks|key|194302|text|根据Java语言的特性，我想人们实际上并不需要Pair，接口通常是他们所需要的。下面是一个示例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|194303|interface+Pair<L,+R>+{
++++public+L+getL();
++++public+R+getR();
}|code-block|syntax|javascript|194304|因此，当人们想返回两个值时，他们可以执行以下操作：|194305|...+//Calcuate+the+return+value
final+Integer+v1+=+result1;
final+String+v2+=+result2;
return+new+Pair<Integer,+String>(){
++++Integer+getL(){+return+v1;+}
++++String+getR(){+return+v2;+}
}|194306|这是一个非常轻量级的解决方案，它回答了“Pair<L,R>的语义是什么？”这个问题。答案是，这是一个具有两种(可能不同的)类型的接口构建，它有方法来返回其中的每一种类型。应该由您来为它添加更多的语义。例如，如果您使用的是位置，并且确实希望在代码中指示它，则可以定义包含PositionX和PositionY的Integer，以构成Pair<PositionX,PositionY>。如果JSR+308可用，您也可以使用Pair<@PositionX+Integer,+@PositionY+Ingeger>来简化它。|194307|编辑:这里我要指出的一件事是，上面的定义显式地关联了类型参数名称和方法名称。这是对那些认为Pair缺乏语义信息的观点的回答。实际上，方法getL的意思是“给我与类型参数L的类型相对应的元素”，这意味着什么。|194308|编辑:下面是一个简单的实用程序类，它可以使生活变得更容易：|194309|class+Pairs+{
++++static+<L,R>+Pair<L,R>+makePair(final+L+l,+final+R+r){
++++++++return+new+Pair<L,R>(){
++++++++++++public+L+getL()+{+return+l;+}
++++++++++++public+R+getR()+{+return+r;+}+++
++++++++};
++++}
}|194310|用法：|194311|return+Pairs.makePair(new+Integer(100),+"123");|194312|entityMap^0|N|4|0|0|0|0|K|9|3Q|9|40|9|4A|7|4L|P|5T|18|0|19|4|1W|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1S|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|10|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|11|$]]

According to the nature of Java language, I suppose people do not actually require a <code>Pair</code>, an interface is usually what they need. Here is an example:

<pre><code>interface Pair&lt;L, R&gt; {
 public L getL();
 public R getR();
}
</code></pre>

So, when people want to return two values they can do the following:

<pre><code>... //Calcuate the return value
final Integer v1 = result1;
final String v2 = result2;
return new Pair&lt;Integer, String&gt;(){
 Integer getL(){ return v1; }
 String getR(){ return v2; }
}
</code></pre>

This is a pretty lightweight solution, and it answers the question "What is the semantic of a <code>Pair&lt;L,R&gt;</code>?". The answer is, this is an interface build with two (may be different) types, and it has methods to return each of them. It is up to you to add further semantic to it. For example, if you are using Position and REALLY want to indicate it in you code, you can define <code>PositionX</code> and <code>PositionY</code> that contains <code>Integer</code>, to make up a <code>Pair&lt;PositionX,PositionY&gt;</code>. If JSR 308 is available, you may also use <code>Pair&lt;@PositionX Integer, @PositionY Ingeger&gt;</code> to simplify that.

EDIT:
One thing I should indicate here is that the above definition explicitly relates the type parameter name and the method name. This is an answer to those argues that a <code>Pair</code> is lack of semantic information. Actually, the method <code>getL</code> means "give me the element that correspond to the type of type parameter L", which do means something.

EDIT:
Here is a simple utility class that can make life easier:

<pre><code>class Pairs {
 static &lt;L,R&gt; Pair&lt;L,R&gt; makePair(final L l, final R r){
 return new Pair&lt;L,R&gt;(){
 public L getL() { return l; }
 public R getR() { return r; } 
 };
 }
}
</code></pre>

usage:

<pre><code>return Pairs.makePair(new Integer(100), "123");
</code></pre>

blocks|key|194341|text|最大的问题可能是不能确保A和B上的不可变性(参见如何确保类型参数不可变)，因此hashCode()可能会在集合中插入相同的对后给出不一致的结果(例如，这会给出未定义的行为，参见用可变字段定义相等)。对于特定的(非泛型)对类，程序员可以通过谨慎地选择A和B来确保不可变。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|194342|总之，从@PeterLawrey的答案(java+1.7)中清除泛型的警告：|194343|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)+%2B+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+%7C%7C+(o1+!=+null+&&+o1.equals(o2));
++++}

++++@Override
++++public+String+toString()+{
++++++++return+"("+%2B+first+%2B+",+"+%2B+second+%2B+')';
++++}
}|code-block|syntax|javascript|194344|添加/更正非常受欢迎:)特别是，我不太确定我对Pair<?,+?>的使用。|194345|有关为什么使用此语法的更多信息，请参见确保对象实现可比较的和详细说明函数在Java中？。|194346|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/13666444/java-ensure-that-type-parameters-are-immutable/13667623#13667623|1|http://www.artima.com/lejava/articles/equality.html|2|https://stackoverflow.com/a/3166935/281545|3|https://stackoverflow.com/a/6466779/281545^0|13|A|O|B|0|2G|9|1|0|0|0|N|A|0|J|A|2|Y|9|3|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]|$9|1A|A|1B|1|1C]]|E|$]]|$1|F|3|G|5|6|7|1D|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]|$9|1M|A|1N|1|1O]]|E|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]|10|$5|T|U|V|E|$W|11]]|12|$5|T|U|V|E|$W|13]]]]

The biggest problem is probably that one can't ensure immutability on A and B (see <a href="https://stackoverflow.com/questions/13666444/java-ensure-that-type-parameters-are-immutable/13667623#13667623">How to ensure that type parameters are immutable</a>) so <code>hashCode()</code> may give inconsistent results for the same Pair after is inserted in a collection for instance (this would give undefined behavior, see <a href="http://www.artima.com/lejava/articles/equality.html" rel="nofollow noreferrer">Defining equals in terms of mutable fields</a>). For a particular (non generic) Pair class the programmer may ensure immutability by carefully choosing A and B to be immutable.

Anyway, clearing generic's warnings from @PeterLawrey's answer (java 1.7) :

<pre><code>public class Pair&lt;A extends Comparable&lt;? super A&gt;,
 B extends Comparable&lt;? super B&gt;&gt;
 implements Comparable&lt;Pair&lt;A, B&gt;&gt; {

 public final A first;
 public final B second;

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

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

 @Override
 public int compareTo(Pair&lt;A, B&gt; 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&lt;?, ?&gt;) obj).first)
 &amp;&amp; equal(second, ((Pair&lt;?, ?&gt;) obj).second);
 }

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

 @Override
 public String toString() {
 return "(" + first + ", " + second + ')';
 }
}
</code></pre>

Additions/corrections much welcome :) In particular I am not quite sure about my use of <code>Pair&lt;?, ?&gt;</code>.

For more info on why this syntax see <a href="https://stackoverflow.com/a/3166935/281545">Ensure that objects implement Comparable</a> and for a detailed explanation <a href="https://stackoverflow.com/a/6466779/281545">How to implement a generic <code>max(Comparable a, Comparable b)</code> function in Java?</a>

blocks|key|1193614|text|很多人都在发布Pair代码，这些代码在Map...If中可以作为密钥使用，您要尝试使用一对作为散列键(一个常见的成语)，请务必查看番石榴的Table<R,C,V>：http://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained#Table。对于图边，它们给出了以下示例用法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1193615|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|code-block|syntax|javascript|1193616|Table将两个键映射到一个值，并单独为这两种类型的键提供高效的查找。在我的代码的许多部分中，我已经开始使用这个数据结构而不是Map<Pair<K1,K2>,+V>。有用于密集和稀疏用途的数组、树和其他实现，可以选择指定自己的中间映射类。|1193617|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained#Table^0|7|4|1X|C|2A|27|0|0|0|0|5|1R|J|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Many people are posting <code>Pair</code> code that is usable as a key in a Map...If you're trying to use a pair as a hashing key (a common idiom), be sure to check out Guava's <code>Table&lt;R,C,V&gt;</code>: <a href="http://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained#Table" rel="nofollow">http://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained#Table</a>. They give the following example usage, for graph edges:

<pre><code>Table&lt;Vertex, Vertex, Double&gt; 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
</code></pre>

A <code>Table</code> maps two keys to a single value, and provides efficient lookups for both types of keys alone as well. I've started using this data structure instead of a <code>Map&lt;Pair&lt;K1,K2&gt;, V&gt;</code> in many parts of my code. There are array, tree, and other implementations for both dense and sparse uses, with the option of specifying your own intermediate map classes.

blocks|key|864315|text|对于像Java这样的编程语言，大多数程序员用来表示类似于对的数据结构的替代数据结构是两个数组，数据是通过相同的索引访问的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|864316|示例：http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080|offset|length|864317|这并不理想，因为数据应该绑定在一起，但结果也非常便宜。此外，如果您的用例需要存储协调，那么构建您自己的数据结构会更好。|864318|我的图书馆里有这样的东西|864319|public+class+Pair<First,Second>{..+}|code-block|syntax|javascript|864320|entityMap|0|LINK|mutability|MUTABLE|url|http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080^0|0|3|1S|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

For programming languages like Java, the alternate data structure used by most programmers to represent pair like data-structures are two array, and data is accessed via the same index 

example: <a href="http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080" rel="nofollow">http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080</a>

This isn't ideal as the data should be bound together, but also turn out to be pretty cheap. Also, if your use case demands storing co-ordinates then its better to build your own data structure. 

I've something like this in my library

<pre><code>public class Pair&lt;First,Second&gt;{.. }
</code></pre>

blocks|key|1193672|text|尽管在语法上是相似的，但C%2B%2B和Java有着非常不同的范例。像Java一样编写C%2B%2B是糟糕的C%2B%2B，编写像C%2B%2B这样的Java是糟糕的Java。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1193673|使用基于反射的IDE+(如Eclipse+)，编写“对”类的必要功能是快速而简单的。创建类，定义两个字段，使用各种"Generate“菜单选项在几秒钟内填写类。如果你想要类似的界面，也许你必须尽快输入一个"compareTo“。|1193674|在语言中使用单独的声明/定义选项，C%2B%2B代码生成器就不是那么好了，所以手工编写很少的实用程序类会花费更多时间。因为这对代码是一个模板，所以您不必为不使用的函数付费，还可以为代码分配有意义的类型名，因此关于“无语义”的反对意见并不成立。|1193675|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Despite being syntactically similar, Java and C++ have very different paradigms. Writing C++ like Java is bad C++, and writing Java like C++ is bad Java.

With a reflection based IDE like Eclipse, writing the necessarily functionality of a "pair" class is quick and simple. Create class, define two fields, use the various "Generate XX" menu options to fill out the class in a matter of seconds. Maybe you'd have to type a "compareTo" real quick if you wanted the Comparable interface.

With separate declaration / definition options in the language C++ code generators aren't so good, so hand writing little utility classes is more time consuming tedium. Because the pair is a template, you don't have to pay for functions you don't use, and the typedef facility allows assigning meaningful typenames to the code, so the objections about "no semantics" don't really hold up.

blocks|key|194501|text|android提供了Pair类(http://developer.android.com/reference/android/util/Pair.html)，在这里实现如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|194502|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())+%5E+(second+==+null+?+0+:+second.hashCode());
++++}

++++public+static+<A,+B>+Pair+<A,+B>+create(A+a,+B+b)+{
++++++++return+new+Pair<A,+B>(a,+b);
++++}
}|code-block|syntax|javascript|194503|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.android.com/reference/android/util/Pair.html^0|A|4|G|1P|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

android provides <code>Pair</code>class (<a href="http://developer.android.com/reference/android/util/Pair.html">http://developer.android.com/reference/android/util/Pair.html</a>) , here the implementation:

<pre><code>public class Pair&lt;F, S&gt; {
 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&lt;?, ?&gt; p = (Pair&lt;?, ?&gt;) o;
 return Objects.equal(p.first, first) &amp;&amp; Objects.equal(p.second, second);
 }

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

 public static &lt;A, B&gt; Pair &lt;A, B&gt; create(A a, B b) {
 return new Pair&lt;A, B&gt;(a, b);
 }
}
</code></pre>

blocks|key|864353|text|com.sun.tools.javac.util.Pair是一对的简单实现。它可以在jdk1.7.0_51\lib\tools.jar中找到。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|864354|除了org.apache.commons.lang3.tuple.Pair之外，它不仅仅是一个接口。|864355|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

com.sun.tools.javac.util.Pair is an simple implementation of a pair. 
It can be found in jdk1.7.0_51\lib\tools.jar.

Other than the org.apache.commons.lang3.tuple.Pair, it's not just an interface.

blocks|key|860019|text|你可以使用谷歌的AutoValue库--+https://github.com/google/auto/tree/master/value。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|860020|您创建一个非常小的抽象类并使用@AutoValue对其进行注释，注释处理器将为您生成一个具有值语义的具体类。|860021|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/google/auto/tree/master/value^0|L|1C|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

You can use Google's AutoValue library - <a href="https://github.com/google/auto/tree/master/value" rel="nofollow">https://github.com/google/auto/tree/master/value</a>.

You create a very small abstract class and annotate it with @AutoValue and the annotation processor generates a concrete class for you that has a value semantic.

blocks|key|194568|text|JavaFX+(它与Java+8捆绑在一起)有Pair<+A，B>类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194569|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

JavaFX (which comes bundled with Java 8) has the Pair&lt; A,B > class

blocks|key|1193805|text|Map.Entry接口非常接近c%2B%2B对。看看具体的实现，比如AbstractMap.SimpleEntry和AbstractMap.SimpleImmutableEntry，第一项是getKey()，第二项是getValue()。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1193806|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/7/docs/api/java/util/Map.Entry.html|1|http://docs.oracle.com/javase/7/docs/api/java/util/AbstractMap.SimpleEntry.html^0|0|9|0|U|N|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Map.Entry.html" rel="noreferrer">Map.Entry</a> interface come pretty close to c++ pair. Look at the concrete implementation, like <a href="http://docs.oracle.com/javase/7/docs/api/java/util/AbstractMap.SimpleEntry.html" rel="noreferrer">AbstractMap.SimpleEntry</a> and AbstractMap.SimpleImmutableEntry
First item is getKey() and second is getValue().

blocks|key|864394|text|为了您的方便，这里有一些具有多个元组的库：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|864395|JavaTuples。1-10级的元组是它的全部。|unordered-list-item|offset|length|864396|JavaSlang。从0-8度的元组和许多其他功能的好东西。|864397|jOOλ。从0-16度的元组和其他一些功能性的好东西。(免责声明，我在维护公司工作)|864398|函数式Java。从0-8度的元组和许多其他功能的好东西。|864399|还提到了至少包含Pair元组的其他库。|style|CODE|864400|具体来说，在使用大量结构化类型(而不是标称类型(正如公认的答案所主张的那样)+)的函数式编程环境中，这些库及其元组非常有用。|864401|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javatuples.org/|1|http://javaslang.com/|2|https://github.com/jOOQ/jOOL|3|http://www.functionaljava.org/|4|https://stackoverflow.com/a/156685/521799^0|0|0|A|0|0|0|9|1|0|0|4|2|0|0|7|3|0|8|4|0|O|D|4|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@$E|1A|F|1B|1|1C]]|A|$]]|$1|G|3|H|5|D|7|1D|8|@]|9|@$E|1E|F|1F|1|1G]]|A|$]]|$1|I|3|J|5|D|7|1H|8|@]|9|@$E|1I|F|1J|1|1K]]|A|$]]|$1|K|3|L|5|D|7|1L|8|@]|9|@$E|1M|F|1N|1|1O]]|A|$]]|$1|M|3|N|5|6|7|1P|8|@$E|1Q|F|1R|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1S|8|@]|9|@$E|1T|F|1U|1|1V]]|A|$]]|$1|S|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]|14|$5|V|W|X|A|$Y|15]]|16|$5|V|W|X|A|$Y|17]]]]

Here are some libraries that have multiple degrees of tuples for your convenience:

<ul>
<li><a href="http://www.javatuples.org" rel="nofollow noreferrer">JavaTuples</a>. Tuples from degree 1-10 is all it has. </li>
<li><a href="http://javaslang.com" rel="nofollow noreferrer">JavaSlang</a>. Tuples from degree 0-8 and lots of other functional goodies. </li>
<li><a href="https://github.com/jOOQ/jOOL" rel="nofollow noreferrer">jOOλ</a>. Tuples from degree 0-16 and some other functional goodies. (Disclaimer, I work for the maintainer company) </li>
<li><a href="http://www.functionaljava.org" rel="nofollow noreferrer">Functional Java</a>. Tuples from degree 0-8 and lots of other functional goodies. </li>
</ul>

Other libraries have been mentioned to contain at least the <code>Pair</code> tuple.

Specifically, in the context of functional programming which makes use of a lot of structural typing, rather than nominal typing (<a href="https://stackoverflow.com/a/156685/521799">as advocated in the accepted answer</a>), those libraries and their tuples come in very handy.

blocks|key|860081|text|好消息JavaFX有一个键值对。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|860082|只需将JavaFX添加为依赖项并导入javafx.util.Pair，就可以像在C%2B%2B中一样使用。|offset|length|style|CODE|860083|Pair+<Key,+Value>+|code-block|syntax|javascript|860084|例如：|860085|Pair+<Integer,+Integer>+pr+=+new+Pair<Integer,+Integer>()

pr.get(key);//+will+return+corresponding+value|860086|entityMap^0|0|I|G|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Good News JavaFX has a key value Pair.
Just add JavaFX as a dependency and import <code>javafx.util.Pair</code>, and use simply as in C++.
<pre><code>Pair &lt;Key, Value&gt; 
</code></pre>
e.g.
<pre><code>Pair &lt;Integer, Integer&gt; pr = new Pair&lt;Integer, Integer&gt;()

pr.get(key);// will return corresponding value
</code></pre>

blocks|key|1193873|text|使用新版本的隆布克，您可以编译这个可爱的类：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1193874|@Value(staticConstructor+=+"of")+public+class+Pair+<E>+{
++E+first,+second;
}|code-block|syntax|javascript|1193875|并使用它，如：Pair<Value>+pairOfValues+=+Pair.of(value1,+value2);|style|CODE|1193876|entityMap|0|LINK|mutability|MUTABLE|url|https://projectlombok.org/^0|6|3|0|0|0|7|1F|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

With new version of <a href="https://projectlombok.org/" rel="nofollow">Lombok</a> you can compile that cute class:

<pre><code>@Value(staticConstructor = "of") public class Pair &lt;E&gt; {
 E first, second;
}
</code></pre>

and use it like: <code>Pair&lt;Value&gt; pairOfValues = Pair.of(value1, value2);</code>

blocks|key|194646|text|Collections.singletonMap(left,+rigth);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|194647|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Collections.singletonMap(left, rigth);
</code></pre>

blocks|key|1193908|text|Brian，Paul和Stuart+Marks+解释为什么在Devoxx'14的QA会议期间。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1193909|一旦引入价值类型，在标准库中拥有泛型对类就会变成技术债务。|1193910|另见：Java+8有对或元组吗？|1193911|entityMap|0|LINK|mutability|MUTABLE|url|https://youtu.be/ischZmi5oi4?t=33m22s|1|http://openjdk.java.net/projects/valhalla/|2|https://stackoverflow.com/questions/24328679/does-java-se-8-have-pairs-or-tuples/24336841#24336841^0|O|5|0|0|4|4|1|0|3|D|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]]]

Brian Goetz, Paul Sandoz and Stuart Marks <a href="https://youtu.be/ischZmi5oi4?t=33m22s" rel="nofollow noreferrer">explain why</a> during QA session at Devoxx'14.

Having generic pair class in standard library will turn into technical debt once <a href="http://openjdk.java.net/projects/valhalla/" rel="nofollow noreferrer">value types</a> introduced.

See also: <a href="https://stackoverflow.com/questions/24328679/does-java-se-8-have-pairs-or-tuples/24336841#24336841">Does Java SE 8 have Pairs or Tuples?</a>

blocks|key|860107|text|您可以使用javafx实用程序类Pair，它与c%2B%2B中的对<>具有相同的用途。https://docs.oracle.com/javafx/2/api/javafx/util/Pair.html|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|860108|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javafx/2/api/javafx/util/Pair.html^0|G|4|13|1M|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

You can use javafx utility class, <code>Pair</code> which serves the same purpose as pair &lt;> in c++. <a href="https://docs.oracle.com/javafx/2/api/javafx/util/Pair.html" rel="noreferrer">https://docs.oracle.com/javafx/2/api/javafx/util/Pair.html</a>

blocks|key|194718|text|安德烈亚斯·克里的回答其实很好。任何Java造成的困难，您可能不应该做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194719|在我的经验中，结对最常见的用法是来自方法的多个返回值，以及作为hashmap中的值(通常由字符串索引)。|194720|在后一种情况下，我最近使用了一个数据结构，如下所示：|194721|class+SumHolder{MyObject+trackedObject,+double+sum};|code-block|syntax|javascript|194722|您的整个“对”类与一般的“对”类的代码数量大致相同，但具有描述性名称的优势。它可以在所使用的方法中直接定义，这将消除具有公共变量等典型问题。换句话说，对于这种用法(由于命名的成员)，它绝对比一对好，而且不会更糟。|194723|如果您实际上想要一个“对”作为hashmap的键，那么您实际上是在创建一个双键索引。我认为这可能是“对”大大减少代码的一种情况。这并不是很容易，因为您可以在您的小数据类上使用eclipse+generate+/散列，但这将是一个很好的更多代码。在这里，一对将是一个快速修复，但如果您需要一个双索引哈希，谁说你不需要一个n索引哈希？数据类解决方案将扩展，除非您嵌套它们，否则这对解决方案不会增加！|194724|因此，第二个例子，从一个方法返回，有点困难。您的类需要更多的可见性(调用者也需要看到它)。您可以在方法之外定义它，但可以在类中定义它，就像上面那样。此时，您的方法应该能够返回一个MyClass.SumHolder对象。调用方可以看到返回对象的名称，而不仅仅是“对”。请再次注意，包级别的“默认”安全性非常好--它的限制性很强，不应该给自己带来太多麻烦。总比“对”对象好。|194725|我可以看到的另一种情况是对对的使用是一个公共api，它为当前包之外的调用者提供返回值。为此，我只创建一个真正的对象--最好是不可变的。最终，调用方将共享此返回值，并且使其可更改可能会出现问题。这是另一种情况，这对对象是更糟的--大多数对是不可变的。|194726|所有这些情况的另一个优点--+java类扩展了，我的sum类需要第二个sum和一个“创建”标志，当我完成时，我就不得不丢弃这对并带其他的东西，但是如果这对有意义的话，我的4个值的类至少还是有意义的。|194727|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

The answer by @Andreas Krey is actually good. Anything Java makes difficult, you probably shouldn't be doing.

The most common uses of Pair's in my experience have been multiple return values from a method and as VALUES in a hashmap (often indexed by strings).

In the latter case, I recently used a data structure, something like this:

<pre><code>class SumHolder{MyObject trackedObject, double sum};
</code></pre>

There is your entire "Pair" class, pretty much the same amount of code as a generic "Pair" but with the advantage of descriptive names. It can be defined in-line right in the method it's used which will eliminate typical problems with public variables and the like. In other words, it's absolutely better than a pair for this usage (due to the named members) and no worse. 

If you actually want a "Pair" for the key of a hashmap you are essentially creating a double-key index. I think this may be the one case where a "Pair" is significantly less code. It's not really easier because you could have eclipse generate equals/hash on your little data class, but it would be a good deal more code. Here a Pair would be a quick fix, but if you need a double-indexed hash who's to say you don't need an n-indexed hash? The data class solution will scale up, the Pair will not unless you nest them!

So the second case, returning from a method, is a bit harder. Your class needs more visibility (the caller needs to see it too). You can define it outside the method but inside the class exactly as above. At that point your method should be able to return a MyClass.SumHolder object. The caller gets to see the names of the returned objects, not just a "Pair". Note again that the "Default" security of package level is pretty good--it's restrictive enough that you shouldn't get yourself into too much trouble. Better than a "Pair" object anyway.

The other case I can see a use for Pairs is a public api with return values for callers outside your current package. For this I'd just create a true object--preferably immutable. Eventually a caller will share this return value and having it mutable could be problematic. This is another case of the Pair object being worse--most pairs cannot be made immutable.

Another advantage to all these cases--the java class expands, my sum class needed a second sum and a "Created" flag by the time I was done, I would have had to throw away the Pair and gone with something else, but if the pair made sense, my class with 4 values still makes at least as much sense.

blocks|key|194741|text|另一个简洁的lombok实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194742|import+lombok.Value;

@Value(staticConstructor+=+"of")
public+class+Pair<F,+S>+{
++++private+final+F+first;
++++private+final+S+second;
}|code-block|syntax|javascript|194743|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

another terse lombok implementation

<pre><code>import lombok.Value;

@Value(staticConstructor = "of")
public class Pair&lt;F, S&gt; {
 private final F first;
 private final S second;
}
</code></pre>

blocks|key|864466|text|试试VAVR元组。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|864467|vavr不仅有一组很好的元组类型，而且对函数式编程也有很好的支持。|864468|entityMap|0|LINK|mutability|MUTABLE|url|https://www.vavr.io/vavr-docs/#_tuples^0|2|6|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Try <a href="https://www.vavr.io/vavr-docs/#_tuples" rel="nofollow noreferrer">VAVR Tuples</a>.
Not only does vavr have a good set of tuple types, it has great support for functional programming, too.

blocks|key|1193993|text|Spring数据有一对，可以像下面这样使用，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1193994|Pair<S,+T>+pair+=+Pair.of(S+type+data,+T+type+data)|code-block|syntax|javascript|1193995|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Spring data has a Pair and can be used like below,
<pre><code>Pair&lt;S, T&gt; pair = Pair.of(S type data, T type data)
</code></pre>

blocks|key|860140|text|虽然这个问题已经存在了十年，但我确实觉得有必要提到，从Java14开始，记录可以为这个问题提供一个非常简单和轻量级的解决方案，而不需要任何形式的外部库或依赖项。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|860141|例如，为了实现所需的功能，只需要以下记录类声明：|860142|record+Pair<K,+V>(K+key,+V+value)+{+}|code-block|syntax|javascript|860143|这样的记录类可以这样使用：|860144|//+Declare+a+pair+object+containing+two+integers
var+integerIntegerPair+=+new+Pair<>(1,+2);

//+Declare+a+pair+object+containing+a+String+and+an+integer
var+stringIntegerPair+=+new+Pair<>("String",+20);

//+Declare+a+pair+object+containing+two+other+pairs!
var+pairPairPair+=+new+Pair<>(new+Pair<>(1,+2),+new+Pair<>("String",+20));|860145|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/en/java/javase/14/language/records.html^0|10|2|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Although this question is over a decade old, I do feel the need to mention that, as of Java 14, <a href="https://docs.oracle.com/en/java/javase/14/language/records.html" rel="nofollow noreferrer">Records</a> can provide a very simple and light-weight solution to this problem without the need for any form of external library or dependencies.
For example, the following record class declaration would be all that's required in order to achieve the desired functionality:
<pre><code>record Pair&lt;K, V&gt;(K key, V value) { }
</code></pre>
Such a record class could be used as so:
<pre><code>// Declare a pair object containing two integers
var integerIntegerPair = new Pair&lt;&gt;(1, 2);

// Declare a pair object containing a String and an integer
var stringIntegerPair = new Pair&lt;&gt;(&quot;String&quot;, 20);

// Declare a pair object containing two other pairs!
var pairPairPair = new Pair&lt;&gt;(new Pair&lt;&gt;(1, 2), new Pair&lt;&gt;(&quot;String&quot;, 20));
</code></pre>

Is there a good reason why there is no <code>Pair&lt;L,R&gt;</code> in Java? What would be the equivalent of this C++ construct? I would rather avoid reimplementing my own.

It seems that 1.6 is providing something similar (<code>AbstractMap.SimpleEntry&lt;K,V&gt;</code>), but this looks quite convoluted.

What is the equivalent of the C++ Pair<L,R> in Java?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Java中没有Pair<L,R>有一个很好的理由吗？这个C++结构的等效性是什么？我宁愿避免重新实施我自己的。1.6似乎提供了类似的东西(AbstractMap.SimpleEntry<K,V>)，但这看起来相当复杂。

问Java中的C++ Pair<L，R>相当于什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的C++ Pair<L，R>相当于什么？EN