Java泛型列表算法：安全处理数值类型操作与Stream实践

static <T extends Number> List<T> divide(List<T> list, int val) {
    // 编译错误：bad operand types for binary operator '/'
    // return forEachIndexChange(list, i -> list.get(i) / val);
    // ...
    return null; // 示例，实际代码会报错
}

static <T extends Number> List<T> divide(List<T> list, int val, T type) {
    if (type instanceof Double) {
        // 这里会遇到新的编译错误
        // return forEachIndexChange(list, i -> list.get(i).doubleValue() / val);
    }
    return null;
}

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

public class GenericListAlgorithms {

    /**
     * 对泛型Number列表中的每个元素执行除法操作，并返回一个新的列表。
     *
     * @param orig    原始数值列表。
     * @param divisor 除数。
     * @param <T>     列表元素的类型，必须是Number的子类。
     * @return 包含除法结果的新列表。
     */
    private static <T extends Number> List<T> divide(List<T> orig, int divisor) {
        // 使用Stream API进行转换
        return orig.stream()
                .map(it -> divide(it, divisor)) // 对每个元素调用类型安全的除法辅助方法
                .collect(Collectors.toList()); // 收集结果到新列表中
    }

    /**
     * 类型安全的数值除法辅助方法，根据Number的具体子类型执行除法。
     *
     * @param num     要被除的数值。
     * @param divisor 除数。
     * @param <T>     数值的类型，必须是Number的子类。
     * @return 除法结果，类型与输入数值的类型保持一致。
     * @throws IllegalStateException 如果遇到不支持的Number子类型。
     */
    @SuppressWarnings("unchecked") // 强制类型转换，因为我们已通过instanceof确保类型兼容
    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类型的除法可能导致精度丢失或溢出，需要谨慎处理
            return (T) Byte.valueOf((byte) (num.byteValue() / divisor));
        }
        // 如果遇到未处理的Number子类型，抛出异常
        throw new IllegalStateException("Cannot divide class of " + num.getClass().getName());
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(10, 20, 30, 40);
        List<Integer> dividedIntList = divide(intList, 2);
        System.out.println("Divided Integer List: " + dividedIntList); // Output: [5, 10, 15, 20]

        List<Double> doubleList = List.of(10.5, 20.0, 30.3, 40.8);
        List<Double> dividedDoubleList = divide(doubleList, 2);
        System.out.println("Divided Double List: " + dividedDoubleList); // Output: [5.25, 10.0, 15.15, 20.4]

        List<Number> mixedList = List.of(10, 20.0, 30L, (byte) 40);
        List<Number> dividedMixedList = divide(mixedList, 2);
        System.out.println("Divided Mixed List: " + dividedMixedList); // Output: [5, 10.0, 15, 20]
    }
}

import java.util.List;

public class GenericListAlgorithmsInPlace {

    /**
     * 对泛型Number列表中的每个元素执行除法操作，并原地修改原始列表。
     *
     * @param orig    原始数值列表，将被修改。
     * @param divisor 除数。
     * @param <T>     列表元素的类型，必须是Number的子类。
     */
    @SuppressWarnings("unchecked") // 强制类型转换，与divide辅助方法中的原因相同
    private 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));
        }
    }

    /**
     * 类型安全的数值除法辅助方法，与上面Stream版本中的相同。
     */
    @SuppressWarnings("unchecked")
    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) {
            return (T) Byte.valueOf((byte) (num.byteValue() / divisor));
        }
        throw new IllegalStateException("Cannot divide class of " + num.getClass().getName());
    }

    public static void main(String[] args) {
        List<Integer> intList = new java.util.ArrayList<>(List.of(10, 20, 30, 40));
        System.out.println("Original Integer List: " + intList); // Output: [10, 20, 30, 40]
        divideInPlace(intList, 2);
        System.out.println("Divided (in-place) Integer List: " + intList); // Output: [5, 10, 15, 20]

        List<Double> doubleList = new java.util.ArrayList<>(List.of(10.5, 20.0, 30.3, 40.8));
        System.out.println("Original Double List: " + doubleList); // Output: [10.5, 20.0, 30.3, 40.8]
        divideInPlace(doubleList, 2);
        System.out.println("Divided (in-place) Double List: " + doubleList); // Output: [5.25, 10.0, 15.15, 20.4]
    }
}