16

過去の試験問題で見つけたこの質問を試してみて、次のJava試験の準備をします。

物事のペアを表すためのジェネリッククラスPairを提供します。クラスは、コンストラクター、ペアの最初のメンバーを取得するためのメソッド、ペアの2番目のメンバーを取得するためのメソッド、ペアの最初のメンバーを設定するためのメソッド、ペアの2番目のメンバーを設定するためのメソッドを提供する必要があります。クラスは、ペアの最初のメンバー用と2番目のメンバー用の2つのタイプでパラメーター化する必要があります。

これはこの質問の正しい実装ですか？

public class Pair<firstThing, secondThing>{
   private firstThing first;//first member of pair
   private secondThing second;//second member of pair

   public Pair(firstThing first, secondThing second){
     this.first = first;
     this.second = second;
   }

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

   public void setSecond(secondThing second) {
     this.second = second;
   }

   public thing getFirst() {
     return this.first;
   }

   public thing getSecond() {
     return this.second;
   }
}
4

15 に答える 15

23

ほとんど。私はそれを次のように書きます：

public class Pair<F, S> {
    private F first; //first member of pair
    private S second; //second member of pair

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

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

    public void setSecond(S second) {
        this.second = second;
    }

    public F getFirst() {
        return first;
    }

    public S getSecond() {
        return second;
    }
}

編集：@karmakazeのコメントに同意します。コードはセッターをスキップし、不変に保つために1番目と2番目のファイナルを作成する必要があります。

于 2011-05-18T13:04:57.710 に答える
11

通常、Pairクラスの必要性は、より大きなプロジェクトで発生します。現在のプロジェクトにペアクラスを（再）実装しようとしています（以前の実装にはアクセスできないため）。

通常、インスタンスを作成するための便利な機能を備えた不変のPOJOにします。例えば：

public class Pair<T,U>
{
    public final T first;
    public final U second;
    public static <T,U> Pair<T,U> of(T first, U second);
}

エンドユーザーが次のように記述できるようにします。

return Pair.of (a, b);

と

Pair<A,B> p = someThing ();
doSomething (p.first);
doSomethingElse (p.second);

上記のように、PairクラスはhashCode（）、equals（）、オプションですが便利なtoString（）も実装する必要があります。これらは、TとUでサポートされている場合に使用するためにclone（）とcompareTo（）として使用できます。これらのコントラクトがPairクラスによってどのようにサポートされるかを説明するために必要です。

于 2013-09-23T12:11:49.437 に答える
5

標準のJavaクラスAbstractMap.SimpleEntryおよびAbstractMap.SimpleImmutableEntryの実装を調べることができます。ソースをグーグルするのはとても簡単です：

于 2013-04-18T17:15:03.080 に答える
5

これがAndroidSDKからの実装です

/**
 * Container to ease passing around a tuple of two objects. This object provides a sensible
 * implementation of equals(), returning true if equals() is true on each of the contained
 * objects.
 */
public class Pair<F, S> {
    public final F first;
    public final S second;

    /**
     * Constructor for a Pair.
     *
     * @param first the first object in the Pair
     * @param second the second object in the pair
     */
    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    /**
     * Checks the two objects for equality by delegating to their respective
     * {@link Object#equals(Object)} methods.
     *
     * @param o the {@link Pair} to which this one is to be checked for equality
     * @return true if the underlying objects of the Pair are both considered
     *         equal
     */
    @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);
    }

    /**
     * Compute a hash code using the hash codes of the underlying objects
     *
     * @return a hashcode of the Pair
     */
    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    /**
     * Convenience method for creating an appropriately typed pair.
     * @param a the first object in the Pair
     * @param b the second object in the pair
     * @return a Pair that is templatized with the types of a and b
     */
    public static <A, B> Pair <A, B> create(A a, B b) {
        return new Pair<A, B>(a, b);
    }
}
于 2013-09-03T07:43:01.373 に答える
3

いいえ。引用：

「クラスは2つのタイプでパラメーター化する必要があります...」

私は彼らが次の点で期待していると思います：

public class Pair<ThingA, ThingB>
于 2011-05-18T12:54:16.373 に答える
2

通常、ジェネリックペアタイプには1つではなく、 2つのジェネリックタイプパラメーターがあります。したがって、（たとえば）を持つことができますPair<String, Integer>。これは通常、IMOの方が便利です。

また、「thing」よりもタイプパラメータのより一般的な名前を検討することをお勧めします。たとえば、Pair<A, B>またはを使用できPair<T, U>ます。

于 2011-05-18T12:54:22.520 に答える
2

ゲッターが壊れている

public thing getFirst() {
  return thing.first;
}

public thing getSecond() {
  return thing.second;
}

thingに置き換える必要がありますthis

于 2011-05-18T12:56:34.227 に答える
2

編集後は良さそうです。

hashCodeただし、実際にはとメソッドを実装してequals、同じオブジェクトを含む2つのペアが互いに等しくなり、HashMapのキーとして使用できるようにする必要があります。そしてtoString、あなたが寛大に感じているなら。これらのメソッドは、与えられた要件を満たすために必須ではありませんが、優れたプログラマーが追加するものです。

于 2011-05-18T13:26:27.233 に答える
1

クラスは、ペアの最初のメンバー用と2番目のメンバー用の2つのタイプでパラメーター化する必要があります。

パラメータは1つだけです。

のようなものが必要で、最初Pair<F,S>に使用する場合はFを使用し、2番目に使用する場合thingはSを使用しますthing。

于 2011-05-18T12:55:41.080 に答える
1

いいえ。動作するかどうかを確認するためにコーディングしてみましたか？

要件のこの部分を見逃しているようです。

クラスは、ペアの最初のメンバー用と2番目のメンバー用の2つのタイプでパラメーター化する必要があります。

つまり、クラスはおそらく次のようなものとして定義する必要があります。

public class Pair<T1, T2>

それに応じて他のメソッドが更新されました。（ちなみに、私はT1とT2を使用してタイプを参照しました。これは、慣例により、短い-1または2文字の識別子が使用されるためです）。

また、

return thing.first;

と

return thing.second;

あなたの例のように、は機能thingしません。これはタイプであり、オブジェクトではありません。ここに何を返したいか考えてください。メソッドを呼び出す必要もありますか？

変更を加えたら、それをコーディングし、単体テストまたは簡単なテストハーネスを作成して、それが機能するかどうかを確認します。

于 2011-05-18T13:00:45.540 に答える
1

ApacheCommonsLangには汎用ペアの実装があります

https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html

于 2018-02-27T13:09:55.260 に答える
0

thingは、異常な表記の型変数Tです。通常、大文字の後者を1つ使用します（のように）。次に、型変数にはメソッドがないため、ゲッターはコンパイルされません。

迅速な改善：すべてthingをT

ゲッターのクイックフィックス：

public T getFirst() {
 return first;
}

public T getSecond() {
 return second;
}

1つの要件は、ペアメンバーに2つの異なるタイプを許可することでした。したがって、クラスの署名は次のようになります。

public Pair<S,T> {
  private S first;
  private T second;
  //...
}
于 2011-05-18T12:55:28.630 に答える
0

ペアの私のバージョン。これは比較も処理します。PS：ほとんどのコードはAOSPから取得されます。

package util;

import java.util.Objects;

public class Pair<F extends Comparable<F>, S extends Comparable<S>>
  implements Comparable<Pair<F, S>> {

    public final F first;
    public final S second;

    /**
     * Constructor for a Pair.
     *
     * @param first  the first object in the Pair
     * @param second the second object in the pair
     */
    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    /**
     * Checks the two objects for equality by delegating to their respective
     * {@link Object#equals(Object)} methods.
     *
     * @param o the {@link Pair} to which this one is to be checked for equality
     * @return true if the underlying objects of the Pair are both considered
     * equal
     */
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> p = (Pair<?, ?>) o;
        return Objects.equals(p.first, first) && Objects.equals(p.second, second);
    }

    /**
     * Compute a hash code using the hash codes of the underlying objects
     *
     * @return a hashcode of the Pair
     */
    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    /**
     * Convenience method for creating an appropriately typed pair.
     *
     * @param a the first object in the Pair
     * @param b the second object in the pair
     * @return a Pair that is templatized with the types of a and b
     */
    public static <A extends Comparable<A>, B extends Comparable<B>> Pair<A, B> create(A a, B b) {
        return new Pair<>(a, b);
    }

    @Override
    public int compareTo(Pair<F, S> that) {
        int cmp = this.first.compareTo(that.first);
        if (cmp == 0)
            cmp = this.second.compareTo(that.second);
        return cmp;
    }
}
于 2016-03-02T14:11:04.440 に答える
0

私は似たようなものを実装しましたが、静的ビルダーとチェーンセッターを使用しました

public class Pair<R, L> {

private R left;
private L right;

public static <K,V> Pair<K, V> of(K k, V v) {
    return new Pair<K,V>(k, v);
}

public Pair() {}

public Pair(R key, L value) {
    this.left(key);
    this.right(value);
}

public R left() {
    return left;
}

public Pair<R, L> left(R key) {
    this.left = key;
    return this;
}

public L right() {
    return right;
}

public Pair<R, L> right(L value) {
    this.right = value;
    return this;
}
}
于 2017-01-28T12:17:50.033 に答える
0

ジェネリックペアクラスの作成には多くの時間がかかります。使用SimpleEntryがはるかに簡単になります。

static class Pair {
    public static <T, U> Map.Entry<T, U> of(T first, U second) {
        return new AbstractMap.SimpleEntry<>(first, second);
    }
}
于 2021-09-23T16:04:56.803 に答える