Java ジェネリックスの説明

はじめに

ジェネリックは Java の非常に重要な知識ポイントであり、Java コレクション クラス フレームワークで広く使用されています。この記事では、Java ジェネリックの設計をゼロから見ていきます。これには、ワイルドカード処理と煩わしい型の消去が含まれます。

一般的な基本

汎用クラス

最初に単純な Box クラスを定義します:

public class Box {
    private String object;
    public void set(String object) { this.object = object; }
    public String get() { return object; }
}

これは最も一般的なアプローチです。この方法の欠点は、今後 Integer などの他のタイプの要素をロードする必要がある場合、コードを書き直す必要があることです。再利用に関しては、ジェネリックを使用するとこの問題をうまく解決できます。

りー

このようにして、Box クラスを再利用でき、T を任意の型に置き換えることができます:

public class Box<T> {
    // T stands for "Type"
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

一般的なメソッド

ジェネリック クラスについて読んだ後、ジェネリック メソッドを見てみましょう。ジェネリック メソッドの宣言は非常に簡単で、戻り値の型の前に のような形式を追加するだけです。 次のような汎用メソッドを呼び出すことができます:

Box<Integer> integerBox = new Box<Integer>();
Box<Double> doubleBox = new Box<Double>();
Box<String> stringBox = new Box<String>();

または、Java1.7/1.8 で型推論を使用して、Java が対応する型パラメータを自動的に導出できるようにします:

public class Util {
    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}
public class Pair<K, V> {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
    public K getKey()   { return key; }
    public V getValue() { return value; }
}

境界記号

ここで、汎用配列内の特定の要素より大きい要素の数を見つける関数を実装したいと思います。これは次のように実装できます。 しかし、これは明らかに間違っています。short、int、double、long、float、byte、char などのプリミティブ型を除き、他のクラスは演算子 > を使用できない可能性があるため、コンパイラはエラーを報告します。この問題を解決するにはどうすればよいですか？答えは、境界文字を使用することです。

りー

次のようなステートメントを作成することは、型パラメーター T が Comparable インターフェイスを実装するクラスを表すことをコンパイラーに伝えることと同じであり、すべてのクラスが少なくとも CompareTo メソッドを実装することをコンパイラーに伝えることと同じです。

りー

ワイルドカード

ワイルドカードを理解する前に、まず概念を明確にする必要があります。上で定義した Box クラスを次のようなメソッドに追加するとします。 それでは、Box n は現在どのような種類のパラメータを受け入れることができるのでしょうか? Box または Box を渡すことはできますか?答えは「ノー」です。Integer と Double は Number のサブクラスですが、ジェネリックスでは Box と Box の間には関係がありません。これは非常に重要です。完全な例を通して理解を深めましょう。

まず、以下で使用するいくつかの単純なクラスを定義します。 次の例では、ジェネリック クラス Reader を作成し、f1() で Fruit f = FruitReader.readExact(apples); を実行すると、List と List< の間にギャップがあるため、コンパイラはエラーを報告します。 Apple＞関係ありません。

りー

しかし、私たちの通常の思考習慣によれば、Apple と Fruit の間には関連性があるはずですが、コンパイラーはそれを認識できません。では、この問題を汎用コードで解決するにはどうすればよいでしょうか。この問題はワイルドカードを使用することで解決できます:

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);

これは、fruitReader の readCovariant メソッドによって受け入れられるパラメーターは Fruit のサブクラス (Fruit 自体を含む) のみである必要があるため、サブクラスと親クラスの間の関係も関連付けられることをコンパイラーに伝えるのと同じです。

PECS原則

上で と同様の使用法を示しましたが、これを使用してリストから要素を取得できるので、リストに要素を追加できますか?試してみましょう:

rreee

答えは「いいえ」です。Java コンパイラではこれを行うことができません。なぜでしょうか?この問題をコンパイラの観点から検討することもできます。 List を拡張したものなので、それ自体が複数の意味を持つ可能性があります: Apple を追加しようとすると、flist が新しい ArrayList();

を指す場合があります。 Orange を追加しようとすると、flist が新しい ArrayList();

• を指す可能性があります。 フルーツを追加しようとすると、フルーツはどのタイプのフルーツでも構いませんが、flist は特定のタイプのフルーツのみを必要とする可能性があり、コンパイラはそれを認識できず、エラーを報告します。

• したがって、

要素を追加したい場合はどうすればよいでしょうか? を使用できます:

• public class GenericWriting {
      static List<Apple> apples = new ArrayList<Apple>();
      static List<Fruit> fruit = new ArrayList<Fruit>();
      static <T> void writeExact(List<T> list, T item) {
          list.add(item);
      }
      static void f1() {
          writeExact(apples, new Apple());
          writeExact(fruit, new Apple());
      }
      static <T> void writeWithWildcard(List<? super T> list, T item) {
          list.add(item)
      }
      static void f2() {
          writeWithWildcard(apples, new Apple());
          writeWithWildcard(fruit, new Apple());
      }
      public static void main(String[] args) {
          f1(); f2();
      }
  }

  　　这样我们可以往容器里面添加元素了，但是使用super的坏处是以后不能get容器里面的元素了，原因很简单，我们继续从编译器的角度考虑这个问题，对于List list，它可以有下面几种含义：

  List<? super Apple> list = new ArrayList<Apple>();
  List<? super Apple> list = new ArrayList<Fruit>();
  List<? super Apple> list = new ArrayList<Object>();

  　　当我们尝试通过list来get一个Apple的时候，可能会get得到一个Fruit，这个Fruit可以是Orange等其他类型的Fruit。

  　　根据上面的例子，我们可以总结出一条规律，”Producer Extends, Consumer Super”：

  • “Producer Extends” – 如果你需要一个只读List，用它来produce T，那么使用? extends T。

  • “Consumer Super” – 如果你需要一个只写List，用它来consume T，那么使用? super T。

  • 如果需要同时读取以及写入，那么我们就不能使用通配符了。

  　　如何阅读过一些Java集合类的源码，可以发现通常我们会将两者结合起来一起用，比如像下面这样：

  public class Collections {
      public static <T> void copy(List<? super T> dest, List<? extends T> src) {
          for (int i=0; i<src.size(); i++)
              dest.set(i, src.get(i));
      }
  }

  　类型擦除

  　　Java泛型中最令人苦恼的地方或许就是类型擦除了，特别是对于有C++经验的程序员。类型擦除就是说Java泛型只能用于在编译期间的静态类型检查，然后编译器生成的代码会擦除相应的类型信息，这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的，为了保持向下的兼容性，所以只能做类型擦除来兼容以前的非泛型代码。对于这一点，如果阅读Java集合框架的源码，可以发现有些类其实并不支持泛型。

  　　说了这么多，那么泛型擦除到底是什么意思呢？我们先来看一下下面这个简单的例子：

  public class Node<T> {
      private T data;
      private Node<T> next;
      public Node(T data, Node<T> next) }
          this.data = data;
          this.next = next;
      }
      public T getData() { return data; }
      // ...
  }

  　　编译器做完相应的类型检查之后，实际上到了运行期间上面这段代码实际上将转换成：

  public class Node {
      private Object data;
      private Node next;
      public Node(Object data, Node next) {
          this.data = data;
          this.next = next;
      }
      public Object getData() { return data; }
      // ...
  }

  　　这意味着不管我们声明Node还是Node，到了运行期间，JVM统统视为Node