Java 包装类与泛型应用详解

在实际使用中，有几个关键点需要留意：

1. 性能开销：频繁装箱拆箱会创建大量临时对象，影响性能。
2. 空指针异常：包装类是引用类型，可为 null。若对 null 进行拆箱，会抛出 NullPointerException。
3. 缓存机制：Integer 等类对 -128 到 127 之间的值进行了缓存。超出此范围比较时，== 可能失效，建议使用 equals()。
4. 常用方法：如 parseInt、valueOf、intValue 等，根据场景选择。

二、Java 泛型基础

泛型的引入主要为了解决类型安全问题并提高代码复用性。在此之前，集合只能存储 Object，取出时需强制转换且容易出错。

泛型的主要优势包括：

• 类型安全：编译期检查类型，减少 ClassCastException。
• 代码复用：一套逻辑适配多种数据类型。
• 消除冗余：无需手动类型转换，代码更清晰。

泛型类与接口

定义泛型类时，在类名后指定类型参数：

public class Box<T> {
    private T content;
    public void setContent(T content) { this.content = content; }
    public T getContent() { return content; }
}

使用时指定具体类型：

Box<Integer> integerBox = new Box<>();
integerBox.setContent(100);

泛型接口类似，实现时需明确类型：

public interface Pair<K, V> { K getKey(); V getValue(); }
public class OrderedPair<K, V> implements Pair<K, V> { ... }

泛型方法与通配符

泛型方法在返回类型前声明类型参数：

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

通配符 ? 用于表示未知类型：

• List<?>：无界通配符。
• List<? extends Number>：上界，可读取但不能写入（除 null）。
• List<? super Integer>：下界，可写入 Integer 及其子类。

三、包装类与泛型的结合

当需要将基本类型存入集合时，必须使用包装类。例如 ArrayList<Integer> 提供了类型安全的整数列表。

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

public class WrapperGenericsExample {
    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(10);
        integerList.add(20);

        // 遍历时的自动拆箱
        for (Integer integer : integerList) {
            System.out.println(integer);
        }

        // 计算总和
        int sum = 0;
        for (Integer integer : integerList) {
            sum += integer.intValue(); 
        }
        System.out.println("Sum: " + sum);
    }
}

注意：虽然泛型集合理论上允许 null，但实际开发中应尽量避免，以防遍历时出现空指针。

四、Java 泛型进阶

泛型擦除

Java 泛型在运行时存在类型擦除现象。这意味着在字节码层面，泛型信息会被移除，还原为原始类型。

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Box<T> {
    private T content;
    public void setContent(T content) { this.content = content; }
    public T getContent() { return content; }
    
    // 通过反射尝试获取泛型信息
    public Type getGenericType() {
        return ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello");
        
        // 直接实例化无法获取 T 的具体类型，因为已擦除
        // 需要通过继承类才能保留泛型信息
        class StringBox extends Box<String> {}
        Type type = StringBox.class.getGenericSuperclass().getActualTypeArguments()[0];
        System.out.println(type);
    }
}

类型推断

Java 7 引入了菱形运算符 <>，Java 10 引入了 var，进一步简化了泛型代码。

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

public class TypeInferenceExample {
    public static void main(String[] args) {
        // Java 7+ 菱形语法
        List<String> list1 = new ArrayList<>(); 
        
        // Java 10+ var 关键字
        var list2 = new ArrayList<String>(); 
        
        // 泛型方法调用
        List<Integer> numbers = createListWithElements(1, 2, 3);
    }

    public static <T> List<T> createListWithElements(T... elements) {
        List<T> list = new ArrayList<>();
        for (T e : elements) list.add(e);
        return list;
    }
}

五、实战总结

在实际开发中，包装类与泛型的组合非常常见。核心原则是：优先保证类型安全，同时注意性能边界。

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

public class WrapperAndGenericsExample {
    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(10);
        integerList.add(20);
        integerList.add(30);

        // 打印列表
        printList(integerList);

        List<Double> doubleList = new ArrayList<>();
        doubleList.add(1.1);
        printList(doubleList);
    }

    public static <T> void printList(List<T> list) {
        for (T element : list) {
            System.out.println(element);
        }
    }
}

掌握这些机制，能帮助你写出更安全、更健壮的 Java 代码。