掌握Java泛型列表算法：实现多类型数值操作

import java.util.List;
import java.util.stream.Collectors;

public class GenericListAlgorithms {

    /**
     * 对单个Number类型的数值进行除法运算，并返回相同泛型类型的结果。
     * 该方法通过instanceof检查来处理不同的数值类型。
     *
     * @param num     待除的数值
     * @param divisor 除数
     * @param <T>     Number的子类型
     * @return 经过除法运算后的结果，类型与输入相同
     * @throws IllegalStateException 如果遇到不支持的Number子类型
     */
    private static <T extends Number> T divide(T num, int divisor) {
        if (num instanceof Double) {
            return (T) Double.valueOf(num.doubleValue() / divisor);
        }
        if (num instanceof Float) {
            return (T) Float.valueOf(num.floatValue() / divisor);
        }
        if (num instanceof Long) {
            return (T) Long.valueOf(num.longValue() / divisor);
        }
        if (num instanceof Integer) {
            return (T) Integer.valueOf(num.intValue() / divisor);
        }
        if (num instanceof Byte) {
            // 注意：byte类型的除法可能导致溢出，如果结果超出byte范围，需要额外处理
            return (T) Byte.valueOf((byte) (num.byteValue() / divisor));
        }
        // 对于其他未明确处理的Number子类型，抛出异常
        throw new IllegalStateException("无法对 " + num.getClass().getName() + " 类型的数值进行除法运算。");
    }
}

    /**
     * 对泛型Number列表中的每个元素执行除法运算，并返回一个新的列表。
     * 原有列表不会被修改。
     *
     * @param orig    原始的Number列表
     * @param divisor 除数
     * @param <T>     Number的子类型
     * @return 包含除法结果的新列表
     */
    public static <T extends Number> List<T> divide(List<T> orig, int divisor) {
        // 使用Stream API的map操作对每个元素进行转换
        return orig.stream()
                .map(it -> divide(it, divisor)) // 调用上面定义的单元素除法辅助方法
                .collect(Collectors.toList()); // 将结果收集成一个新的List
    }

    public static void main(String[] args) {
        List<Integer> integers = List.of(10, 20, 30);
        List<Integer> dividedIntegers = divide(integers, 2);
        System.out.println("原始整数列表: " + integers); // [10, 20, 30]
        System.out.println("除以2后的整数列表: " + dividedIntegers); // [5, 10, 15]

        List<Double> doubles = List.of(10.5, 21.0, 30.0);
        List<Double> dividedDoubles = divide(doubles, 2);
        System.out.println("原始浮点数列表: " + doubles); // [10.5, 21.0, 30.0]
        System.out.println("除以2后的浮点数列表: " + dividedDoubles); // [5.25, 10.5, 15.0]

        List<Byte> bytes = List.of((byte)10, (byte)20, (byte)30);
        List<Byte> dividedBytes = divide(bytes, 2);
        System.out.println("原始字节列表: " + bytes); // [10, 20, 30]
        System.out.println("除以2后的字节列表: " + dividedBytes); // [5, 10, 15]

        // 尝试不支持的类型（如果辅助方法未处理）
        // List<BigDecimal> bigDecimals = List.of(BigDecimal.TEN);
        // List<BigDecimal> dividedBigDecimals = divide(bigDecimals, 2); // 会抛出IllegalStateException
    }

    /**
     * 对泛型Number列表中的每个元素执行除法运算，并直接修改原有列表。
     *
     * @param orig    待修改的Number列表
     * @param divisor 除数
     * @param <T>     Number的子类型
     */
    public static <T extends Number> void divideInPlace(List<T> orig, int divisor) {
        for (int i = 0; i < orig.size(); i++) {
            // 使用上面定义的单元素除法辅助方法更新列表元素
            orig.set(i, divide(orig.get(i), divisor));
        }
    }

    public static void main(String[] args) {
        List<Integer> integers = new java.util.ArrayList<>(List.of(10, 20, 30));
        System.out.println("原始整数列表 (修改前): " + integers); // [10, 20, 30]
        divideInPlace(integers, 2);
        System.out.println("除以2后的整数列表 (原地修改后): " + integers); // [5, 10, 15]
    }