在Java中，编写能够对List
理解泛型算术运算的挑战
当定义一个泛型方法如divide(List
为了解决这个问题，常见的思路是根据运行时类型进行判断和转换。例如，使用instanceof来检查元素是Double还是Integer，然后调用其对应的doubleValue()或intValue()方法。然而，直接将转换后的结果（如doubleValue() / val）赋值回List
解决方案：结合Stream API与类型判断
最推荐的方法是结合Java 8引入的Stream API和私有的辅助方法，该辅助方法专门处理单个Number对象的类型判断和转换。这种方法不仅代码更简洁、可读性更强，而且更符合函数式编程范式，倾向于创建新的集合而非修改原集合，从而避免了副作用。
立即学习“Java免费学习笔记（深入）”；
1. 类型安全的单元素除法辅助方法
首先，我们需要一个私有的泛型辅助方法，它接收一个Number类型的元素和一个除数，并根据Number的具体子类型执行相应的除法运算，然后将结果安全地转换回泛型类型T。
import java.util.List;
import java.util.stream.Collectors;
public class GenericListAlgorithms {
/**
* 对单个Number类型的数值进行除法运算，并返回相同泛型类型的结果。
* 该方法通过instanceof检查来处理不同的数值类型。
*
* @param num 待除的数值
* @param divisor 除数
* @param Number的子类型
* @return 经过除法运算后的结果，类型与输入相同
* @throws IllegalStateException 如果遇到不支持的Number子类型
*/
private static 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() + " 类型的数值进行除法运算。");
}
} 注意事项：
- 类型转换 ((T))： 这是一个不安全的强制类型转换，但在此特定场景下是安全的，因为我们已经通过instanceof确保了实际类型与泛型参数T兼容。例如，如果T是Double，num是Double，那么Double.valueOf(...)的结果就是Double，可以安全地转换为(T)。
- Byte类型： byte类型的除法需要特别注意，因为结果byteValue() / divisor仍然是int类型，需要再次强制转换为(byte)。如果除法结果超出byte的表示范围（-128到127），则会发生溢出。对于更复杂的数值类型，如BigInteger或BigDecimal，需要使用它们各自的divide方法。
2. 基于Stream API的列表转换
有了上述辅助方法，我们可以利用Stream API的map操作来对列表中的每个元素进行转换，并生成一个新的列表。
/**
* 对泛型Number列表中的每个元素执行除法运算，并返回一个新的列表。
* 原有列表不会被修改。
*
* @param orig 原始的Number列表
* @param divisor 除数
* @param Number的子类型
* @return 包含除法结果的新列表
*/
public static List divide(List 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 integers = List.of(10, 20, 30);
List dividedIntegers = divide(integers, 2);
System.out.println("原始整数列表: " + integers); // [10, 20, 30]
System.out.println("除以2后的整数列表: " + dividedIntegers); // [5, 10, 15]
List doubles = List.of(10.5, 21.0, 30.0);
List 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 bytes = List.of((byte)10, (byte)20, (byte)30);
List dividedBytes = divide(bytes, 2);
System.out.println("原始字节列表: " + bytes); // [10, 20, 30]
System.out.println("除以2后的字节列表: " + dividedBytes); // [5, 10, 15]
// 尝试不支持的类型（如果辅助方法未处理）
// List bigDecimals = List.of(BigDecimal.TEN);
// List dividedBigDecimals = divide(bigDecimals, 2); // 会抛出IllegalStateException
} 这种方法是首选，因为它遵循了函数式编程的原则，即不可变性——原始列表不会被修改。
替代方案：原地修改列表
如果确实需要修改原始列表（尽管通常不推荐，因为它会产生副作用），可以使用传统的循环结合辅助方法来实现。
/**
* 对泛型Number列表中的每个元素执行除法运算，并直接修改原有列表。
*
* @param orig 待修改的Number列表
* @param divisor 除数
* @param Number的子类型
*/
public static void divideInPlace(List 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 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]
} 注意事项：
- 可变性： 这种方法直接修改了传入的列表，因此调用者需要清楚这种副作用。
- 列表类型： 传入的列表必须是可变的（例如ArrayList），如果传入List.of()创建的不可变列表，将会抛出UnsupportedOperationException。
总结
在Java中编写泛型算法来处理List
- 利用instanceof进行运行时类型判断： 创建一个私有辅助方法，根据Number的具体子类型执行相应的算术操作。
- 安全地进行类型转换： 在辅助方法中，将算术结果包装回对应的Number子类型（如Double.valueOf()），然后强制转换为泛型类型T。
-
选择合适的列表操作方式：
- 推荐使用Stream API的map操作： 这会生成一个新的列表，保持原始列表的不可变性，代码简洁且符合函数式编程风格。
- 当需要原地修改时，使用循环和list.set()： 这种方式直接修改原始列表，但需要注意其副作用以及列表的可变性要求。
通过上述方法，我们可以在Java中优雅且类型安全地实现对多种数值类型列表的泛型算法，避免了为每种具体类型编写重复代码的困扰。
