C ++ Pair＆lt; L、R＆gt;と同等のものは何ですか？ Javaで？
https://stackoverflow.com/questions/156275
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
Javaに Pair＆lt; L、R＆gt; がない理由はありますか？このC ++コンストラクトと同等のものは何でしょうか？自分で再実装することは避けたいです。
1.6 は類似したもの（ AbstractMap.SimpleEntry＆lt; K、V＆gt; ）を提供しているようですが、これはかなり複雑に見えます。
解決
compのスレッド.lang.java.help 、Hunter Gratznerは、Javaの Pair コンストラクトの存在に対していくつかの引数を与えています。主な議論は、クラス Pair は2つの値の関係についてのセマンティクスを伝えないということです（「最初」と「2番目」の意味をどうやって知るのですか？）。
Pair クラスで作成したアプリケーションごとに、Mikeが提案したような非常に単純なクラスを作成することをお勧めします。 Map.Entry は、名前の意味を伝えるペアの例です。
要約すると、私の意見では、クラス Position（x、y）、クラス Range（begin、end）およびクラス< code> Entry（key、value）汎用の Pair（first、second）ではなく、何をすべきかについて何も教えてくれません。
他のヒント
これはJavaです。説明的なクラス名とフィールド名を使用して、独自の調整されたPairクラスを作成する必要があります。hashCode（）/ equals（）を記述するか、Comparableを何度も実装することでホイールを再発明することを忘れないでください。
HashMap互換のペアクラス：
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 + hashSecond) * hashSecond + hashFirst;
}
public boolean equals(Object other) {
if (other instanceof Pair) {
Pair otherPair = (Pair) other;
return
(( this.first == otherPair.first ||
( this.first != null && otherPair.first != null &&
this.first.equals(otherPair.first))) &&
( this.second == otherPair.second ||
( this.second != null && otherPair.second != null &&
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;
}
}
私が思いつく最短のペアは、 Lombok を使用して次のとおりです。
@Data
@AllArgsConstructor(staticName = "of")
public class Pair<F, S> {
private F first;
private S second;
}
@arturhからの回答（比較可能性を除く）のすべての利点があり、 hashCode 、 equals 、 toString 、および静的な＆＃8220; constructor＆＃8221;。
Apache Commons Lang 3.0+には、いくつかのペアクラスがあります。 http：// commons .apache.org / proper / commons-lang / apidocs / org / apache / commons / lang3 / tuple / package-summary.html
ペアを実装する別の方法。
- パブリックな不変フィールド、つまり単純なデータ構造
- 同等。
- 単純なハッシュと等しい。
-
単純なファクトリなので、型を指定する必要はありません。例えばPair.of（＆quot; hello＆quot ;, 1）;
public class Pair<FIRST, SECOND> implements Comparable<Pair<FIRST, SECOND>> { public final FIRST first; public final SECOND second; private Pair(FIRST first, SECOND second) { this.first = first; this.second = second; } public static <FIRST, SECOND> Pair<FIRST, SECOND> of(FIRST first, SECOND second) { return new Pair<FIRST, SECOND>(first, second); } @Override public int compareTo(Pair<FIRST, SECOND> 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) && 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 + ')'; } }
http://www.javatuples.org/index.html はどうですか非常に便利です。
javatuplesは、1〜10個の要素のタプルクラスを提供します。
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());
}
androidは Pair クラスを提供します（ 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);
}
}
最大の問題は、おそらくAとBの不変性を保証できないことです（型パラメーターが不変であることを確認する方法）。 hashCode（）は、 after が挿入された後の同じペアに対して一貫性のない結果をもたらす可能性がありますインスタンスのコレクション（これにより、未定義の動作が発生します。可変フィールドに関して等号を定義）。特定の（非ジェネリック）Pairクラスの場合、プログラマーは不変であるようにAとBを慎重に選択することで不変を保証できます。
とにかく、@ PeterLawreyの回答（generic 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＆lt;？、？＆gt; の使用についてはよくわかりません。
この構文の理由の詳細については、 Comparableを実装するオブジェクトを確認するおよび詳細な説明についてはJavaで汎用の max（Comparable a、Comparable b）関数を実装する方法？
Javaにはペアはありません。ペアに追加機能を直接追加する場合（Comparableなど）は、型をバインドする必要があるためです。 C ++では気にしません。ペアを構成する型に operator＆lt; がない場合、 pair :: operator＆lt; もコンパイルされません。
境界のない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));
これは良いことですが、今回はペアの型引数として比較できない型を使用することはできません。 いくつかのユーティリティクラスでペアの多くのコンパレータを使用できますが、C ++の人々はそれを取得できない可能性があります。別の方法は、型引数に異なる境界を持つ型階層で多くのクラスを記述することですが、可能性のある境界とその組み合わせが多すぎます...
JavaFX（Java 8にバンドルされています）にはペアがあります＆lt; A、B＆gt;クラス
他の多くの人がすでに述べているように、Pairクラスが有用かどうかは、ユースケースに本当に依存します。
プライベートヘルパー関数の場合、コードを読みやすくし、そのすべてのボイラープレートコードでさらに別の値クラスを作成する努力の価値がない場合、Pairクラスを使用することは完全に合法であると思います。
一方、抽象化レベルで、2つのオブジェクトまたは値を含むクラスのセマンティクスを明確に文書化する必要がある場合は、そのクラスを作成する必要があります。通常、データがビジネスオブジェクトの場合に当てはまります。
いつものように、熟練した判断が必要です。
2番目の質問には、Apache CommonsライブラリのPairクラスをお勧めします。これらは、Javaの拡張標準ライブラリと見なされる場合があります。
https：// commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html
Apache Commonsの EqualsBuilder 、 HashCodeBuilder および ToStringBuilder 。これにより、ビジネスオブジェクトの値クラスを簡単に記述できます。
グッドニュース Java にキー値Pairが追加されました。
ちょうどインポート javafx.util.Pair ;
そして c ++ のように単純に使用します。
Pair < Key , Value >
e.g。
Pair < Integer , Integer > pr = new Pair<Integer , Integer>()
pr.get(key); // will return corresponding value
ペア＆lt;＆gt;と同じ目的を果たすjavafxユーティリティクラス Pair を使用できます。 C ++で。 https://docs.oracle.com/javafx/2/api /javafx/util/Pair.html
Collections.singletonMap(left, rigth);
Java言語の性質によると、人々は実際には Pair を必要としないと思います。通常、インターフェースは必要なものです。次に例を示します。
interface Pair<L, R> {
public L getL();
public R getR();
}
したがって、人々が2つの値を返したい場合、次のことができます。
... //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; }
}
これは非常に軽量なソリューションであり、「 Pair＆lt; L、R＆gt; ？の意味は何ですか？」という質問に答えます。答えは、これは2つの（異なる場合があります）タイプのインターフェースビルドであり、それぞれを返すメソッドがあります。さらにセマンティックを追加するのはあなた次第です。たとえば、Positionを使用しており、コード内でそれを実際に示したい場合、 Integer を含む PositionX および PositionY を定義して、 Pair＆lt; PositionX、PositionY＆gt; を作成します。 JSR 308が利用可能な場合、 Pair＆lt; @PositionX Integer、@PositionY Ingeger＆gt; を使用して、それを単純化することもできます。
編集：
ここで示す必要があることの1つは、上記の定義が型パラメーター名とメソッド名を明示的に関連付けていることです。これは、 Pair にはセマンティック情報が不足しているという主張に対する答えです。実際、メソッド getL は、「型パラメーターLの型に対応する要素を教えてください」という意味で、これは何かを意味します。
編集： 簡単なユーティリティクラスを次に示します。
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; }
};
}
}
使用法：
return Pairs.makePair(new Integer(100), "123");
構文的には似ていますが、JavaとC ++には非常に異なるパラダイムがあります。 JavaのようなC ++を書くのは悪いC ++であり、C ++のようなJavaを書くのは悪いJavaです。
EclipseのようなリフレクションベースのIDEで、「ペア」の必然的な機能を記述します。クラスは素早く簡単です。クラスを作成し、2つのフィールドを定義して、さまざまな「XXを生成」を使用します。数秒でクラスに記入するメニューオプション。たぶん＆quot; compareTo＆quot;を入力する必要があるでしょうComparableインターフェースが必要な場合は非常に高速です。
言語の宣言/定義オプションを個別に使用する場合、C ++コードジェネレーターはあまり良くないので、小さなユーティリティクラスを手書きするのは時間がかかります。ペアはテンプレートであるため、使用しない関数に料金を支払う必要はありません。また、typedef機能を使用すると、意味のあるタイプ名をコードに割り当てることができます。本当に持ちこたえないでください。
ペアは、複雑なジェネリックの基本的な構築単位になるのに適しています。たとえば、これは私のコードからのものです。
WeakHashMap<Pair<String, String>, String> map = ...
HaskellのTupleとまったく同じです
Javaなどのプログラミング言語では、データ構造のようなペアを表すためにほとんどのプログラマーが使用する代替データ構造は2つの配列であり、データは同じインデックスを介してアクセスされます
例： http：//www-igm.univ -mlv.fr/~lecroq/string/node8.html#SECTION0080
これは、データを結合する必要があるため理想的ではありませんが、かなり安価であることが判明しました。また、ユースケースで座標の保存が必要な場合は、独自のデータ構造を構築することをお勧めします。
ライブラリにこのようなものがあります
public class Pair<First,Second>{.. }
GoogleのAutoValueライブラリを使用できます- https://github.com/google/auto / tree / master / value 。
非常に小さな抽象クラスを作成し、@ AutoValueで注釈を付けます。注釈プロセッサは、値セマンティクスを持つ具体的なクラスを生成します。
ここでは、利便性のために複数のレベルのタプルを持つライブラリをいくつか示します。
- JavaTuples 。次数1〜10のタプルがすべてです。
- JavaSlang 。 0から8度のタプルおよびその他の多くの機能グッズ。
- jOO＆＃955; 。 0〜16度のタプルおよびその他の機能的なグッズ。 （免責事項、私はメンテナー会社で働いています）
- Functional Java 。 0から8度のタプルおよびその他の多くの機能グッズ。
少なくとも Pair タプルを含む他のライブラリが言及されています。
具体的には、名目上のタイピングではなく、多くの構造タイピングを使用する関数型プログラミングのコンテキストで（受け入れられた回答）、それらのライブラリとそのタプルは非常に便利です。
Simple way Object []-＃1091として使用できます。次元タプル
ここでは、2つの値の順序が意味するすべてのペアの実装が散らばっていることに気付きました。ペアを考えるとき、2つのアイテムの組み合わせでは、2つの順序は重要ではないと思います。コレクションでの望ましい動作を保証するための hashCode および equals オーバーライドを使用した、順序付けられていないペアの実装を次に示します。クローンも可能です。
/**
* 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.<p>
* 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.<p>
* Mind that the order of the type parameters T and U is of no importance. A
* Pair<T, U> can still return <code>true</code> for method <code>equals</code>
* called with a Pair<U, T> argument.<p>
* 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.<p>
*/
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<T, U></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 <v1, v2> of
* this pair and <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.<p>
* The type parameters that were used for the other pair are of no importance.
* A Pair<T, U> can return <code>true</code> for equality testing with
* a Pair<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 += (object2Null ? 0 : object2.hashCode());
return hashCode;
}
}
この実装は適切に単体テストされており、セットおよびマップでの使用が試行されています。
私はこれをパブリックドメインでリリースすると主張していません。これは、アプリケーションで使用するために作成したばかりのコードです。使用する場合は、直接コピーを作成したり、コメントや名前を少し変更したりしないでください。ドリフトをキャッチしますか？
非常にシンプルで使いやすいバージョンが必要な場合は、 https：/で入手できます。 /github.com/lfac-pt/Java-Pair 。また、改善も大歓迎です！
com.sun.tools.javac.util.Pairは、ペアの単純な実装です。 jdk1.7.0_51 \ lib \ tools.jarにあります。
org.apache.commons.lang3.tuple.Pair以外は、単なるインターフェースではありません。
別の簡潔なロンボクの実装
import lombok.Value;
@Value(staticConstructor = "of")
public class Pair<F, S> {
private final F first;
private final S second;
}
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;
}
}
使用法：
Pair<Integer, String> pair = Pair.createPair(1, "test");
pair.getElement0();
pair.getElement1();
不変、ペアのみ！
