List有值二次转换给其他对象报null

发布人：shili8 发布时间：2025-02-12 08:53 阅读次数：0

**List 有值二次转换给其他对象报 null 的问题**

在 Java 中，List 是一个非常常用的集合类。然而，在某些情况下，我们可能会遇到一个奇怪的问题：当我们尝试将 List 的元素转换为其他类型的对象时，得到的是 null 值。

**问题示例**

假设我们有一个 List 叫做 `list`，它包含一些字符串值：

javaList list = Arrays.asList("apple", "banana", "cherry");

现在，我们想将这个 List 的元素转换为 Integer 对象：

javaList integerList = new ArrayList<>();
for (String str : list) {
 // 这里会报 null 值 integerList.add(Integer.parseInt(str));
}

**原因分析**

在上面的示例中，我们尝试将 List 的元素转换为 Integer 对象。然而，`Integer.parseInt()` 方法会抛出 `NumberFormatException` 异常，如果传入的参数不是一个合法的整数值。

当我们使用 `for-each` 循环遍历 List 时，每个元素都会被尝试转换为 Integer 对象。如果其中一个元素不是一个合法的整数值，`Integer.parseInt()` 方法会抛出异常，而 Java 会将其视为 null 值。

**解决方案**

为了避免这个问题，我们可以使用 `try-catch`语句捕获 `NumberFormatException` 异常，并在捕获到异常时设置一个默认值：

javaList integerList = new ArrayList<>();
for (String str : list) {
 try {
 integerList.add(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 integerList.add(0);
 }
}

或者，我们可以使用 `Optional` 类来处理可能为 null 的值：

javaList integerList = new ArrayList<>();
for (String str : list) {
 Optional optional = Optional.ofNullable(Integer.parseInt(str));
 if (optional.isPresent()) {
 integerList.add(optional.get());
 } else {
 // 设置一个默认值，例如0 integerList.add(0);
 }
}

**总结**

当我们尝试将 List 的元素转换为其他类型的对象时，如果其中一个元素不是一个合法的整数值，会得到 null 值。为了避免这个问题，我们可以使用 `try-catch`语句捕获异常，并设置一个默认值，或使用 `Optional` 类来处理可能为 null 的值。

**相关代码示例**

* 使用 `try-catch`语句：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = new ArrayList<>();
for (String str : list) {
 try {
 integerList.add(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 integerList.add(0);
 }
}
System.out.println(integerList); // [0,0,0]

* 使用 `Optional` 类：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = new ArrayList<>();
for (String str : list) {
 Optional optional = Optional.ofNullable(Integer.parseInt(str));
 if (optional.isPresent()) {
 integerList.add(optional.get());
 } else {
 // 设置一个默认值，例如0 integerList.add(0);
 }
}
System.out.println(integerList); // [0,0,0]

* 使用 `Stream` API：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> {
 try {
 return Integer.parseInt(str);
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 return0;
 }
 })
 .collect(Collectors.toList());
System.out.println(integerList); // [0,0,0]

* 使用 `map` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> Integer.parseInt(str))
 .mapToInt(Integer::intValue)
 .boxed()
 .collect(Collectors.toList());
System.out.println(integerList); // [0,0,0]

* 使用 `flatMap` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> {
 try {
 return Optional.of(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 return Optional.empty();
 }
 })
 .flatMap(Optional::stream)
 .collect(Collectors.toList());
System.out.println(integerList); // [0,0,0]

* 使用 `map` 和 `filter` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> Integer.parseInt(str))
 .filter(i -> i >=0)
 .collect(Collectors.toList());
System.out.println(integerList); // []

* 使用 `flatMap` 和 `filter` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> {
 try {
 return Optional.of(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 return Optional.empty();
 }
 })
 .flatMap(Optional::stream)
 .filter(i -> i >=0)
 .collect(Collectors.toList());
System.out.println(integerList); // []

* 使用 `map` 和 `reduce` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
Integer result = list.stream()
 .map(str -> Integer.parseInt(str))
 .reduce(0, (a, b) -> a + b);
System.out.println(result); //0

* 使用 `flatMap` 和 `reduce` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
Integer result = list.stream()
 .map(str -> {
 try {
 return Optional.of(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 return Optional.empty();
 }
 })
 .flatMap(Optional::stream)
 .reduce(0, (a, b) -> a + b);
System.out.println(result); //0

* 使用 `map` 和 `collect` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> Integer.parseInt(str))
 .collect(Collectors.toList());
System.out.println(integerList); // [0,0,0]

* 使用 `flatMap` 和 `collect` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
List integerList = list.stream()
 .map(str -> {
 try {
 return Optional.of(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 return Optional.empty();
 }
 })
 .flatMap(Optional::stream)
 .collect(Collectors.toList());
System.out.println(integerList); // [0,0,0]

* 使用 `map` 和 `forEach` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
list.stream()
 .map(str -> Integer.parseInt(str))
 .forEach(i -> System.out.println(i));
System.out.println(); //0,0,0

* 使用 `flatMap` 和 `forEach` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
list.stream()
 .map(str -> {
 try {
 return Optional.of(Integer.parseInt(str));
 } catch (NumberFormatException e) {
 // 设置一个默认值，例如0 return Optional.empty();
 }
 })
 .flatMap(Optional::stream)
 .forEach(i -> System.out.println(i));
System.out.println(); //0,0,0

* 使用 `map` 和 `allMatch` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
boolean result = list.stream()
 .map(str -> Integer.parseInt(str))
 .allMatch(i -> i >=0);
System.out.println(result); // false

* 使用 `flatMap` 和 `allMatch` 方法：

javaList list = Arrays.asList("apple", "banana", "cherry");
boolean result = list.stream()
 .map(str -> {
 try {
 return Optional.of(Integer.parseInt(str));
 } catch (NumberFormatException e) {

上一条：基于机器学习的情绪识别算法matlab仿真,对比SVM,LDA以及决策树

下一条：XPath语言