脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java8 Stream过滤null值

Java8如何从一个Stream中过滤null值

 更新时间：2022年05月06日 10:40:03   作者：wangmm0218  
这篇文章主要介绍了Java8如何从一个Stream中过滤null值，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

从一个Stream中过滤null值

复习一个Stream 包含 null 数据的例子.

Java8Examples.java

package com.mkyong.java8; 
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class Java8Examples { 
    public static void main(String[] args) { 
        Stream<String> language = Stream.of("java", "python", "node", null, "ruby", null, "php"); 
        List<String> result = language.collect(Collectors.toList()); 
        result.forEach(System.out::println); 
    }
}

output

java
python
node
null   // <--- NULL
ruby
null   // <--- NULL
php

Solution（解决）

为了解决上面的问题，我们使用： Stream.filter(x -> x!=null)

Java8Examples.java

package com.mkyong.java8; 
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class Java8Examples { 
    public static void main(String[] args) { 
        Stream<String> language = Stream.of("java", "python", "node", null, "ruby", null, "php"); 
        //List<String> result = language.collect(Collectors.toList()); 
        List<String> result = language.filter(x -> x!=null).collect(Collectors.toList()); 
        result.forEach(System.out::println);  
    }
}

output

java
python
node
ruby
php

另外，过滤器还可以用： Objects::nonNull

import java.util.List;
List<String> result = language.filter(Objects::nonNull).collect(Collectors.toList());

stream方法过滤条件的使用

@Data 
@AllArgsConstructor    
public class User { 
    private Long id;      // id
    private Integer age;  // 年龄 
    private Byte gentle;  // 性别 
    private String name;  // 名字 
    private Integer rank; // 排名 
}
 
User user0 = new User(1L, 18, (byte) 0, "张三", 1); 
User user1 = new User(2L, 20, (byte) 1, "李四", 4); 
User user2 = new User(3L, 35, (byte) 0, "王五", 2); 
User user3 = new User(4L, 29, (byte) 1, "赵六", 3);

下面以List为例

实际上只要是Collection的子类，玩法都类似

1、生成stream

List<User> list = Arrays.asList(user0, user1, user2, user3);
Stream<User> stream = null;
stream = list.stream(); // 需要预判NPE
stream = Optional.of(list).orElseGet(Collections::emptyList).stream(); // 需要预判NPE
stream = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream();
stream = Optional.ofNullable(list).orElseGet(Collections::emptyList).parallelStream(); // 并行处理流
stream = Stream.of(user0, user1, user2, user3).parallel(); // 直接构造
stream = Stream.of(Arrays.asList(user0, user1), Arrays.asList(user2, user3)).flatMap(Collection::stream); // flatMap合并

2、stream操作

// 过滤出性别为0的user
List<User> userList = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().filter(user -> (byte) 0 == user.getGentle()).collect(Collectors.toList());
 
// 获取排名大于1的用户年龄set
Set<Integer> ageList = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().filter(user -> 1 < user.getRank()).map(User::getAge).collect(Collectors.toSet());
 
// 合计性别为0的user的年龄
Integer totalAge = Optional.ofNullable(userList).orElseGet(Collections::emptyList).stream().map(User::getAge).reduce(0, Integer::sum);
 
// 按排名倒序排列
List<User> sortedUserList = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().sorted(Comparator.comparing(User::getRank, Comparator.reverseOrder())).collect(Collectors.toList());
 
// 获取排名第2高的user
User rankUser = Optional.ofNullable(sortedUserList).orElseGet(Collections::emptyList).stream().skip(1).findFirst().get();
 
// 排名最高的user
User highestRankUser = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().max(Comparator.comparing(User::getRank)).get();
 
// 是否存在排名大于1的user
boolean flag = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().anyMatch(user -> user.getRank() > 1);
 
// 是否所有user排名都大于1
boolean flag = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().allMatch(user -> user.getRank() > 1);
 
// 是否所有user排名都不大于5
boolean flag = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().noneMatch(user -> user.getRank() > 5);
 
// 按唯一id分组
Map<Long, User> idUserMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.toMap(User::getId, Function.identity()));
 
// 按唯一id,名字分组
Map<Long, String> idNameMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.toMap(User::getId, User::getName));
 
// 按年龄,名字分组，相同年龄的后出现的被覆盖
Map<Integer, String> ageNameMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.toMap(User::getAge, User::getName, (a, b) -> a));
 
// 按性别分组
Map<Byte, List<User>> gentleUserMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.groupingBy(User::getGentle));
 
// 按排名是否大于3分组
Map<Boolean, List<User>> partitionUserMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.partitioningBy(user -> user.getRank() > 3));
 
// 按性别名字分组
Map<Byte, List<String>> gentleNameMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.groupingBy(User::getGentle, Collectors.mapping(User::getName, Collectors.toList())));
 
// 按性别年龄总和分组
Map<Byte, Integer> gentleTotalAgeMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.groupingBy(User::getGentle, Collectors.reducing(0, User::getAge, Integer::sum)));
 
// 迭代操作
Stream.iterate(0, i -> i + 1).limit(list.size()).forEach(i -> {
    System.out.println(list.get(i).getName());
});
 
// guava table转换
Table<Long, String, Integer> idNameRankTable = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().map(user -> ImmutableTable.of(user.getId(), user.getName(), user.getRank())).collect(HashBasedTable::create, HashBasedTable::putAll, HashBasedTable::putAll);

// stream只能被terminal一次，下面是错误示范
Stream<User> stream = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream();
stream.collect(Collectors.toMap(User::getId, Function.identity()));
stream.collect(Collectors.toMap(User::getId, User::getName)); // java.lang.IllegalStateException: stream has already been operated upon or closed 
 
// ssc-common的com.meicloud.mcu.common.util.StreamUtil简单封装了一些流操作，欢迎试用 
// 参考资料：https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • Spring中的FactoryBean与BeanFactory详细解析

    Spring中的FactoryBean与BeanFactory详细解析

    这篇文章主要介绍了Spring中的FactoryBean与BeanFactory详细解析,在Spring框架中,FactoryBean和BeanFactory是两个关键的接口,用于创建和管理对象实例,它们在Spring的IoC(Inversion of Control,控制反转)容器中发挥着重要的作用,需要的朋友可以参考下
    2023-11-11
  • SpringBoot集成本地缓存性能之王Caffeine示例详解

    SpringBoot集成本地缓存性能之王Caffeine示例详解

    这篇文章主要为大家介绍了SpringBoot集成本地缓存性能之王Caffeine的示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-07-07
  • Java使用FileReader读取文件详解

    Java使用FileReader读取文件详解

    本文将为大家介绍FileReader类的基本用法,包括如何创建FileReader对象,如何读取文件,以及如何关闭流,感兴趣的小伙伴可以跟随小编一起了解一下
    2023-09-09
  • 实例详解Spring Boot实战之Redis缓存登录验证码

    实例详解Spring Boot实战之Redis缓存登录验证码

    本章简单介绍redis的配置及使用方法，本文示例代码在前面代码的基础上进行修改添加，实现了使用redis进行缓存验证码，以及校验验证码的过程。感兴趣的的朋友一起看看吧
    2017-08-08
  • springboot统一接口返回数据的实现

    springboot统一接口返回数据的实现

    这篇文章主要介绍了springboot统一接口返回数据的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-09-09
  • SpringBoot基于RabbitMQ实现消息延迟队列方案及使用场景

    SpringBoot基于RabbitMQ实现消息延迟队列方案及使用场景

    在很多的业务场景中,延时队列可以实现很多功能,此类业务中,一般上是非实时的,需要延迟处理的,需要进行重试补偿的,这篇文章主要介绍了SpringBoot基于RabbitMQ实现消息延迟队列方案及使用场景,需要的朋友可以参考下
    2024-04-04
  • java并发数据包Exchanger线程间的数据交换器

    java并发数据包Exchanger线程间的数据交换器

    这篇文章主要为大家介绍了java并发数据包使用数据交换器Exchanger来进行线程之间的数据交换。有需要的朋友可以借鉴参考下，希望能够有所帮助
    2022-03-03
  • 如何解决异步线程导致的traceId为空的问题

    如何解决异步线程导致的traceId为空的问题

    文章讨论了在使用异步线程时,traceId为空的问题,并提出了使用线程池的解决方案,作者分享了个人经验,并鼓励大家参考和支持脚本之家
    2025-02-02
  • 详解Java中的Reflection反射和暴力反射

    详解Java中的Reflection反射和暴力反射

    本文主要介绍了详解Java中的Reflection反射和暴力反射，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2023-06-06
  • SpringBoot拦截器实现登录拦截的示例代码

    SpringBoot拦截器实现登录拦截的示例代码

    本文主要介绍了SpringBoot拦截器实现登录拦截，文中根据实例编码详细介绍的十分详尽，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-03-03

最新评论