Java 泛型常用场景

Java 泛型(Generics)是Java 5引入的重要特性，它提供了编译时类型安全检查机制，并消除了强制类型转换的需要。以下是Java泛型最常用的场景：

1. 集合框架(Collections Framework)

这是泛型最广泛应用的场景：

// 不使用泛型
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 需要强制转换

// 使用泛型
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // 自动类型推断，无需强制转换

2. 自定义泛型类

public class Box<T> {
    private T t;
    
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

// 使用
Box<Integer> integerBox = new Box<>();
integerBox.set(10);
Integer value = integerBox.get();

3. 泛型方法

public class Util {
    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}

// 使用
Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);

4. 类型安全的接口

public interface List<E> {
    void add(E x);
    Iterator<E> iterator();
}

public interface Iterator<E> {
    E next();
    boolean hasNext();
}

5. 限制类型参数(有界类型参数)

public class NaturalNumber<T extends Number> {
    private T n;
    
    public NaturalNumber(T n) { this.n = n; }
    
    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }
}

// 只能使用Number或其子类
NaturalNumber<Integer> i = new NaturalNumber<>(6);
NaturalNumber<Double> d = new NaturalNumber<>(6.0);
// NaturalNumber<String> s = new NaturalNumber<>("6"); // 编译错误

6. 通配符使用

// 上界通配符
public static double sumOfList(List<? extends Number> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

// 下界通配符
public static void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

7. 类型安全的函数式接口(Java 8+)

@FunctionalInterface
interface Function<T, R> {
    R apply(T t);
}

Function<String, Integer> lengthFunction = s -> s.length();
Integer length = lengthFunction.apply("Hello");

8. 类型安全的缓存实现

public class GenericCache<K, V> {
    private Map<K, V> cache = new HashMap<>();
    
    public void put(K key, V value) {
        cache.put(key, value);
    }
    
    public V get(K key) {
        return cache.get(key);
    }
}

泛型的主要优点包括：

• 编译时更强的类型检查
• 消除类型转换
• 实现更通用的算法
• 提高代码的可读性和重用性

正确使用泛型可以使代码更安全、更清晰，并减少运行时错误。