Java ジェネリックスを 1 つの記事で理解しても、包括的すぎるため、理解できない可能性があります。

I.はじめに

Java ジェネリックの背景と役割

Java ジェネリックは Java プログラミング言語の機能であり、ジェネリックを導入する目的は、コードの型安全性と再利用性を強化することです。ジェネリック型が存在しない前は、Java のコレクションクラス (ArrayList、HashMap など) は Object 型のオブジェクトのみを格納できました。そのため、コレクションを使用する場合は必須の型変換が必要であり、型エラーが発生する傾向がありました。

ジェネリックスの背景: Java 5 バージョンより前は、Java の型は静的であり、コンパイル時に決定され、型情報は実行時に消去されました。この場合、コンパイラはコレクションの要素の型を検証できないため、実行時型エラーが発生する可能性があります。この問題を解決するために、Java は汎用メカニズムを導入しました。

ジェネリックの役割:

型安全性: ジェネリックにより、コンパイル時に型エラーを検出できるようになり、実行時の型変換例外が回避されます。
コードの再利用: ジェネリックスを使用すると、さまざまな種類のデータに適用できる汎用コードを作成でき、コードの柔軟性と再利用性が向上します。
API 設計: ジェネリックにより、API 設計がより明確かつ一貫性のあるものになり、ジェネリックインターフェイス、クラス、メソッドを定義でき、より柔軟なパラメーターの型と戻り値の型を提供できます。
強化されたコレクションクラス: ジェネリックにより、コレクションクラスがより型安全かつ簡潔になり、明示的な型変換の必要がなくなります。

ジェネリックスを使用する場合、ジェネリックパラメーターを使用してクラス、インターフェイス、メソッド、変数を定義し、特定の型引数を使用してジェネリックスの特定の型を指定できます。たとえば、ジェネリッククラス ArrayList (T は型パラメーターを表します) を定義でき、ArrayList オブジェクトの作成時に特定の型を指定できます (ArrayList は整数を格納する ArrayList を表します)。

ジェネリックの基本概念と利点

基本コンセプト:

型パラメーター: ジェネリックスでは、型パラメーターは未知の型を表すために使用されます。型パラメータは任意の識別子で表すことができます。通常は、慣例として 1 つの大文字を使用します ( 、TなどE) K。
実際の型パラメータ: ジェネリックスを使用する場合は、特定の型を型パラメータに割り当てる必要があります。これらの特定の型は、実際の型パラメータと呼ばれます。たとえば、ジェネリッククラスのインスタンスを作成する場合、Integer型パラメーターを実際の型パラメーターとして渡すTことによって、整数を格納するオブジェクトを作成できます。

利点：

型安全性: ジェネリックスはより厳密な型チェックを提供し、コンパイル時に型エラーを検出できます。特定の型パラメーターを指定することにより、互換性のない型操作をコンパイル中に捕捉し、実行時の型変換エラーや関連する例外を回避できます。
コードの再利用性: ジェネリックを使用すると、型ごとに対応するコードを作成することなく、複数の型を操作できる共通のコードロジックを作成できます。これにより、コードの重複が減り、コードの保守性と可読性が向上します。
効率: ジェネリック型はコンパイル時に型消去を実行し、ジェネリック型をその境界型 (通常はオブジェクト型) に変換します。これは、実行時にジェネリック型情報を保存する必要がないことを意味し、それによって追加のオーバーヘッドが回避され、プログラムのパフォーマンスが向上します。

2. 一般的な型とメソッド

ジェネリッククラス

ジェネリッククラスを定義するための構文と使用法

Java や C# などの多くのプログラミング言語では、ジェネリッククラスは、インスタンス化のためにさまざまなタイプのパラメーターを受け入れることができる特別なタイプのクラスです。ジェネリッククラスは、型ごとに個別のクラスを作成せずにさまざまなデータ型で使用できるため、コードの再利用と型安全性の利点が得られます。

ジェネリッククラスを定義するための構文は次のとおりです。

public class GenericClass<T> {
    
    
    // 类成员和方法定义
}

上記の例では、は型パラメータを示すGenericClassジェネリッククラスの名前であり、実際の型を示す正当な識別子に置き換えることができます。<T>T

ジェネリッククラスを使用するには、実際の型を指定してインスタンスを作成します。たとえば、MyClassというジェネリッククラスがあると仮定すると、それを次のように使用できます。

GenericClass<Integer> myInstance = new GenericClass<Integer>();

上の例では、GenericClass整数型を使用してジェネリッククラスをインスタンス化しました。このようにすると、myInstance整数型のみを格納できるオブジェクトになります。

ジェネリッククラスをインスタンス化した後は、通常のクラスと同様に、そのクラスで定義されたメンバーとメソッドを使用できます。違いは、ジェネリッククラスのメンバーまたはメソッドは型パラメーターを受け取ることができT、型がチェックされ、実際の型に従って処理されることです。

ジェネリッククラスで複数の型パラメーターを使用する必要がある場合は、それらをカンマで区切ることができます。

public class MultiGenericClass<T, U> {
    
    
    // 类成员和方法定义
}

上の例では、2 つの型パラメーターを持つジェネリッククラスを定義していますMultiGenericClass。

要約すると、ジェネリッククラスを定義する構文は、<T>クラス名の後にまたは他の型パラメーターを使用し、クラス内でそれらの型パラメーターを使用することです。その後、実際の型を指定してジェネリッククラスをインスタンス化し、ジェネリッククラスで定義されたメンバーとメソッドを使用できるようになります。

型パラメータの修飾とワイルドカードの使用

型パラメータの制限:

型パラメーター修飾を使用すると、ジェネリッククラスまたはメソッドの型パラメーターを制約して、特定の型または特定の条件を満たす型のみを使用できるようにすることができます。

Java では、extendsキーワードを使用して型パラメータを修飾できます。型パラメータを修飾するには 2 つの方法があります。

Single Bound : type パラメーターがクラスまたはインターフェイスのサブクラスである必要があることを指定します。
```
public class MyClass<T extends SomeClass> {
      
      
    // 类成员和方法定义
}
```
上の例では、type パラメーターはクラスのサブクラス、またはインターフェイスを実装する型Tである必要があります。SomeClassSomeClass
Multiple Bounds : type パラメーターが複数のクラスまたはインターフェイスのサブクラスである必要があり、(存在する場合は) 1 つだけであることを指定します。
```
public class MyClass<T extends ClassA & InterfaceB & InterfaceC> {
      
      
    // 类成员和方法定义
}
```
上記の例では、type パラメーターはクラスのサブクラスでTある必要があり、およびインターフェイスも実装する必要があります。ClassAInterfaceBInterfaceC

型パラメーターの修飾を通じて、ジェネリッククラスまたはメソッドで型をより正確に制御および制約することができ、コードの型安全性と柔軟性が向上します。

ワイルドカードの使用:

ワイルドカードは、ジェネリッククラスまたはメソッドで未知または不定の型を表すために使用される特別な型パラメーターです。使用できるワイルドカードは 2 つあります。

無制限のワイルドカード: 疑問符を使用して、?任意のタイプに一致できることを示します。
```
public void myMethod(List<?> myList) {
      
      
    // 方法实现
}
```
上の例では、myMethodメソッドは type の 1 つのパラメーターを受け入れますListが、リストの要素の型は不明であり、任意の型である可能性があります。
境界付きワイルドカード:extends具象クラスまたはインターフェイスを使用して、ワイルドカードが一致できる型の範囲を制限します。
```
public void myMethod(List<? extends SomeClass> myList) {
      
      
    // 方法实现
}
```
上の例では、myMethodメソッドは type のパラメータを 1 つ受け入れますListが、リストの要素の型はSomeClassクラスまたはそのサブクラスである必要があります。

ワイルドカードを使用すると、より一般的な汎用コードを作成でき、さまざまな型の引数を処理できるようになります。これにより、特に具体的な型を気にしない場合、または複数の型を操作する必要がある場合に、柔軟性が向上します。

ワイルドカードを使用する場合、ワイルドカードで表される特定の型を決定できないため、ワイルドカードを使用して汎用オブジェクトに要素を追加する操作は実行できないことに注意してください。ただし、要素の読み取り操作は実行できます。追加操作と読み取り操作の両方をサポートする必要がある場合は、修飾されたワイルドカードを使用してこの問題を解決できます。

ジェネリッククラスのインスタンス化と型推論

Java では、ジェネリッククラスは、型でパラメータ化できるクラスです。ジェネリックスを使用すると、型安全性を向上させながら、より一般的で再利用可能なコードを作成できます。ジェネリッククラスをインスタンス化するときは、具象型パラメーターを指定する必要があります。

以下は、ジェネリッククラスをインスタンス化するための一般的な構文です。

ClassName<DataType> objectName = new ClassName<>();

上記の構文では、ClassNameはジェネリッククラスの名前であり、DataType実際の型パラメーターのプレースホルダーです。適切な型をに置き換えることでDataType、特定の型のオブジェクトを作成できます。たとえば、がジェネリック型パラメータBox<T>であるジェネリッククラスがある場合T、次のようにインスタンス化できます。

Box<Integer> integerBox = new Box<>();

この例では、Tジェネリック型パラメーターをに置き換えてInteger、Box型の整数オブジェクトを作成しました。

一方、型推論は、コンパイラがコンテキスト情報に基づいてジェネリック型パラメーターを自動的に推論するプロセスを指します。場合によっては、ジェネリック型パラメーターを省略して、コンパイラーに自動的に推論させることができます。これによりコードが簡素化され、読みやすくなります。

以下は、型推論の使用法を示す例です。

Box<Integer> integerBox = new Box<>();  // 类型推断

List<String> stringList = new ArrayList<>();  // 类型推断

これらの例では、ジェネリック型パラメーターを明示的に指定せず、<>演算子を使用しました。コンパイラは、変数宣言と初期化値から正しい型パラメータを推測します。

型推論は Java 7 以降でのみ使用できることに注意してください。Java の古いバージョンでは、ジェネリック型パラメータを明示的に指定する必要がありました。

一般的なメソッド

ジェネリックメソッド定義の構文と使用法

ジェネリックメソッドは、ジェネリック型のパラメータを持つメソッドです。ジェネリックメソッドを使用すると、メソッドレベルで型パラメーターを使用できるため、メソッドでさまざまな種類のデータを処理できるようになり、コードの柔軟性と再利用性が向上します。

以下は、ジェネリックメソッドを定義するための一般的な構文です。

public <T> ReturnType methodName(T parameter) {
    
    
    // 方法体
}

上記の構文では、<T>型パラメーターのプレースホルダー。任意の識別子 (通常は 1 つの大文字) を指定できます。Tメソッドのパラメータ、戻り値の型、メソッド本体の内部で使用できます。ReturnTypeメソッドの戻り値の型です。具象型またはジェネリック型のいずれかになります。

以下は、ジェネリックメソッドを定義して使用する方法を示す簡単な例です。

public <T> void printArray(T[] array) {
    
    
    for (T element : array) {
    
    
        System.out.println(element);
    }
}

// 调用泛型方法
Integer[] intArray = {
    
     1, 2, 3, 4, 5 };
printArray(intArray);

String[] stringArray = {
    
     "Hello", "World" };
printArray(stringArray);

上の例では、printArrayという汎用メソッドを定義しました。汎用配列を引数として受け取り、配列内の各要素を出力します。このメソッドを使用して、整数配列や文字列配列などのさまざまな型の配列を出力できます。

ジェネリックメソッドはジェネリッククラスから独立して存在でき、どのクラスでも定義して使用できることに注意することが重要です。これらにより柔軟性が向上し、クラス全体だけでなく特定のメソッドを汎用化できるようになります。

ジェネリックメソッドの呼び出しと型推論

ジェネリックメソッドを呼び出すときは、いくつかの重要な点に注意する必要があります。

型パラメーターを明示的に指定する: ジェネリックメソッドの型パラメーターがコンパイラーによって自動的に推論されない場合は、型パラメーターを明示的に指定する必要があります。メソッド名の前に山括弧 (<>) を使用して、特定の型パラメータを指定できます。
```
// 显式指定类型参数为String
String result = myGenericMethod.<String>genericMethod(argument);
```
自動型推論: 場合によっては、Java コンパイラーがジェネリックメソッドの型パラメーターを自動的に推論し、コードをより簡潔で読みやすくすることができます。type パラメータの明示的な指定は省略できます。
```
// 自动类型推断，根据参数类型推断类型参数为Integer
Integer result = myGenericMethod.genericMethod(argument);
```
コンパイラは、メソッドパラメーターの型とコンテキスト情報から型パラメーターを推測します。この型推論は、コードを簡素化し、読みやすさを向上させるのに非常に役立ちます。
ワイルドカード型パラメータ: 場合によっては、ジェネリックメソッドで未指定の型のパラメータを受け入れたい場合があります。この場合、ワイルドカードを型パラメータとして使用できます。
- 無制限のワイルドカード: 疑問符 (?) で表され、任意のタイプのパラメーターを受け入れることができます。
```
// 泛型方法接受任意类型的参数
void myGenericMethod(List<?> list) {
        
        
    // 方法体
}
```
- 境界付きワイルドカード: extends キーワードを使用して上限を指定するか、super キーワードを使用して下限を指定します。これにより、ジェネリックメソッドで受け入れられるパラメータータイプの範囲が制限されます。
```
// 泛型方法接受 Number 及其子类的参数
void myGenericMethod(List<? extends Number> list) {
        
        
    // 方法体
}

// 泛型方法接受 Integer 及其父类的参数
void myGenericMethod(List<? super Integer> list) {
        
        
    // 方法体
}
```

ジェネリックメソッドを呼び出す場合、コンパイラは渡されたパラメーターの型とコンテキストに従って型チェックを実行することに注意してください。型が一致しない場合はコンパイルエラーが発生します。

3. 汎用インターフェースとワイルドカード

汎用インターフェース

汎用インターフェイスを定義するための構文と使用法

ジェネリックインターフェイスは、ジェネリック型パラメーターを持つインターフェイスです。ジェネリックインターフェイスを使用すると、インターフェイスレベルで型パラメーターを使用できるようになり、実装クラスがさまざまな種類のデータを処理できるようになり、コードの柔軟性と再利用性が向上します。

以下は、汎用インターフェイスを定義するための一般的な構文です。

public interface InterfaceName<T> {
    
    
    // 接口方法和常量声明
}

上記の構文では、<T>型パラメーターのプレースホルダー。任意の識別子 (通常は 1 つの大文字) を指定できます。Tインターフェースのメソッド、定数、内部クラスで使用できます。

以下は、汎用インターフェイスを定義して使用する方法を示す簡単な例です。

public interface Box<T> {
    
    
    void add(T item);
    T get();
}

// 实现泛型接口
public class IntegerBox implements Box<Integer> {
    
    
    private Integer item;

    public void add(Integer item) {
    
    
        this.item = item;
    }

    public Integer get() {
    
    
        return item;
    }
}

// 使用泛型接口
Box<Integer> box = new IntegerBox();
box.add(10);
Integer value = box.get();

上の例では、Boxという汎用インターフェイスを定義しました。これには、ジェネリック型のデータをそれぞれ追加および取得するために使用されるaddメソッドとgetメソッドが含まれています。次に、このジェネリックインターフェイスの具象クラスを実装しIntegerBox、その中に具象型パラメーターを指定しますInteger。

Box<Integer>最後に、ジェネリックインターフェイスを使用して型のオブジェクトを作成し、addメソッドを介して整数値を追加し、getメソッドを介して整数値を取得しました。

ジェネリックインターフェイスを実装する場合、型パラメータを具体的に指定するか、ジェネリックを引き続き使用するかを選択できることに注意してください。

汎用インターフェースを実装する方法

具象型パラメータの実装: 実装クラスで具象型パラメータを明示的に指定します。これにより、実装クラスは特定の種類のデータのみを処理できるようになります。
```
public class IntegerBox implements Box<Integer> {
      
      
    private Integer item;

    public void add(Integer item) {
      
      
        this.item = item;
    }

    public Integer get() {
      
      
        return item;
    }
}
```
上記の例では、IntegerBoxクラスはジェネリックインターフェイスを実装しBox<Integer>、型パラメーターをとして明示的に指定しますInteger。したがって、IntegerBoxこのクラスは整数型のデータのみを扱うことができます。
ジェネリック型パラメーターを保持する: 実装クラスでジェネリック型パラメーターを引き続き使用します。これにより、実装クラスは汎用インターフェイスと同じ型パラメータを持つことができ、柔軟性が維持されます。
```
public class GenericBox<T> implements Box<T> {
      
      
    private T item;

    public void add(T item) {
      
      
        this.item = item;
    }

    public T get() {
      
      
        return item;
    }
}
```
上記の例では、GenericBox<T>クラスはジェネリックインターフェイスを実装しBox<T>、型パラメータを保持しますT。これは、GenericBoxクラスがあらゆる種類のデータをより柔軟に処理できることを意味します。

上記の 2 つの方法のいずれかを使用して、ニーズに応じて汎用インターフェイスを実装する方法を選択できます。それは、実装クラスを特定の型にバインドする必要があるか、データを操作するときに柔軟にする必要があるかによって異なります。

さらに、ジェネリックインターフェイスの実装にどのメソッドを使用するかに関係なく、実装クラスのメソッドシグネチャがジェネリックインターフェイスで定義されたメソッドと正確に一致することを確認する必要があります。これには、メソッド名、パラメータリスト、戻り値の型が含まれます。

ワイルドカード

上限ワイルドカードと下限ワイルドカードの概念

上限ワイルドカード

上限ワイルドカードは、ジェネリック型パラメーターを指定された型または指定された型のサブクラスに制限するために使用されます。キーワードを使用しextendsて上限を指定します。

文法：

<? extends Type>

たとえば、printListリストを取得し、リストの要素を出力する汎用メソッドがあるとします。ただし、メソッドが Number 型またはそのサブクラスのリストのみを受け入れられることを望みます。これは、上限ワイルドカードを使用することで実現できます。

public static void printList(List<? extends Number> list) {
    
    
    for (Number element : list) {
    
    
        System.out.println(element);
    }
}

// 调用示例
List<Integer> integerList = Arrays.asList(1, 2, 3);
printList(integerList); // 可以正常调用

List<String> stringList = Arrays.asList("Hello", "World");
printList(stringList); // 编译错误，String 不是 Number 的子类

上記の例では、printListメソッドは、<? extends Number>メソッドが Number 型またはそのサブクラスのリストを受け入れることを示すために、上限付きのワイルドカードを定義します。したがって、Integer 型のリストをパラメータとして渡すことはできますが、String 型のリストを渡すことはできません。

下限ワイルドカード

下限ワイルドカードは、ジェネリック型パラメーターが指定された型または指定された型のスーパークラスになるように制限するために使用されます。キーワードを使用してsuper下限を指定します。

文法：

<? super Type>

たとえば、addToListリストとリストに追加する要素を受け取るジェネリックメソッドがあるとします。ただし、このメソッドが Object 型またはその親クラスの要素のみを受け入れられることを望みます。これは、下限ワイルドカードを使用することで実現できます。

public static void addToList(List<? super Object> list, Object element) {
    
    
    list.add(element);
}

// 调用示例
List<Object> objectList = new ArrayList<>();
addToList(objectList, "Hello");
addToList(objectList, 42);

List<String> stringList = new ArrayList<>();
addToList(stringList, "World"); // 编译错误，String 不是 Object 的父类

上記の例では、addToListメソッドは<? super Object>を使用して下限ワイルドカードを定義しています。これは、メソッドがオブジェクト型またはそのスーパークラスのリストを受け入れ、任意の型の要素をリストに追加できることを意味します。したがって、文字列と整数をに追加することはできますobjectListが、 strings には追加できませんstringList。

上限ワイルドカードと下限ワイルドカードは、主にジェネリック型パラメーターを柔軟に処理するために使用され、さまざまな種類のデータをジェネリックコードで処理できることに注意してください。柔軟性と再利用性が向上します。

ジェネリックメソッドおよびジェネリックインターフェイスでワイルドカードを使用するシナリオ

ジェネリックメソッドでワイルドカードを使用するシナリオ:

読み取り操作: メソッドがジェネリックパラメーターから値を取得することのみが必要な場合、上限ワイルドカードを使用して、? extends Tメソッドが任意の T 型またはそのサブクラスに適用可能であることを示すことができます。

public static <T> void printList(List<? extends T> list) {
      
      
    for (T element : list) {
      
      
        System.out.println(element);
    }
}

// 调用示例
List<Integer> integerList = Arrays.asList(1, 2, 3);
printList(integerList); // 可以正常调用

List<String> stringList = Arrays.asList("Hello", "World");
printList(stringList); // 可以正常调用

書き込み操作: メソッドがジェネリックパラメーターに値を書き込む必要がある場合、下限ワイルドカードを使用して、? super Tメソッドが任意の T 型またはそのスーパークラスに適用できることを示すことができます。

public static <T> void addToList(List<? super T> list, T element) {
      
      
    list.add(element);
}

// 调用示例
List<Object> objectList = new ArrayList<>();
addToList(objectList, "Hello");
addToList(objectList, 42);

List<Number> numberList = new ArrayList<>();
addToList(numberList, 3.14);
addToList(numberList, 123);

汎用インターフェイスでワイルドカードを使用するシナリオ:

柔軟なコンテナーを定義する: コンテナークラスを定義するときは、コンテナーにあらゆる種類のデータを格納でき、無制限のワイルドカードを使用できることが望まれます<?>。

public interface Container<E> {
      
      
    void add(E element);
    E get();
}

// 实现示例
public class AnyContainer implements Container<?> {
      
      
    private Object element;

    public void add(Object element) {
      
      
        this.element = element;
    }

    public Object get() {
      
      
        return element;
    }
}

型の範囲の制限: 汎用インターフェイスで特定の範囲内の型のみを処理したい場合は、上限または下限のワイルドカードを使用できます。

public interface Box<T extends Number> {
      
      
    void addItem(T item);
    T getItem();
}

// 实现示例
public class NumberBox<T extends Number> implements Box<T> {
      
      
    private T item;

    public void addItem(T item) {
      
      
        this.item = item;
    }

    public T getItem() {
      
      
        return item;
    }
}

public class IntegerBox implements Box<Integer> {
      
      
    private Integer item;

    public void addItem(Integer item) {
      
      
        this.item = item;
    }

    public Integer getItem() {
      
      
        return item;
    }
}

上記のシナリオでワイルドカードを使用する目的は、柔軟性と再利用性を高めることです。ワイルドカードを使用すると、具体的な型にバインドせずに、ジェネリックメソッドやインターフェイスで複数の型のデータを処理できるようになります。これにより、コードがより一般的で拡張可能になり、より幅広いシナリオに適用できるようになります。

4. ジェネリックと収集フレームワーク

一般的なコレクションフレームワークの詳細な紹介

ジェネリックコレクションフレームワークは、データの保存と操作のために Java で提供されるコンテナクラスのセットであり、ジェネリック型パラメータをサポートします。汎用コレクションフレームワークは、リスト (List)、コレクション (Set)、マップ (Map) などを含む豊富な実装をJDKjava.utilのパッケージで提供します。

コアインターフェイス:

リストインターフェイス: 順序付けされた反復可能なコレクションを表します。インデックスによる要素へのアクセスを許可し、繰り返しの要素を含めることができます。一般的な実装クラスは、ArrayList、LinkedList、Vector です。
Set インターフェイス: 要素の重複を許可しない、順序付けされていないコレクションを表します。要素の一意性が保証されます。一般的な実装クラスは、HashSet、TreeSet、LinkedHashSet です。
キューインターフェイス: 先入れ先出し (FIFO) キューを表します。一般的な実装クラスは LinkedList と PriorityQueue です。
マップインターフェイス: キーと値のペアのマッピングテーブルを表します。各キーは一意であり、関連付けられた値を取得するために使用できます。一般的な実装クラスは、HashMap、TreeMap、LinkedHashMap です。

ジェネリック医薬品の利点:

ジェネリックコレクションフレームワークの主な利点は、型安全性とコンパイル時の型チェックが提供されることです。ジェネリック型パラメーターを指定すると、コンパイル時に多くの型エラーを検出し、実行時の型変換例外を回避できます。また、ジェネリックスはコンテナーに格納される要素のタイプを明示的に指定するため、コードの可読性と保守性も向上します。

使用例:

一般的な汎用コレクションフレームワークの使用例をいくつか示します。

// 创建一个泛型列表，并添加元素
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");

// 使用迭代器遍历列表
for (String element : stringList) {
    
    
    System.out.println(element);
}

// 创建一个泛型集合，并添加元素
Set<Integer> integerSet = new HashSet<>();
integerSet.add(1);
integerSet.add(2);
integerSet.add(3);

// 判断集合是否包含特定元素
boolean containsTwo = integerSet.contains(2);
System.out.println(containsTwo);  // 输出: true

// 创建一个键值对映射表，并添加元素
Map<String, Integer> stringToIntegerMap = new HashMap<>();
stringToIntegerMap.put("One", 1);
stringToIntegerMap.put("Two", 2);
stringToIntegerMap.put("Three", 3);

// 根据键获取值
int value = stringToIntegerMap.get("Two");
System.out.println(value);  // 输出: 2

ジェネリックコレクションフレームワークを使用すると、さまざまな型のコレクションを簡単に作成および操作でき、型安全性とコンパイル時のチェックの利点を得ることができます。

5. タイプ消去とブリッジ方法

活字消去の原理と影響

ジェネリック型消去 (Type Erasure) は、Java におけるジェネリックスの実装の 1 つです。これは、コンパイル中にジェネリック型を非ジェネリック型に変換するメカニズムです。ジェネリック型の消去では、ジェネリック型パラメーターはその上限またはオブジェクト型まで消去され、型チェックは実行時ではなく主にコンパイル時に行われます。

ジェネリック型消去の原理:

型の消去: コンパイル中に、すべてのジェネリック型パラメーターがその上限またはオブジェクト型に置き換えられます。たとえば、List<String>コンパイル後はになりますList<Object>。
型消去後の変換: 型消去のため、元のジェネリック型情報は実行時に利用できません。したがって、ジェネリック型を使用する場合は、型の安全性を確保するために必要な変換が実行されます。
- アップキャスト: ジェネリック型パラメーターがサブクラスの場合、その上限型にキャストされます。たとえば、List<String>はに変換されますList<Object>。
- ダウンキャスト: ジェネリック型から特定の型パラメーターを取得する必要がある場合は、型変換を実行する必要があります。ただし、これによりランタイム型例外 (ClassCastException) が発生する可能性があります。

ジェネリック型の消去の影響:

互換性: ジェネリック型消去により、元の非ジェネリックコードとの互換性が保証されます。これは、ジェネリック型を使用するコードは、ジェネリック型を使用しない従来のコードと対話できることを意味します。
具象型パラメータを取得できません: 型が消去されているため、実行時にジェネリック型パラメータの詳細を取得できません。たとえば、実行時にList オブジェクトが List オブジェクトであるList<String>かList オブジェクトであるかを判断する方法はありませんList<Integer>。
型の安全性: 型の消去により、ジェネリックは実行時の型チェックを失います。コンパイラはコンパイル時にのみ型チェックを実行できるため、型の不一致がある場合、実行時に ClassCastException が発生する可能性があります。
リフレクション操作を制限する: リフレクションメカニズムを通じて、ジェネリック型の消去の制限を回避し、実行時にジェネリック型の情報を取得できます。ただし、リフレクションの使用は複雑でパフォーマンスも低いため、頻繁に使用することはお勧めできません。

影響の例:

次の例は、ジェネリック型の消去の影響を示しています。

// 定义一个泛型类
public class GenericClass<T> {
    
    
    private T value;

    public void setValue(T value) {
    
    
        this.value = value;
    }

    public T getValue() {
    
    
        return value;
    }
}

// 使用泛型类
GenericClass<String> stringGeneric = new GenericClass<>();
stringGeneric.setValue("Hello");
String value = stringGeneric.getValue();

// 编译后的泛型类型擦除
GenericClass stringGeneric = new GenericClass();
stringGeneric.setValue("Hello");
String value = (String) stringGeneric.getValue();  // 需要进行类型转换

// 运行时类型异常示例
GenericClass<String> stringGeneric = new GenericClass<>();
GenericClass<Integer> integerGeneric = new GenericClass<>();

System.out.println(stringGeneric.getClass() == integerGeneric.getClass());  // 输出: true

stringGeneric.setValue("Hello");

try {
    
    
    Integer value = integerGeneric.getValue();  // 运行时抛出 ClassCastException 异常
} catch (ClassCastException e) {
    
    
    System.out.println("ClassCastException: " + e.getMessage());
}

ブリッジ法の概念と機能

ジェネリックブリッジメソッド (Generic Bridge Method) は、ジェネリック型の安全性を維持するために Java コンパイラによって自動的に生成されるメソッドです。その役割は、ジェネリック型パラメーターを持つクラスまたはインターフェイスを継承または実装するときに、型の安全性と互換性を確保することです。

コンセプト：

クラスまたはインターフェイスがジェネリック型パラメーターを持つメソッドを定義し、そのクラスまたはインターフェイスがサブクラスまたは実装クラスによって継承または実装される場合、ジェネリック型の消去により、コンパイラーは型の安全性を確保するために追加のブリッジメソッドを生成する必要があります。これらのブリッジメソッドは同じメソッドシグネチャを持ちますが、継承階層内の他の非ジェネリックメソッドとの互換性を維持するために、パラメーターおよび戻り値の型としてプリミティブ型を使用します。

効果：

タイプセーフティ: ジェネリックブリッジメソッドの主な役割は、タイプセーフティを維持することです。ブリッジメソッドを追加することで、互換性のない型へのアクセスを実行時に防ぐことができます。これにより、コンパイル中に検出できない型エラーが回避されます。
継承関係の維持: ジェネリックブリッジメソッドは、ジェネリッククラスまたはインターフェイス間の継承関係を維持するためにも使用されます。これらにより、サブクラスまたは実装クラスが、正しい型パラメーターを使用してスーパークラスまたはインターフェイスのジェネリックメソッドを正しくオーバーライドできることが保証されます。

例：

次の例を考えてみましょう。

public class MyList<T> {
    
    
    public void add(T element) {
    
    
        // 添加元素的逻辑
    }
}

// 子类继承泛型类，并覆盖泛型方法
public class StringList extends MyList<String> {
    
    
    @Override
    public void add(String element) {
    
    
        // 添加元素的逻辑
    }
}

この例では、コンパイラは、Java のジェネリック型消去メカニズムによる型の安全性と互換性を確保するブリッジメソッドを生成します。上記のコードは実際にはコンパイラによって次のように変換されます。

public class MyList {
    
    
    public void add(Object element) {
    
    
        // 添加元素的逻辑
    }
}

public class StringList extends MyList {
    
    
    @Override
    public void add(Object element) {
    
    
        add((String) element);
    }

    public void add(String element) {
    
    
        // 添加元素的逻辑
    }
}

この変換されたコードでは、クラスには実際のジェネリックメソッドを呼び出すStringListブリッジメソッドが含まれています。これにより型の安全性が維持され、親クラスの非ジェネリックメソッドと互換性があります。add(Object element)add(String element)

ジェネリックブリッジメソッドを生成することにより、Java コンパイラはジェネリック型を継承および実装するときに型の安全性と互換性を維持できます。これらのブリッジメソッドは、内部で変換してジェネリック型の消去を維持しながら、より優れた型チェックと実行時の型の安全性を提供します。

6. ジェネリック医薬品の制限事項と注意事項

ジェネリックにおける型安全性と実行時例外

ジェネリックスでは、型安全性とは、プログラムが実行時に型エラーを起こさないようにするためのコンパイラーによる型のチェックを指します。ジェネリックスを使用すると、コンパイル時に多くの型エラーを検出し、実行時の型変換例外を回避できます。

タイプセーフティの利点:

コンパイル時の型チェック: Java コンパイラーは、ジェネリックスに対して型チェックを実行して、コードの型安全性を確保します。ジェネリック型パラメーターが宣言された型パラメーターと一致することを検証し、不正な型操作を拒否できます。
キャストを避ける: ジェネリックスを使用する場合、コンパイラーが自動的にキャストコードを挿入できるため、手動キャストは必要なくなります。
コードの可読性と保守性の向上: ジェネリックスを使用すると、コンテナーに格納される要素のタイプを明示的に指定できるため、コードがより読みやすく、理解しやすくなります。また、型情報が明示的であるため、コードの保守性も向上します。

タイプセーフティの実装:

コンパイル時の型チェック: コンパイラはジェネリックスに対して型チェックを実行し、コンパイル時に型エラーが発生しないことを確認します。型の不一致がある場合、コンパイラーはエラーを報告し、コードのコンパイルを妨げます。
型消去メカニズム: Java のジェネリックは型消去を通じて実装されます。つまり、ジェネリック型はコンパイル時に消去されてプリミティブ型 (オブジェクトなど) になります。型消去により、元の非汎用コードとの互換性が保証され、下位互換性が維持されます。
ブリッジメソッド: ジェネリッククラスとインターフェイス間の継承関係と型の安全性を維持するために、コンパイラはブリッジメソッドを生成します。ブリッジメソッドは、ジェネリック型パラメーターを持つクラスまたはインターフェイスを継承または実装するときに、正しい型変換とメソッド呼び出しを保証するために使用されます。

実行時例外:

ジェネリックスは型の安全性を強化しますが、特定の状況では依然として実行時例外が発生する可能性があります。これらの例外は通常、次の状況で発生します。

型の消去による情報損失: 型の消去により、ジェネリック型パラメーターの詳細を実行時に取得できません。そのため、型変換時に型が一致しない場合、ClassCastException 例外が発生する可能性があります。
プリミティブ型との対話: パラメーター化されていないコレクションにジェネリックコレクションを割り当てるなど、プリミティブ型を使用してジェネリック型と対話する場合、コンパイル時には警告が表示されない可能性がありますが、実行時には型エラーが発生します。
リフレクション操作: リフレクションメカニズムを通じて、ジェネリックスの型安全性をバイパスできます。リフレクションを使用する場合は、型エラーや実行時例外を避けるために特別な注意が必要です。

例：

List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");

// 编译时类型检查，不允许添加非 String 类型的元素
stringList.add(123);  // 编译错误

// 获取元素时不需要进行类型转换
String firstElement = stringList.get(0);

// 迭代器遍历时可以确保元素类型的安全性
for (String element : stringList) {
    
    
    System.out.println(element);
}

// 类型擦除引起的运行时异常示例
List<Integer> integerList = new ArrayList<>();
integerList.add(10);

List rawList = integerList;  // 原始类型与泛型类型交互

List<String> stringList = rawList;  // 编译通过，但在运行时会导致类型错误

String firstElement = stringList.get(0);  // 运行时抛出 ClassCastException 异常

この例では、rawListコンパイル時にプリミティブ型をジェネリック型に、またはジェネリック型から割り当てることができますList<String>。ただし、実行時にstringListから、型の消去により ClassCastException が発生し、実際に格納されるのは整数型です。

したがって、ジェネリックには型安全性とコンパイル時の型チェックの利点がありますが、実行時例外の可能性を避けるために、型消去とプリミティブ型との相互作用は依然として慎重に処理する必要があります。

ジェネリック配列の制限と解決策

ジェネリック配列は、ジェネリック型パラメーターを使用して作成された配列です。ただし、Java には、ジェネリック型パラメーターを使用した配列の直接作成を許可しないいくつかの制限があります。これは、Java ジェネリックの型消去メカニズムによるものです。

制限:

List<String>[]ジェネリック型パラメーターを使用して配列を作成できない: Java では、ジェネリック型パラメーター (またはなど)を使用して配列を直接作成することはできませんT[]。
コンパイラの警告: ジェネリック配列を作成しようとすると、コンパイラは「ジェネリック配列の作成により、チェックされていない操作や安全でない操作が発生する可能性があります」という警告を発行します。

問題の原因:

ジェネリックの型消去メカニズムが、ジェネリック配列を直接作成できない主な理由です。ジェネリックはコンパイル時に消去されてプリミティブ型になるため、実行時にジェネリック型に関する具体的な情報を取得する方法はありません。これにより、配列の正確なタイプを判断できなくなります。

解決：

ジェネリック型パラメーターを使用した配列の直接作成は制限されていますが、ジェネリック配列の問題は次の 2 つの解決策で処理できます。

1. ワイルドカードまたはプリミティブ型の配列を使用します。

?特定のジェネリック型パラメーターの代わりに、ワイルドカード ( ) またはプリミティブ型の配列を使用できます。たとえば、List<?>[]またはObject[]型の配列を作成できます。このメソッドでは型安全性は得られませんが、コンパイル時の制限を回避できます。

List<?>[] arrayOfLists = new List<?>[5];
Object[] objects = new Object[5];

配列の正確な型を決定できないため、配列要素にアクセスするときに明示的な型変換が必要になる場合があることに注意してください。

2. コレクションまたはその他のデータ構造を使用します。

配列の代わりに、コレクション (例ArrayList: 、LinkedListなど) または他のデータ構造を使用して、ジェネリック型パラメーターを格納できます。これにより、汎用配列を直接使用する場合の制限と問題が回避されます。

List<List<String>> listOfLists = new ArrayList<>();

コレクションを使用する利点は、汎用配列の制限なしに、より柔軟な操作と型の安全性が提供されることです。

ジェネリックとリフレクションの互換性の問題

ジェネリックとリフレクションの間には互換性の問題がいくつかあります。これは、Java ジェネリックの型消去メカニズムとリフレクションの特性が原因で発生します。

1. 型消去による情報損失:ジェネリックスは、型消去を通じて Java に実装されます。つまり、実行時に、ジェネリック型パラメーターはプリミティブ型 (オブジェクトなど) に消去されます。これは、リフレクションを使用すると、ジェネリック型パラメーターの特定の情報は取得できず、元の型のみが取得されることを意味します。

解決策:リフレクション操作を使用して、ジェネリッククラス、ジェネリックメソッド、またはジェネリックフィールドのメタデータ (名前、修飾子、ジェネリックパラメーターなど) を取得できますが、ジェネリック型パラメーターの特定の種類を正確に取得することはできません。場合によっては、ジェネリックマーカーインターフェイスを組み合わせて使用して型情報を渡すことができるため、リフレクション操作でより多くの型情報を取得できます。

2. ジェネリック配列の制限:ジェネリック型パラメーターを持つ配列を直接作成することはできません。これは、実行時にジェネリック型パラメーターの具体的な型を決定できない型消去メカニズムが原因です。

解決策:?具体的なジェネリック型パラメーターの配列は、ワイルドカード ( ) またはプリミティブ型の配列を使用して置き換えることができます。ただし、配列要素にアクセスする場合は、明示的な型変換が必要になる場合があります。

3. ジェネリックメソッドのリフレクティブ呼び出し:リフレクションを通じてジェネリックメソッドを呼び出すときは、型の安全性に注意を払う必要があります。リフレクション操作は実行時に動的に実行されるため、コンパイラーは静的な型チェックを実行できないため、型エラーが発生する可能性があります。

解決策:リフレクションを使用してジェネリックメソッドを呼び出す場合、正しいパラメーターの型を渡すことで型の安全性を確保し、戻り値に対して適切な型変換を実行できます。

4. Class オブジェクトのジェネリック情報の制限:特定のジェネリック型については、そのジェネリック型パラメータの固有情報を Class オブジェクトを通じて取得することはできません。たとえば、List<String>型の場合、ジェネリック型パラメーターが String であるという情報はList.class、から。

解決策: TypeToken クラスライブラリなどのサードパーティライブラリを使用して、この制限を回避できます。TypeToken は、サブクラス化および匿名内部クラスを通じてジェネリック型パラメーターの特定の情報を取得できます。

7. 一般的なプログラミングの実践とベストプラクティス

汎用プログラミングの一般的なパターンとテクニック

1. ジェネリッククラスとインターフェイス:型パラメーターを使用してジェネリッククラスまたはインターフェイスを定義すると、コードでさまざまな種類のデータを処理できるようになります。クラスまたはインターフェイスで型パラメータを使用すると、インスタンス化時に具象型を指定できます。

public class GenericClass<T> {
    
    
    private T value;
    
    public void setValue(T value) {
    
    
        this.value = value;
    }
    
    public T getValue() {
    
    
        return value;
    }
}

2. ジェネリックメソッド:型パラメーターを使用してジェネリックメソッドを定義します。これにより、呼び出し時に渡されたパラメーターの型に従ってメソッドが型を推測し、対応する型を返すことができます。

public <T> T genericMethod(T value) {
    
    
    // 方法逻辑
    return value;
}

3. ワイルドカード:ワイルドカード ( ?) を使用して未知の型を表すか、型の範囲を制限し、コードの柔軟性を高めます。

無制限のワイルドカード:List<?>任意のタイプのリストを保存できることを示します。
上限ワイルドカード: List<? extends Number>Number とそのサブクラスを格納できるリストであることを示します。
下限ワイルドカード:List<? super Integer>整数とそのスーパークラスを格納できるリストであることを示します。

4. 型の制限と制約:型の制限と制約を使用して、ジェネリック型パラメーターの範囲を制限し、より正確な型情報を提供します。

public <T extends Number> void processNumber(T number) {
    
    
    // 方法逻辑
}

5. ジェネリックスと継承関係:ジェネリッククラスとインターフェイスは、他のジェネリッククラスとインターフェイスを継承して実装でき、継承関係を通じてより充実したジェネリック階層を構築できます。

public interface MyInterface<T> {
    
    
   // 接口定义
}

public class MyClass<T> implements MyInterface<T> {
    
    
   // 类定义
}

6. 汎用配列とコレクション:汎用配列とコレクションを使用すると、さまざまな種類のデータコレクションを処理でき、より安全で柔軟なデータの保存と操作方法が提供されます。

List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");

String value = stringList.get(0);  // 获取元素，无需转换类型

7. 型推論:<> Java 7 で導入されたダイヤモンド演算子 ( ) は、コンテキストに従って型パラメータを自動的に推論できるため、コードがより簡潔になります。

Map<String, List<Integer>> map = new HashMap<>();  // 类型推断

ジェネリックに関する一般的な間違いと落とし穴を回避する

1. プリミティブ型とジェネリック型の混同:ジェネリックスを使用するときは、プリミティブ型とジェネリック型を正しく区別する必要があります。プリミティブ型には型パラメータがないため、ジェネリックスの利点が失われます。

回避方法:ジェネリック型パラメーターを使用してクラス、インターフェイス、メソッドを宣言し、コード内で型パラメーターを明示的に指定します。

2. 型チェックの警告を無視する:ジェネリックスを使用する場合、コンパイラーは型チェックの警告を生成する可能性があり、無視すると型の安全性の問題が発生する可能性があります。

回避方法:型チェックの警告を直接無視することは避けてください。適切な型制限、型変換、またはアノテーションを使用することで、@SuppressWarnings警告を解決または抑制できます。

3. ジェネリック配列の作成: Java の配列には固定型 (共分散) があるため、ジェネリック配列を直接作成することはできません。ジェネリック配列を作成しようとすると、コンパイル時エラーまたは実行時例外が発生する可能性があります。

回避方法:特定の汎用配列の代わりに、ワイルドカードまたはプリミティブ型の配列を使用できます。たとえば、代わりにList<?>またはを使用します。List<Object>List<T>

4. ジェネリック型の消去:実行時に、ジェネリック型パラメーターはプリミティブ型 (オブジェクトなど) に消去され、ジェネリック型パラメーターに関する特定の情報を取得できなくなります。

回避方法:ジェネリック型の消去の問題は、型トークンを渡すか、TypeToken などのサードパーティライブラリを使用してより多くの型情報を取得することで回避できます。

5. 静的コンテキストのジェネリック:静的フィールド、静的メソッド、および静的初期化ブロックは、クラスの読み込み時に存在し、インスタンス化とは何の関係もないため、ジェネリック型パラメーターを参照できません。

回避方法:静的コンテキストでジェネリック型を使用する必要がある場合は、静的メソッド内でジェネリックパラメーターをローカル変数として宣言できます。

6. ジェネリックおよび可変個引数メソッド:ジェネリックメソッドで構文を使用すると、<T...>可変個引数メソッドを呼び出すときにコンパイルエラーが発生する可能性があります。

回避方法:パラメータの型として境界型のワイルドカード (T[]またはList<T>) を使用することも、非ジェネリック型のパラメータを使用することもできます。

7. ジェネリック型パラメーターの境界制限:ジェネリック型パラメーターが制限されている場合は、コード内でのこれらの制限の合理的な使用に注意し、型変換エラーを防止してください。

回避方法:必要に応じて、境界修飾を使用してジェネリック型パラメーターを制約し、境界型に基づいてコード内で対応する操作と変換を実行します。