深入理解Java包装类与泛型的应用

public class BoxingUnboxingExample {
    public static void main(String[] args) {
        // 自动装箱
        int primitiveInt = 10;
        Integer boxedInt = primitiveInt; // 编译器会自动调用 Integer.valueOf(int)

        // 自动拆箱
        int unboxedInt = boxedInt; // 编译器会自动调用 boxedInt.intValue()

        // 在算术运算中自动拆箱
        Integer anotherBoxedInt = 20;
        int result = boxedInt + anotherBoxedInt; // 实际上会拆箱为 int，然后执行加法运算，再装箱为 Integer（如果赋值给 Integer 变量）
        // 但由于 result 是 int 类型，所以这里只涉及拆箱，不涉及装箱

        // 显式装箱和拆箱（通常不需要这样做，因为自动装箱和拆箱已经足够）
        Integer explicitlyBoxedInt = Integer.valueOf(primitiveInt); // 显式装箱
        int explicitlyUnboxedInt = explicitlyBoxedInt.intValue(); // 显式拆箱

        // 打印结果以验证
        System.out.println("Primitive int: " + primitiveInt);
        System.out.println("Boxed int: " + boxedInt);
        System.out.println("Unboxed int: " + unboxedInt);
        System.out.println("Result of boxed int addition: " + result);
        System.out.println("Explicitly boxed int: " + explicitlyBoxedInt);
        System.out.println("Explicitly unboxed int: " + explicitlyUnboxedInt);
    }
}

// 定义一个泛型类 Box
public class Box<T> {
    // 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);
Integer content = integerBox.getContent();

// 定义一个泛型接口 Pair
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }
}

// 定义一个泛型方法 printArray
public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

Integer[] intArray = {1, 2, 3, 4, 5};
printArray(intArray); // 输出: 1 2 3 4 5

ArrayList<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");

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

// 使用无界通配符
List<?> unknownList = new ArrayList<String>();

// 使用上界通配符
List<? extends Number> numberList = new ArrayList<Integer>();
// numberList 可以是 Integer、Double、Float 等 Number 子类的列表，但不能添加除 null 以外的元素

// 使用下界通配符
List<? super Integer> integerSuperList = new ArrayList<Number>();
// integerSuperList 可以是 Number 或 Number 的父类（如 Object）的列表，可以添加 Integer 或 Integer 的子类对象

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

public class WrapperGenericsExample {
    public static void main(String[] args) {
        // 创建一个存储Integer对象的ArrayList
        List<Integer> integerList = new ArrayList<>();

        // 向列表中添加整数（自动装箱）
        integerList.add(10);
        integerList.add(20);
        integerList.add(30);

        // 遍历列表并打印每个元素（自动拆箱）
        for (Integer integer : integerList) {
            System.out.println(integer);
        }

        // 使用包装类的方法
        int sum = 0;
        for (Integer integer : integerList) {
            sum += integer.intValue(); // 使用intValue()方法将Integer转换为int
        }
        System.out.println("Sum: " + sum);
    }
}

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

// 定义一个简单的泛型类
public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }

    // 一个用于反射获取泛型类型信息的方法（注意：这个方法在泛型擦除后无法直接获取到T的具体类型）
    public Type getGenericType() {
        return ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, World!");
        System.out.println(stringBox.getContent());

        // 通过反射尝试获取泛型类型信息（实际上在运行时已经擦除）
        Type genericType = stringBox.getGenericType();
        System.out.println("Generic type (at runtime, may be erased): " + genericType);

        // 但我们可以通过子类化并立即获取泛型信息来“绕过”擦除（这种方法不适用于所有情况）
        class StringBox extends Box<String> {}
        Type stringBoxType = StringBox.class.getGenericSuperclass().getActualTypeArguments()[0];
        System.out.println("Generic type of StringBox (inferred at compile time): " + stringBoxType);

        // 注意到，直接使用Box<String>的实例在运行时无法获取到T的具体类型，因为泛型信息已被擦除
    }
}

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

public class TypeInferenceExample {
    public static void main(String[] args) {
        // 在Java 7及更高版本中，可以在右侧的构造函数调用中省略泛型类型参数
        List<String> list1 = new ArrayList<>(); // 类型推断为List<String>

        // 在Java 10及更高版本中，可以使用var关键字进一步简化变量声明
        var list2 = new ArrayList<String>(); // 类型推断为ArrayList<String>（但var的使用应谨慎，以避免降低代码可读性）

        // 方法调用中的类型推断
        printList(list1); // 编译器可以推断出list1的类型为List<String>

        // 泛型方法调用中的类型推断
        List<Integer> numbers = createListWithNumbers(1, 2, 3, 4, 5); // 编译器可以推断出返回类型为List<Integer>
    }

    // 一个简单的泛型方法，用于创建并返回一个包含指定元素的列表
    public static <T> List<T> createListWithElements(T... elements) {
        List<T> list = new ArrayList<>();
        for (T element : elements) {
            list.add(element);
        }
        return list;
    }

    // 一个用于打印列表内容的方法（注意：这里不是泛型方法，只是接受泛型类型的参数）
    public static void printList(List<?> list) {
        for (Object element : list) {
            System.out.println(element);
        }
    }

    // 一个具体的泛型方法调用示例，用于创建并返回一个包含数字的列表
    public static List<Integer> createListWithNumbers(Integer... numbers) {
        return createListWithElements(numbers); // 这里再次调用了泛型方法createListWithElements，并进行了类型推断
    }
}

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

public class WrapperAndGenericsExample {
    public static void main(String[] args) {
        // 创建一个存储Integer对象的列表
        List<Integer> integerList = new ArrayList<>();
        integerList.add(10);
        integerList.add(20);
        integerList.add(30);

        // 遍历列表并打印元素
        for (Integer integer : integerList) {
            System.out.println(integer);
        }

        // 创建一个存储Double对象的列表
        List<Double> doubleList = new ArrayList<>();
        doubleList.add(1.1);
        doubleList.add(2.2);
        doubleList.add(3.3);

        // 使用泛型方法来打印Double列表
        printList(doubleList);
    }

    // 泛型方法，用于打印列表中的元素
    public static <T> void printList(List<T> list) {
        for (T element : list) {
            System.out.println(element);
        }
    }
}