MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java泛型与集合操作

2024-09-148.0k 阅读

Java 泛型基础

泛型是 Java 5.0 引入的一个强大特性，它允许我们在定义类、接口和方法时使用类型参数。通过使用泛型，我们可以编写更加通用、类型安全且可重用的代码。

泛型类

泛型类是最常见的泛型应用场景。例如，我们可以定义一个简单的 Box 类来存储任意类型的对象：

public class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

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

在上述代码中，<T> 是类型参数，T 通常被用作类型参数的占位符，你也可以使用其他字母，如 <E>、<K>、<V> 等，这些字母都有约定俗成的含义。E 常用于集合中，表示元素类型，K 和 V 分别用于键值对中，表示键类型和值类型。

我们可以这样使用这个 Box 类：

Box<Integer> integerBox = new Box<>(10);
Integer num = integerBox.getValue();
System.out.println(num);

Box<String> stringBox = new Box<>("Hello, Java Generics!");
String str = stringBox.getValue();
System.out.println(str);

通过这种方式，我们可以创建不同类型的 Box，并且在编译时就确保类型安全。如果尝试将不匹配的类型放入 Box 中，编译器会报错。

泛型接口

泛型接口的定义方式与泛型类类似。例如，定义一个 Generator 接口，它可以生成特定类型的值：

public interface Generator<T> {
    T generate();
}

然后我们可以实现这个接口：

public class IntegerGenerator implements Generator<Integer> {
    @Override
    public Integer generate() {
        return (int) (Math.random() * 100);
    }
}

public class StringGenerator implements Generator<String> {
    @Override
    public String generate() {
        return "Generated String";
    }
}

使用这些实现类：

Generator<Integer> intGenerator = new IntegerGenerator();
Integer randomInt = intGenerator.generate();
System.out.println(randomInt);

Generator<String> stringGenerator = new StringGenerator();
String randomStr = stringGenerator.generate();
System.out.println(randomStr);

泛型方法

除了泛型类和泛型接口，Java 还支持泛型方法。泛型方法允许我们在方法中使用类型参数，而不必在类级别定义。例如：

public class GenericMethodExample {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

在上述代码中，<T> 是泛型方法 printArray 的类型参数。我们可以这样调用这个方法：

Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"a", "b", "c", "d", "e"};

GenericMethodExample.printArray(intArray);
GenericMethodExample.printArray(stringArray);

泛型方法可以有多个类型参数，例如：

public static <T, U> void printPair(T first, U second) {
    System.out.println("First: " + first + ", Second: " + second);
}

调用方式如下：

printPair(10, "Hello");

类型擦除

Java 泛型是在编译期实现的，这意味着泛型信息在运行时会被擦除。类型擦除是指编译器会将泛型类型替换为它们的边界类型（如果有边界的话，否则替换为 Object）。

例如，对于我们前面定义的 Box<T> 类，在编译后，字节码中 Box 类的定义实际上是：

public class Box {
    private Object value;

    public Box(Object value) {
        this.value = value;
    }

    public Object getValue() {
        return value;
    }

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

当我们使用 Box<Integer> 时，编译器会在必要的地方插入类型转换：

Box<Integer> integerBox = new Box<>(10);
Integer num = (Integer) integerBox.getValue();

这种类型擦除机制使得 Java 泛型能够兼容旧版本的代码，同时在编译期提供类型安全检查。

但是，类型擦除也带来了一些限制。例如，无法在运行时获取泛型类型的实际类型参数：

Box<Integer> integerBox = new Box<>(10);
Class<?> clazz = integerBox.getClass();
// 这里无法直接获取到 <Integer> 这个类型参数

泛型的边界

上界限定

有时候，我们希望限制类型参数只能是某个特定类型或其子类型。这可以通过上界限定来实现。例如，我们定义一个方法，它只能接受 Number 及其子类的对象：

public static double sum(List<? extends Number> list) {
    double sum = 0;
    for (Number num : list) {
        sum += num.doubleValue();
    }
    return sum;
}

在上述代码中，? extends Number 表示类型参数是 Number 或 Number 的子类。这样，我们可以传入 List<Integer>、List<Double> 等，但不能传入 List<String>。

调用示例：

List<Integer> intList = Arrays.asList(1, 2, 3);
double intSum = sum(intList);
System.out.println(intSum);

List<Double> doubleList = Arrays.asList(1.5, 2.5, 3.5);
double doubleSum = sum(doubleList);
System.out.println(doubleSum);

下界限定

下界限定与上界限定相反，它限制类型参数只能是某个特定类型或其父类型。例如，我们定义一个方法，它只能接受 Integer 及其父类型的对象：

public static void addNumber(List<? super Integer> list, Integer num) {
    list.add(num);
}

在上述代码中，? super Integer 表示类型参数是 Integer 或 Integer 的父类型。这样，我们可以传入 List<Integer>、List<Number> 等。

调用示例：

List<Integer> intList = new ArrayList<>();
addNumber(intList, 10);

List<Number> numberList = new ArrayList<>();
addNumber(numberList, 20);

Java 集合与泛型

Java 集合框架是 Java 编程中非常重要的一部分，而泛型与集合的结合使得集合操作更加类型安全和便捷。

List

List 是一个有序的集合，允许重复元素。在使用泛型时，我们可以指定 List 中元素的类型。例如：

List<String> stringList = new ArrayList<>();
stringList.add("Apple");
stringList.add("Banana");
stringList.add("Cherry");

for (String fruit : stringList) {
    System.out.println(fruit);
}

通过指定泛型类型 String，编译器可以确保我们只能向 stringList 中添加 String 类型的元素。如果尝试添加其他类型的元素，会在编译时报错。

Set

Set 是一个不允许重复元素的集合。同样，我们可以使用泛型来指定 Set 中元素的类型。例如：

Set<Integer> integerSet = new HashSet<>();
integerSet.add(1);
integerSet.add(2);
integerSet.add(1); // 重复元素，不会添加成功

for (Integer num : integerSet) {
    System.out.println(num);
}

这里 HashSet 会自动去除重复的元素。由于使用了泛型 Integer，编译器可以保证集合中只包含 Integer 类型的元素。

Map

Map 是一个键值对的集合，每个键最多映射到一个值。在使用泛型时，我们需要指定键和值的类型。例如：

Map<String, Integer> scoreMap = new HashMap<>();
scoreMap.put("Alice", 85);
scoreMap.put("Bob", 90);

Integer aliceScore = scoreMap.get("Alice");
System.out.println("Alice's score: " + aliceScore);

在上述代码中，Map 的键类型为 String，值类型为 Integer。通过泛型，我们可以确保在操作 scoreMap 时，键和值的类型是正确的。

集合操作中的泛型应用

遍历集合

在遍历集合时，泛型使得代码更加简洁和类型安全。例如，对于 List 的遍历：

List<Double> doubleList = Arrays.asList(1.1, 2.2, 3.3);
for (Double num : doubleList) {
    System.out.println(num * 2);
}

由于 doubleList 被定义为 List<Double>，我们可以直接在 for - each 循环中使用 Double 类型的变量，而不需要进行额外的类型转换。

对于 Map 的遍历，我们可以这样做：

Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("Tom", 20);
ageMap.put("Jerry", 22);

for (Map.Entry<String, Integer> entry : ageMap.entrySet()) {
    System.out.println(entry.getKey() + " is " + entry.getValue() + " years old.");
}

这里 Map.Entry<String, Integer> 明确了键和值的类型，使得遍历 Map 时更加清晰和安全。

集合的转换与操作

在集合之间进行转换或进行一些操作时，泛型也起着重要作用。例如，将一个 List 转换为 Set：

List<String> namesList = Arrays.asList("Alice", "Bob", "Alice");
Set<String> namesSet = new HashSet<>(namesList);

由于 namesList 是 List<String>，HashSet 的构造函数可以正确地处理 String 类型的元素，并去除重复的元素。

再比如，使用 Collections 类的一些静态方法来操作集合：

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Collections.sort(numbers);
System.out.println(numbers);

这里 Collections.sort 方法可以处理 List<Integer>，对其中的元素进行排序。由于泛型的存在，编译器可以确保方法参数的类型正确性。

通配符与泛型方法重载

通配符的使用场景

通配符 ? 在泛型中有着特殊的用途。除了前面提到的上界限定 ? extends 和下界限定 ? super，无界通配符 ? 表示未知类型。例如，我们有一个方法，它接受任何类型的 List，并打印其中的元素：

public static void printList(List<?> list) {
    for (Object element : list) {
        System.out.print(element + " ");
    }
    System.out.println();
}

这个方法可以接受 List<Integer>、List<String> 等任何类型的 List。

通配符与泛型方法重载

在重载泛型方法时，通配符可能会带来一些混淆。例如，考虑以下两个方法：

public static void processList(List<?> list) {
    System.out.println("Processing list with wildcard");
}

public static <T> void processList(List<T> list) {
    System.out.println("Processing list with type parameter");
}

当我们调用 processList 方法时：

List<Integer> intList = Arrays.asList(1, 2, 3);
processList(intList);

此时，编译器会优先选择具体类型参数的方法，即 processList(List<T> list)。如果没有这个方法，才会选择使用通配符的方法 processList(List<?> list)。

理解通配符和泛型方法重载的关系对于编写正确且清晰的代码非常重要。在实际应用中，要根据具体需求选择合适的方法定义，避免产生模棱两可的代码。

泛型与反射

反射是 Java 提供的一种机制，它允许程序在运行时获取和操作类的信息。在使用反射与泛型时，需要注意类型擦除带来的影响。

例如，我们有一个泛型类 GenericClass<T>：

public class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

使用反射来获取这个类的信息：

GenericClass<Integer> intGenericClass = newGenericClass<>(10);
Class<?> clazz = intGenericClass.getClass();
// 这里无法直接获取到 <Integer> 这个类型参数

由于类型擦除，在运行时通过反射无法直接获取泛型类型参数的具体类型。但是，我们可以通过一些技巧来部分实现获取泛型类型信息。例如，通过定义一个子类来保留泛型类型信息：

public class IntegerGenericClass extendsGenericClass<Integer> {
    public IntegerGenericClass(Integer value) {
        super(value);
    }
}

然后使用反射：

IntegerGenericClass intGenericClass = new IntegerGenericClass(10);
Type genericSuperclass = intGenericClass.getClass().getGenericSuperclass();
if (genericSuperclass instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    for (Type type : actualTypeArguments) {
        System.out.println("Actual type argument: " + type);
    }
}

在上述代码中，通过获取子类的泛型超类，可以获取到实际的类型参数 Integer。这种方法在一些需要在运行时处理泛型类型信息的场景中非常有用。

最佳实践与注意事项

合理使用泛型

在编写代码时，要根据实际需求合理使用泛型。不要过度使用泛型，导致代码变得复杂难以理解。例如，如果一个类或方法只处理特定类型的数据，就没有必要使用泛型。同时，也不要因为担心类型擦除等问题而避免使用泛型，泛型在提高代码的类型安全性和可重用性方面有着巨大的优势。

注意类型擦除的影响

由于类型擦除，在运行时泛型类型信息会丢失。这可能会导致一些在编译时无法发现的运行时错误。例如，在使用反射操作泛型类时，要注意获取到的类型信息可能与编译时的泛型类型不完全一致。尽量在编译期通过泛型的类型检查来避免潜在的错误。

保持代码的可读性

在使用泛型时，要保持代码的可读性。使用有意义的类型参数名称，例如 E 表示集合元素类型，K 和 V 表示键值对中的键和值类型。同时，在定义复杂的泛型结构时，添加适当的注释来解释泛型的作用和限制。

测试泛型代码

对于使用泛型的代码，要进行充分的测试。由于泛型可以处理多种类型的数据，要确保在不同类型参数的情况下，代码都能正确工作。可以使用单元测试框架，如 JUnit，编写针对不同类型的测试用例，以验证泛型代码的正确性和稳定性。

通过遵循这些最佳实践和注意事项，可以更好地在 Java 编程中使用泛型与集合操作，编写出更加健壮、高效且易于维护的代码。无论是开发小型应用还是大型企业级项目，合理运用泛型和集合都是提高代码质量的重要手段。在实际项目中，不断积累经验，深入理解泛型的原理和应用场景，将有助于我们成为更优秀的 Java 开发者。