Java泛型编程详解#

什么是泛型？#

泛型是Java 5引入的特性，它允许在定义类、接口和方法时使用类型参数，从而实现代码的复用和类型安全。

泛型的好处#

类型安全：在编译时检查类型，避免运行时的类型转换错误
代码复用：编写通用的代码，适用于不同类型
可读性：代码更加清晰，不需要显式的类型转换
性能优化：避免了运行时的类型检查和转换，提高性能

泛型的基本语法#

泛型类#

1
public class Box<T> {
2
    private T value;
3

4
    public void setValue(T value) {
5
        this.value = value;
6
    }
7

8
    public T getValue() {
9
        return value;
10
    }
11
}
12

13
// 使用
14
Box<String> stringBox = new Box<>();
15
stringBox.setValue("Hello");
16
String value = stringBox.getValue();
17

18
Box<Integer> integerBox = new Box<>();
19
integerBox.setValue(100);
20
Integer number = integerBox.getValue();

泛型接口#

1
public interface List<T> {
2
    void add(T element);
3
    T get(int index);
4
    int size();
5
}
6

7
// 实现
8
public class ArrayList<T> implements List<T> {
9
    // 实现代码
10
}

泛型方法#

1
public class GenericMethod {
2
    public static <T> void printArray(T[] array) {
3
        for (T element : array) {
4
            System.out.print(element + " ");
5
        }
6
        System.out.println();
7
    }
8

9
    public static <T> T getFirstElement(T[] array) {
10
        if (array != null && array.length > 0) {
11
            return array[0];
12
        }
13
        return null;
14
    }
15
}
16

17
// 使用
18
Integer[] intArray = {1, 2, 3, 4, 5};
19
GenericMethod.printArray(intArray);
20

21
String[] stringArray = {"Hello", "World"};
22
GenericMethod.printArray(stringArray);
23

24
Integer firstInt = GenericMethod.getFirstElement(intArray);
25
String firstString = GenericMethod.getFirstElement(stringArray);

类型参数命名约定#

T：Type（类型）
E：Element（元素）
K：Key（键）
V：Value（值）
N：Number（数字）
S, U, V：第二、第三、第四个类型参数

泛型的边界#

上界通配符#

上界通配符使用extends关键字，表示类型参数必须是指定类型的子类或本身。

1
public class GenericUpperBound {
2
    public static double sumOfNumbers(List<? extends Number> numbers) {
3
        double sum = 0.0;
4
        for (Number number : numbers) {
5
            sum += number.doubleValue();
6
        }
7
        return sum;
8
    }
9
}
10

11
// 使用
12
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
13
double intSum = GenericUpperBound.sumOfNumbers(integers);
14

15
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
16
double doubleSum = GenericUpperBound.sumOfNumbers(doubles);

下界通配符#

下界通配符使用super关键字，表示类型参数必须是指定类型的父类或本身。

1
public class GenericLowerBound {
2
    public static void addNumbers(List<? super Integer> numbers) {
3
        numbers.add(1);
4
        numbers.add(2);
5
        numbers.add(3);
6
    }
7
}
8

9
// 使用
10
List<Object> objects = new ArrayList<>();
11
GenericLowerBound.addNumbers(objects);
12

13
List<Number> numbers = new ArrayList<>();
14
GenericLowerBound.addNumbers(numbers);
15

16
List<Integer> integers = new ArrayList<>();
17
GenericLowerBound.addNumbers(integers);

无界通配符#

无界通配符使用?表示，可以匹配任何类型。

1
public class GenericUnbounded {
2
    public static void printList(List<?> list) {
3
        for (Object element : list) {
4
            System.out.print(element + " ");
5
        }
6
        System.out.println();
7
    }
8
}
9

10
// 使用
11
List<Integer> integers = Arrays.asList(1, 2, 3);
12
GenericUnbounded.printList(integers);
13

14
List<String> strings = Arrays.asList("Hello", "World");
15
GenericUnbounded.printList(strings);

泛型的类型擦除#

什么是类型擦除？#

类型擦除是Java泛型的实现机制，它在编译时擦除了泛型类型信息，将泛型类型替换为其边界类型（如果没有指定边界，则替换为Object）。

类型擦除的过程#

编译时擦除类型参数
替换为边界类型（或Object）
插入必要的类型转换
生成桥接方法（用于继承泛型类或实现泛型接口）

类型擦除的影响#

运行时类型信息丢失：运行时无法获取泛型类型参数
不能使用基本类型作为类型参数：必须使用包装类
不能创建泛型数组：但可以声明泛型数组引用
不能使用instanceof检查泛型类型：只能检查原始类型

1
// 类型擦除的示例
2
public class Box<T> {
3
    private T value;
4

5
    public void setValue(T value) {
6
        this.value = value;
7
    }
8

9
    public T getValue() {
10
        return value;
11
    }
12
}
13

14
// 编译后擦除为
15
public class Box {
16
    private Object value;
17

18
    public void setValue(Object value) {
19
        this.value = value;
20
    }
21

22
    public Object getValue() {
23
        return value;
24
    }
25
}

泛型的限制#

1. 不能使用基本类型作为类型参数#

1
// 错误
2
Box<int> intBox = new Box<>();
3

4
// 正确
5
Box<Integer> integerBox = new Box<>();

2. 不能创建泛型数组#

1
// 错误
2
List<String>[] stringLists = new List<String>[10];
3

4
// 正确
5
List<?>[] listArray = new List<?>[10];
6
List<String>[] stringLists = (List<String>[]) new List<?>[10];

3. 不能使用instanceof检查泛型类型#

1
// 错误
2
if (box instanceof Box<String>) {
3
    // 代码
4
}
5

6
// 正确
7
if (box instanceof Box<?>) {
8
    // 代码
9
}

4. 不能在静态上下文中使用类型参数#

1
public class Box<T> {
2
    // 错误
3
    private static T staticValue;
4

5
    // 错误
6
    public static T getStaticValue() {
7
        return staticValue;
8
    }
9
}

5. 不能创建类型参数的实例#

1
public class Box<T> {
2
    // 错误
3
    private T value = new T();
4

5
    // 错误
6
    public Box() {
7
        value = new T();
8
    }
9
}
10

11
// 解决方案：使用反射
12
public class Box<T> {
13
    private T value;
14

15
    public Box(Class<T> clazz) throws InstantiationException, IllegalAccessException {
16
        value = clazz.newInstance();
17
    }
18
}

6. 不能创建类型参数的数组#

1
public class Box<T> {
2
    // 错误
3
    private T[] array = new T[10];
4

5
    // 解决方案：使用Object数组并进行类型转换
6
    private Object[] array = new Object[10];
7

8
    @SuppressWarnings("unchecked")
9
    public T get(int index) {
10
        return (T) array[index];
11
    }
12

13
    public void set(int index, T value) {
14
        array[index] = value;
15
    }
16
}

泛型的高级特性#

1. 泛型的继承#

1
// 泛型类的继承
2
public class NumberBox<T extends Number> extends Box<T> {
3
    public double doubleValue() {
4
        return getValue().doubleValue();
5
    }
6
}
7

8
// 使用
9
NumberBox<Integer> integerBox = new NumberBox<>();
10
integerBox.setValue(100);
11
double value = integerBox.doubleValue();

2. 泛型的通配符捕获#

1
public class GenericCapture {
2
    public static void reverse(List<?> list) {
3
        reverseHelper(list);
4
    }
5

6
    private static <T> void reverseHelper(List<T> list) {
7
        int size = list.size();
8
        for (int i = 0; i < size / 2; i++) {
9
            T temp = list.get(i);
10
            list.set(i, list.get(size - 1 - i));
11
            list.set(size - 1 - i, temp);
12
        }
13
    }
14
}

3. 泛型的类型推断#

Java 7+ 支持钻石操作符（<>），可以自动推断泛型类型。

1
// Java 7之前
2
Box<String> stringBox = new Box<String>();
3

4
// Java 7+
5
Box<String> stringBox = new Box<>(); // 自动推断类型

Java 8+ 支持方法引用和lambda表达式的类型推断。

4. 泛型的桥接方法#

当子类继承泛型父类或实现泛型接口时，编译器会生成桥接方法来保持类型擦除后的多态性。

1
public interface Comparable<T> {
2
    int compareTo(T o);
3
}
4

5
public class String implements Comparable<String> {
6
    @Override
7
    public int compareTo(String o) {
8
        // 实现
9
    }
10

11
    // 编译器生成的桥接方法
12
    public int compareTo(Object o) {
13
        return compareTo((String) o);
14
    }
15
}

泛型的实际应用#

1. 集合框架#

Java的集合框架广泛使用泛型：

1
List<String> list = new ArrayList<>();
2
list.add("Hello");
3
String value = list.get(0);
4

5
Map<String, Integer> map = new HashMap<>();
6
map.put("key", 100);
7
Integer value = map.get("key");
8

9
Set<Integer> set = new HashSet<>();
10
set.add(1);
11
set.add(2);

2. 工具类#

1
public class Collections {
2
    public static <T extends Comparable<? super T>> void sort(List<T> list) {
3
        // 排序实现
4
    }
5

6
    public static <T> void shuffle(List<T> list) {
7
        // 随机打乱实现
8
    }
9

10
    public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) {
11
        // 求最大值实现
12
    }
13
}

3. 自定义泛型类和方法#

1
// 自定义泛型工具类
2
public class ArrayUtils {
3
    public static <T> void swap(T[] array, int i, int j) {
4
        if (array != null && i >= 0 && j >= 0 && i < array.length && j < array.length) {
5
            T temp = array[i];
6
            array[i] = array[j];
7
            array[j] = temp;
8
        }
9
    }
10

11
    public static <T> T[] copyOf(T[] original, int newLength) {
12
        @SuppressWarnings("unchecked")
13
        T[] copy = (T[]) new Object[newLength];
14
        System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
15
        return copy;
16
    }
17
}

最佳实践#

使用有意义的类型参数名：使用T、E、K、V等约定的类型参数名，提高代码可读性。
指定合适的类型边界：使用extends和super指定类型边界，提高类型安全性。
优先使用泛型方法：对于不需要在类级别使用类型参数的情况，优先使用泛型方法。
使用通配符提高灵活性：在方法参数中使用通配符，提高方法的灵活性。
避免原始类型：避免使用原始类型（如List而不是List<?>），使用原始类型会失去泛型的类型安全优势。
使用@SuppressWarnings(“unchecked”)：当不可避免需要类型转换时，使用@SuppressWarnings(“unchecked”)注解抑制警告。
考虑类型擦除的影响：编写泛型代码时，考虑类型擦除的影响，避免运行时错误。
使用Java 7+的钻石操作符：使用<>自动推断类型参数，简化代码。
为泛型类提供类型安全的工厂方法：提供类型安全的工厂方法，简化泛型类的创建。
测试泛型代码：编写测试用例，确保泛型代码在各种情况下都能正常工作。

常见陷阱#

原始类型的使用：使用原始类型（如List）而不是泛型类型（如List<?>），导致类型安全问题。
类型转换错误：在泛型代码中进行错误的类型转换，导致ClassCastException。
通配符使用不当：不正确使用上界和下界通配符，导致编译错误。
类型擦除的误解：不了解类型擦除的机制，导致运行时错误。
泛型数组的创建：尝试创建泛型数组，导致编译错误。
静态上下文中使用类型参数：在静态上下文中使用类型参数，导致编译错误。
类型参数的实例化：尝试创建类型参数的实例，导致编译错误。
过度使用泛型：过度使用泛型，导致代码复杂度过高。

总结#

泛型是Java编程中的重要特性，它提供了类型安全、代码复用和可读性等优势。通过使用泛型，我们可以编写更加灵活、安全和高效的代码。

本文介绍了Java泛型的基本语法、边界、类型擦除、限制和高级特性，以及泛型的实际应用和最佳实践。希望本文能够帮助你更好地理解和使用Java的泛型特性。

练习#

编写一个泛型类Pair<T, U>，用于存储两个不同类型的值。
编写一个泛型方法，用于反转任意类型的数组。
编写一个泛型接口，定义排序功能。
编写一个泛型类，实现栈（Stack）数据结构。
编写一个泛型方法，用于查找数组中的最大值。
编写一个泛型类，支持上界通配符，只能存储Number及其子类。
编写一个泛型方法，演示下界通配符的使用。
编写一个程序，演示类型擦除的影响。
编写一个程序，处理泛型的限制，如创建类型参数的实例。
编写一个程序，使用泛型集合框架，如List、Map、Set等。

溪谷回声

投石问路，静听回响

Java泛型编程详解