[Java]泛型(二)泛型方法

1.定义

在 Java 中，泛型方法是指在方法声明中使用泛型类型参数的一种方法。它使得方法能够处理不同类型的对象，而不需要为每种类型写多个方法，从而提高代码的重用性。

泛型方法与泛型类不同，泛型方法的类型参数仅仅存在于方法的范围内，而不是整个类的范围内。使用泛型方法时，可以在方法调用时指定实际的类型参数。

2.基本语法

泛型方法的语法结构与普通方法类似，只不过在方法返回类型前加上一个泛型参数列表（用尖括号<>表示）。泛型参数列表是类型参数（例如 <T>），可以是一个或多个。

java">public <T> 返回类型 方法名(参数列表) {
    // 方法体
}

例如：

java">public <T> void methodName(T param) {
    // 方法实现
}

3.泛型方法的示例

3.1 示例：

3.1.1 示例1：打印任意类型的值

java">public class GenericMethodExample {
    // 泛型方法：打印任意类型的值
    public <T> void printValue(T value) {
        System.out.println(value);
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        example.printValue("Hello, World!");  // 输出：Hello, World!
        example.printValue(100);              // 输出：100
        example.printValue(3.14);             // 输出：3.14
    }
}

这里的 <T> 是类型参数的声明，表示该方法可以接受任何类型的参数。
在 printValue 方法中，T 代表传递给方法的实际类型，在调用时根据实际传入的参数类型自动推导。

3.1.2 示例2：交换两个元素的位置

java">public class GenericMethodExample {
    // 泛型方法：交换两个元素的位置
    public <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 测试交换整数数组中的元素
        Integer[] intArray = {1, 2, 3, 4};
        example.swap(intArray, 0, 2);
        System.out.println(java.util.Arrays.toString(intArray));  // 输出：[3, 2, 1, 4]

        // 测试交换字符串数组中的元素
        String[] strArray = {"apple", "banana", "cherry"};
        example.swap(strArray, 0, 1);
        System.out.println(java.util.Arrays.toString(strArray));  // 输出：[banana, apple, cherry]
    }
}

在这个例子中，swap 方法使用了泛型 T[] 数组和泛型类型 T，允许我们交换任何类型数组中的元素。
T[] 表示该方法可以接受任何类型的数组，并且 T 会在运行时根据传递的实际数组类型确定。

4.泛型方法的限制和注意事项

4.1 类型擦除

4.1.1 定义：

类型擦除（Type Erasure）是 Java 泛型的一项关键特性，它在编译时通过将泛型类型转换为原始类型（通常是 Object 或指定的边界类型）来实现泛型的类型安全，但在运行时丢失了对类型参数的具体信息。

4.1.2 为什么需要类型擦除？

Java 的泛型是 编译时的类型安全检查，而不是运行时的类型参数。因此，泛型类型的具体信息只存在于编译阶段，编译器会根据类型擦除机制将泛型转换成原始类型（通常是 Object）。这种做法可以在保证类型安全的同时，避免运行时因类型信息的传递导致的性能问题。

泛型的出现是为了增强代码的灵活性，同时 保持类型安全。但是，Java 的泛型并不支持在运行时保留类型信息，这是由于 Java的设计选择和 性能优化考虑。

4.2 类型擦除如何工作？

在 Java 编译器将泛型代码转换为字节码时，所有的泛型类型参数都会被替换为它们的 原始类型。对于不带类型边界的泛型，默认使用 Object 来替代类型参数。而对于有类型边界的泛型，编译器会将类型参数替换为边界类型。

示例：

java">public class Box<T> {
    private T value;

    public T getValue() {
        return value;
    }

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

编译后，Box<T>会变成：

java">public class Box {
    private Object value;

    public Object getValue() {
        return value;
    }

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

所以 类型擦除的结果 是：

泛型参数 T 被替换为 Object。
编译器会删除 T 的所有信息，只保留 Object 或者它的边界类型（如 Number）。
你在使用泛型时，实际上操作的是 Object，即使在代码中看起来是 T。

4.3 类型擦除的原因

类型擦除是 Java 设计的一种机制，其目的是确保 Java 的兼容性，同时增强泛型的灵活性：

向后兼容性：
- 在 Java 5 引入泛型之前，Java 已经有大量的代码和类库。为了让新版本的 Java 仍然能够兼容这些旧代码，泛型类型的具体信息必须在编译时被擦除。
- 这样，即使老代码不支持泛型，新旧代码依然能够共存。
性能优化：
- 在 Java 中，泛型是 编译时的 类型检查，而不是 运行时的 类型参数。泛型的引入是为了提高代码的 类型安全，但同时为了避免在运行时进行类型检查和反射等耗费性能的操作，所有的类型信息会在编译后被擦除。
- 运行时只有原始类型（如 Object），不再有泛型类型的负担，从而提高程序的性能。
简化实现：
- 由于在运行时不需要额外的类型信息，Java 只需要维护单一的原始类型（通常是 Object）的字节码结构。这简化了 Java 虚拟机（JVM）的实现，不需要考虑复杂的泛型类型。

4.4 类型擦除的具体实现细节

4.4.1 泛型的类型擦除：

编译器会用 Object 替换没有指定类型边界的泛型类型参数（如 T）。
如果指定了类型边界（例如 T extends Number），编译器会用边界类型替代泛型类型参数。

示例：

java">public class Box<T> {
    public T value;

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

类型擦除后的字节码：

java">public class Box {
    public Object value;

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

4.4.2 具有边界的泛型：

如果泛型带有边界，擦除时会使用边界类型。

java">public class Box<T extends Number> {
    public T value;

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

类型擦除后的字节码：

java">public class Box {
    public Number value;

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

4.4.3 为什么不能在运行时获取泛型类型信息？

类型擦除后，泛型类型的具体信息被丢弃，JVM 在运行时只知道原始类型。这意味着你无法在运行时直接获取一个泛型类型参数的信息，例如通过 getClass() 或 instanceof 等方法。这是因为在运行时，泛型参数已经被擦除为 Object 或指定的边界类型。

例如：

java">public <T> void printType(T value) {
    System.out.println(value.getClass().getName());  // 获取类型信息
}

调用 printType(new Integer(10))，输出 java.lang.Integer。但是，如果你使用 T 类型的 getClass()，它并不会返回 T 的类型，而是 Object，因为在运行时 T 已经被擦除。

4.5 泛型数组与类型擦除的冲突

在 Java 中创建泛型数组会导致问题，因为 类型擦除后的 T 被替换成了 Object，这使得编译器无法知道实际数组的类型。例如：

java">public <T> void example() {
    T[] array = new T[10];  // 编译错误：不能创建泛型数组
}

原因：

由于 T 在编译时被擦除为 Object，因此编译器无法确定 T[] 代表的实际类型。Java 无法知道该数组是 Integer[]、String[] 还是其他类型的数组。
数组的类型必须在运行时确定，因此无法通过泛型类型直接创建数组。

解决方法：使用反射或者使用 Object[] 来替代泛型数组。

4.6 类型擦除对集合类的影响

类型擦除影响最明显的地方是在集合类中，例如 List<T>，我们不能通过 List<T> 来确定元素的具体类型，因为泛型已经被擦除。

java">List<Integer> list = new ArrayList<>();

虽然我们创建了 List<Integer> 类型的集合，但在运行时，它其实是一个 List 类型的集合，元素类型已经变为 Object。

4.7 如何解决类型擦除带来的问题

4.7.1 解决办法

为了绕开类型擦除的限制，可以使用以下几种方法：

反射（Reflection）：使用反射可以动态获取类型信息，比如 Array.newInstance() 可以在运行时创建泛型类型的数组。
传递 Class 对象：通过传递 Class<T> 类型参数，我们可以在泛型方法中通过反射创建具体类型的数组。
使用 List 或其他集合类：尽量避免使用数组，在需要泛型集合时，可以使用如 ArrayList<T>、HashMap<K, V> 等通用集合类，它们对泛型有更好的支持，并且能够处理不同类型的数据。

4.7.2 注意事项

1.不能直接使用泛型数组

如之前所述，泛型数组在 Java 中是不被允许的，无法直接创建 T[] 类型的数组。需要使用 Object[] 或者通过反射等方式来实现。

2.类型参数的作用范围

泛型类型仅在方法体内有效。方法外部和其他类的泛型类型不会受到影响。

5.泛型方法的类型推导

5.1 定义

类型推导是指 Java 编译器根据实际传递给泛型方法的参数类型，自动推断出泛型类型参数的具体类型。这意味着你可以省略显式声明类型参数，编译器会在调用方法时根据传入的实参类型推导出泛型类型。

5.2 泛型方法类型推导的关键点：

编译器根据传入的实际类型来推导出泛型参数。
你不需要显式指定泛型类型，编译器会根据方法调用的上下文进行推断。

5.3 类型推导的基本规则

在 Java 中，泛型方法的类型推导遵循以下基本规则：

规则 1：根据方法调用时传递的参数类型自动推导泛型类型。

Java 编译器会根据传递给方法的实参的类型自动推导出泛型的实际类型。
规则 2：类型推导基于方法调用时的参数类型。

传递给方法的参数类型将用于推导出泛型类型参数的类型。
规则 3：如果方法调用的上下文不能唯一确定泛型类型，编译器会报错。

如果无法根据传入的参数明确推导出泛型类型，编译器会抛出错误。

5.4 泛型方法的类型推导示例：

5.4.1 示例1：简单的类型推导

java">public class GenericMethodExample {

    // 泛型方法，自动推导类型 T
    public <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 传入 Integer 数组，编译器推导出 T 为 Integer
        Integer[] intArray = {1, 2, 3, 4};
        example.printArray(intArray);

        // 传入 String 数组，编译器推导出 T 为 String
        String[] strArray = {"apple", "banana", "cherry"};
        example.printArray(strArray);
    }
}
/*
输出：
1
2
3
4
apple
banana
cherry
*/

解释：

在 printArray 方法中，类型参数 T 被推导为 Integer（在传递 Integer[] 时）和 String（在传递 String[] 时）。你无需显式指定类型参数，编译器会根据参数类型自动推导。

5.4.2 示例2：类型推导与多个参数

java">public class GenericMethodExample {

    // 泛型方法，接受多个参数
    public <T, U> void printPair(T first, U second) {
        System.out.println("First: " + first);
        System.out.println("Second: " + second);
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 传递 Integer 和 String，编译器推导出 T 为 Integer，U 为 String
        example.printPair(1, "apple");

        // 传递 Double 和 Character，编译器推导出 T 为 Double，U 为 Character
        example.printPair(3.14, 'A');
    }
}
/*
输出：
First: 1
Second: apple
First: 3.14
Second: A
*/

解释：

在这个例子中，printPair 方法接受两个参数 first 和 second，分别是不同的类型。编译器根据传入的参数类型推导出泛型类型 T 和 U 的具体类型。

5.5 类型推导的局限性与注意事项

虽然类型推导非常方便，但它也有一些局限性和需要注意的地方：

5.5.1 方法无法推导泛型类型时会报错

当 Java 编译器无法根据传递给泛型方法的参数推导出唯一的类型时，它会报错。例如，如果你传递了一个 null 值或其他无法确定类型的值，编译器就无法推导出类型。

java">public class GenericMethodExample {

    public <T> void printElement(T element) {
        System.out.println(element);
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 编译器无法推导出类型，因为传入的是 null
        example.printElement(null);  // 编译错误：null 值无法推导出具体类型
    }
}

解释：

null 作为一个类型不确定的值，不能直接用于推导类型。在这种情况下，编译器无法确定泛型参数 T 的具体类型，因而报错。

5.5.2 类型推导失败时的明确类型声明

在无法自动推导出类型时，你可以显式地指定泛型类型参数。例如，使用 printElement(Integer) 来明确指定类型，而不是依赖推导。

java">public class GenericMethodExample {

    public <T> void printElement(T element) {
        System.out.println(element);
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 显式指定类型为 Integer
        example.<Integer>printElement(10);
    }
}

5.5.3 类型擦除与泛型类型推导(不能在泛型方法中直接创建数组)

即使你在方法中使用了泛型，Java 编译器在运行时会执行类型擦除，所有的泛型类型会在运行时被擦除为原始类型（通常是 Object）。因此，你无法在运行时直接通过泛型类型获得具体类型信息。

关于泛型方法中不能直接创建数组，因为类型擦除会把数组元素类型擦除，导致数组创建的时候u程序不知道要创建什么类型的数组，无法为数组分配空间，但是，有同学可能会有疑问：不是还有泛型类型推导吗，在使用泛型方法的时候不是将数组的类型传递进来了吗？为什么不能通过类型推导传递数组的数据类型，从而在泛型方法中创建数组呢？

这个问题涉及到 Java 泛型的 类型擦除机制，以及 数组的创建限制。尽管泛型类型可以通过方法的参数传递给方法，但是 数组的创建 和 类型擦除 之间的关系使得无法直接推断出新建的泛型数组的类型。

5.5.3.1 为什么不能直接推断数组的类型？

类型擦除 是 Java 泛型的一大特性，它在编译时会将所有泛型类型擦除为 Object（或者在某些情况下是指定的边界类型），因此 在运行时并没有保留泛型类型的信息。具体到数组的创建，Java 不允许直接通过泛型类型来创建数组，因为在运行时，泛型类型 T 已经被擦除为 Object，而数组在运行时需要明确的类型。

详细解释：

泛型擦除与数组的创建：
- 当你在 Java 中定义了一个泛型方法：
```
java">public <T> void example(T[] array) {
    T[] newArray = new T[10];  // 编译错误
}
```
  你可能认为 T 是通过参数传递的，因此可以推断出 T 的类型并用它来创建一个新的数组。但问题是，在编译后，Java 编译器会将所有的泛型 T 替换为 Object（即发生了类型擦除），所以在运行时，T[] 就变成了 Object[]。这就导致了问题，因为 Java 不允许你直接通过 T 创建一个数组，因为在运行时 T 已经被擦除了。
泛型类型和数组的创建：
- 数组的创建与普通对象的创建不同。数组是一个 固定类型的数据结构，而且 Java 需要知道数组的元素类型，以便分配内存和进行类型安全检查。由于泛型类型在运行时没有保留，所以你无法通过泛型类型直接创建数组。例如，new T[10] 这样的写法会在编译时产生错误，原因是编译器无法确定 T 的实际类型。
- 而且 Java 在运行时是通过反射或 具体类型信息 来创建数组的，因此无法直接通过 T 来创建数组。

5.3.2 为什么传递类型参数后不能直接推断？

传递 T[] 类型的参数时，编译器已经能够根据方法调用来推断 T 的具体类型（如 Integer 或 String），但是在 方法内部创建数组时，编译器无法推断出 T[] 的具体类型，因为此时 Java 泛型类型已被擦除，运行时并没有存储类型信息。所以，即使你通过方法参数传递了类型，Java 仍然不知道如何通过泛型 T 来创建具体的数组。

举个例子：

假设你有一个泛型方法，并且你希望在方法内部创建一个泛型数组：

java">public <T> void example(T[] array) {
    T[] newArray = new T[10];  // 编译错误
}

这里，T[] 是一个泛型数组，你期望通过 T 创建一个数组。然而，由于 类型擦除，T 会在编译时被擦除为 Object，所以 Java 不能确定在运行时应该创建什么类型的数组。换句话说，在运行时，T 就变成了 Object，所以无法创建 Object[] 类型的数组。

5.5.4 如果一定要在泛型方法中创建一个数组，要怎么办？

1. 使用 `Class` 对象和反射来创建数组：

通过传递 Class<T> 类型参数，结合反射机制，可以动态创建泛型类型的数组。

java">import java.lang.reflect.Array;

public class GenericMethodExample {
    public <T> void example(Class<T> clazz) {
        T[] newArray = (T[]) Array.newInstance(clazz, 10);  // 通过反射创建数组
        System.out.println(newArray.length);  // 输出：10
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();
        example.example(Integer.class);  // 创建 Integer 类型的数组
        example.example(String.class);   // 创建 String 类型的数组
    }
}

2. 使用 `Object[]` 数组：

一种简单的方式是，直接使用 Object[] 类型来存储泛型类型的元素，因为所有类型都会被转换为 Object 类型。

java">public <T> void example() {
    Object[] newArray = new Object[10];  // 使用 Object[]
}

3. 使用集合类（如 `ArrayList`）替代数组：

Java 泛型的使用主要是为了类型安全和灵活性。如果不需要严格使用数组，可以使用 ArrayList<T>，它是更通用的集合类型，能够处理不同类型的数据，并且不需要关注数组的大小。

java">import java.util.ArrayList;

public <T> void example() {
    ArrayList<T> list = new ArrayList<>();  // 使用 ArrayList
    list.add(someElement);  // 添加元素
}

5.6 泛型方法的多个类型参数

泛型方法不仅可以有一个类型参数，还可以有多个类型参数。这种情况下，你需要在方法声明中使用多个类型参数，并且在方法内部使用这些类型。

java">public class GenericMethodExample {
    // 泛型方法：接受多个类型参数
    public <T, U> void printPair(T first, U second) {
        System.out.println("First: " + first + ", Second: " + second);
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 使用不同类型的参数
        example.printPair("Hello", 100);  // 输出：First: Hello, Second: 100
        example.printPair(3.14, true);    // 输出：First: 3.14, Second: true
    }
}

在这个例子中，printPair 方法使用了两个泛型类型参数 T 和 U，分别代表方法的两个不同参数类型。这样的方法可以灵活地处理不同类型的参数。

6.泛型方法实际应用场景

1.最简单的泛型方法示例

java">public class GenericMethodExample {
    // 定义一个泛型方法，打印传入的参数
    public static <T> void print(T value) {
        System.out.println(value);
    }

    public static void main(String[] args) {
        // 调用泛型方法，传入不同类型的参数
        print("Hello, world!");   // 输出：Hello, world!
        print(123);               // 输出：123
        print(45.67);             // 输出：45.67
    }
}

在这个例子中，print 方法是一个泛型方法，<T> 表示方法可以接受任何类型的参数。我们调用 print 方法时，不需要指定类型，编译器会根据传入的参数类型推断出 T 的类型。

2.泛型方法的多重类型参数

java">public class GenericMethodExample {
    // 定义一个泛型方法，接受两个类型的参数
    public static <T, U> void printPair(T first, U second) {
        System.out.println("First: " + first);
        System.out.println("Second: " + second);
    }

    public static void main(String[] args) {
        printPair("Hello", 123);  // 输出 First: Hello  Second: 123
        printPair(45.67, true);    // 输出 First: 45.67  Second: true
    }
}

在这个例子中，<T, U> 表示泛型方法接受两个不同类型的参数。方法可以处理不同类型的传入数据。

3.泛型方法的规则

3.1 泛型方法与泛型类不同：泛型方法的类型参数只在方法内有效，而泛型类的类型参数在整个类内都有效。

3.2 类型推断：在调用泛型方法时，Java 编译器会自动推断类型参数。如果调用时没有显式指定类型，编译器会根据方法的参数自动推断。

3.3 多个类型参数：你可以为泛型方法定义多个类型参数（如 <T, U>）。

3.4 泛型方法可以是静态的：即使是静态方法，依然可以定义泛型类型参数。

3.5 类型安全：避免了类型强制转换，减少了运行时错误。

3.6 提高代码复用性：你可以在不同的情况下使用同一个方法，只需提供不同的类型参数。

3.7 简洁性：通过泛型方法，你不需要为每种类型写一个独立的方法，代码更加简洁。

3.8 通用的交换方法

java">public class GenericMethodExample {
    // 泛型方法，用于交换两个元素
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        String[] names = {"Alice", "Bob", "Charlie"};
        swap(names, 0, 2);  // 交换 Alice 和 Charlie
        System.out.println(names[0]);  // 输出 Charlie
        System.out.println(names[2]);  // 输出 Alice
    }
}

泛型方法在集合中的应用

java">import java.util.List;

public class GenericMethodExample {
    // 泛型方法，打印列表中的所有元素
    public static <T> void printList(List<T> list) {
        for (T item : list) {
            System.out.println(item);
        }
    }

    public static void main(String[] args) {
        List<String> list = List.of("Apple", "Banana", "Cherry");
        printList(list);
    }
}