问：说说Java中泛型，怎么用？

泛型在Java中是一个非常重要的特性，它允许在编译时进行类型检查，从而避免了运行时的类型转换异常。通过泛型，我们可以创建可重用的组件，这些组件可以工作于多种数据类型，同时保持类型安全。

下面，通过示例说明在不同集合类的场景下泛型的具体用法：

使用泛型ArrayList

import java.util.ArrayList;
import java.util.List;

public class GenericExample {
    public static void main(String[] args) {
        // 创建一个整型的ArrayList
        List<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);
        integerList.add(3);
        // 下面的代码将导致编译错误，因为String类型不是Integer
        // integerList.add("four"); 

        // 创建一个字符串的ArrayList
        List<String> stringList = new ArrayList<>();
        stringList.add("one");
        stringList.add("two");
        stringList.add("three");
        // 下面的代码将导致编译错误，因为Integer类型不是String
        // stringList.add(4); 
    }
}

示例，创建了两个ArrayList，一个是Integer类型，另一个是String类型。由于使用了泛型，编译器会检查添加到列表中的元素类型，确保类型安全。

使用泛型HashMap

import java.util.HashMap;
import java.util.Map;

public class GenericMapExample {
    public static void main(String[] args) {
        // 创建一个存储字符串键和整型值的HashMap
        Map<String, Integer> scoreMap = new HashMap<>();
        scoreMap.put("Alice", 90);
        scoreMap.put("Bob", 85);
        // 下面的代码将导致编译错误，因为值应该是Integer类型而不是String
        // scoreMap.put("Charlie", "A"); 

        // 创建一个存储字符串键和字符串值的HashMap
        Map<String, String> addressMap = new HashMap<>();
        addressMap.put("Alice", "123 Main St");
        addressMap.put("Bob", "456 Elm St");
        // 下面的代码将导致编译错误，因为值应该是String类型而不是Integer
        // addressMap.put("Charlie", 789); 
    }
}

示例中，使用了泛型的HashMap来存储不同类型的键值对。泛型确保了我们不能将错误类型的键或值添加到映射中。

自定义泛型类

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
    
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.setContent(123);
        // 下面的代码将导致编译错误，因为内容应该是Integer类型而不是String
        // integerBox.setContent("four"); 
        
        System.out.println(integerBox.getContent()); // 输出：123
        
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, World!");
        System.out.println(stringBox.getContent()); // 输出：Hello, World!
    }
}

示例中，我们创建了一个自定义的泛型类Box，它可以存储任何类型的对象。我们通过泛型参数T来指定要存储的对象类型，确保了类型安全。在main方法中，我们创建了两个不同类型的Box对象来展示其灵活性。

数据处理

假设有一个数据处理系统，需要处理不同类型的数据，如整数、浮点数、字符串等，并对这些数据进行排序。为了保持代码的复用性和类型安全，可以使用泛型来设计一个通用的排序方法。

public class GenericSorter<T extends Comparable<T>> {
    public void sort(List<T> list) {
        Collections.sort(list);
    }

    public static void main(String[] args) {
        GenericSorter<Integer> intSorter = new GenericSorter<>();
        List<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5);
        intSorter.sort(new ArrayList<>(integers));
        System.out.println(integers); // 输出排序后的整数列表

        GenericSorter<String> stringSorter = new GenericSorter<>();
        List<String> strings = Arrays.asList("banana", "apple", "cherry", "date");
        stringSorter.sort(new ArrayList<>(strings));
        System.out.println(strings); // 输出排序后的字符串列表
    }
}

1. 类型安全：通过使用泛型，我们可以确保排序方法仅对实现了Comparable接口的类型进行操作，从而在编译时捕获类型错误，提高了代码的类型安全性。

2. 性能：虽然泛型在编译时会有类型擦除（Type Erasure），导致运行时泛型信息丢失，但泛型的使用通常不会引入显著的性能开销。然而，在极端性能敏感的场景中，需要谨慎评估泛型可能带来的微小性能影响。

3. 可维护性：泛型提高了代码的可重用性和可维护性。在上述示例中，我们只需要编写一个通用的排序方法，就可以对多种数据类型进行排序，而无需为每种类型编写特定的排序逻辑。

4. 继承与限制：在使用泛型时，需要注意继承关系。例如，在示例中，我们限制了T必须实现Comparable<T>接口，这意味着只有实现了该接口的类型才能被排序。这种限制确保了排序操作的有效性，但同时也限制了泛型的灵活性。

结语

Java泛型可以提高代码复用性和类型安全性。通过泛型，可以编写出灵活且可重用的代码，这些代码能够处理不同类型的数据，而无需为每种类型单独实现。在数据处理、集合操作等场景中，泛型发挥着重要作用。例如，通过泛型排序方法，我们可以对整数、字符串等多种数据类型进行排序，而无需修改排序算法本身。这不仅减少了代码量，还提高了代码的可读性和可维护性。然而，在使用泛型时，也需要注意类型安全、性能影响以及继承关系等因素，以确保代码的正确性和效率。