Java中Stream详细使用教程

genggeonly

已于 2022-11-09 16:16:48 修改

阅读量3.7k

点赞数 2

文章标签： java 开发语言 spring boot

于 2022-11-09 14:45:03 首次发布

本文链接：https://blog.csdn.net/genggeonly/article/details/127767804

版权

本文详细介绍了Java8中的Stream流和Lambda表达式的使用，包括遍历、筛选、排序、聚合、分组等多种操作。通过实例展示了如何在实际开发中应用这些功能，如获取集合数量、最大值、最小值、去重、分组等，以及如何进行多条件判断和排序。此外，还涉及了对象属性的映射和排序，为日常开发提供了实用的参考。

摘要由CSDN通过智能技术生成

1、java8中Stream流以及lambda的使用：

stream可以将需要处理的集合元素看做流操作，是结合对象功能的一个增强；

lambda表达式与stream结合使用，可以更好的对集合进行遍历、筛选、排序、聚合、分组；

stream特性：不存储数据，只是对数据的记忆性运算；不会改变原数据源，但是会生成一个新的集合或其他值；

2、应用场景：
2.1、测试类：

    @Data
    public class pre {
        private String name;
        private Integer age;
        private String sex;
    }

2.2、初始化数据：

    public  List<pre> init() {
        List<pre> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            pre pre = new pre();
            if (i < 5) {
                pre.setName("a" + i);
                pre.setAge(i);
                pre.setSex("男");
            } else {
                pre.setName("a" + i);
                pre.setAge(i);
                pre.setSex("女");
            }
            list.add(pre);
        }
        return list;
    }

2.3、遍历输出：

方式一：stream

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    list.stream().forEach(System.out::println);

方式二：forEach

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    list.forEach(System.out::println);

2.4、获取数量：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    long count = list.stream().count();
    System.out.println(count);

2.5、获取最大值：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    Integer max = list.stream().max(Integer::compareTo).get();
    System.out.println(max);

2.6、获取最小值：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    Integer min = list.stream().min(Integer::compareTo).get();
    System.out.println(min);

2.7、任意条件：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    boolean res = list.stream().anyMatch(i -> i > 5);
    System.out.println(res);

2.8、全部条件：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    boolean res = list.stream().allMatch(i -> i % 2 == 0);
    System.out.println(res ? "全部都是偶数" : "不全是偶数");

2.9、条件遍历输出：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    list.stream().filter(i -> i > 5).forEach(System.out::println);

2.10、条件遍历输出第一条数据：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    Integer res = list.stream().filter(i -> i > 5).findFirst().get();
    System.out.println(res);

2.11、条件筛选并放到新的容器中：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    List<Integer> res = list.stream().filter(i -> i > 5).collect(Collectors.toList());
    System.out.println(res);

2.12、去重并输出：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7);
    List<Integer> res = list.stream().distinct().collect(Collectors.toList());
    System.out.println(res);

2.13、返回固定的长度：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7);
    List<Integer> res = list.stream().limit(5).collect(Collectors.toList());
    System.out.println(res);

2.14、去掉指定长度：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7);
    List<Integer> res = list.stream().skip(5).collect(Collectors.toList());
    System.out.println(res);

2.15、计算集合元素之和：

方式一：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7);
    Integer res = list.stream().reduce(0, (a, b) -> a + b);
    System.out.println(res);

方式二：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7);
    Integer res = list.stream().reduce(0, Integer::sum);
    System.out.println(res);

2.16、集合中最大值：(这个以reduce的第一个参数和集合中作对比)：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7);
    Integer res = list.stream().reduce(0, Integer::max);
    System.out.println(res);

2.17、map映射-根据某个对象属性分组（利用2.1的对象来作为实体类，利用2.2初始测试数据）：

    Map<String, List<pre>> res = list.stream().collect(Collectors.groupingBy(pre::getSex));
    System.out.println(res);

2.18、map映射-将对象某个属性取出，并合并（利用2.1的对象来作为实体类，利用2.2初始测试数据）：

    String res = list.stream().map(pre::getName).collect(Collectors.joining("--"));
    System.out.println(res);

2.19、排序：

    List<Integer> list = Arrays.asList(1, 2, 3, 7, 5, 6, 6, 4);
    List<Integer> res = list.stream().sorted().collect(Collectors.toList());
    System.out.println(res);

2.20、指定字段正序排序（利用2.1的对象来作为实体类，利用2.2初始测试数据）：

     List<pre> res=list.stream().sorted(Comparator.comparing(pre::getAge)).collect(Collectors.toList());
     System.out.println(res);

2.21、指定字段倒序排序（利用2.1的对象来作为实体类，利用2.2初始测试数据）：

    List<pre> sortReverseRlt=list.stream().sorted(Comparator.comparing(pre::getAge).reversed()).collect(Collectors.toList());
    System.out.println(res);

2.22、多属性组合排序，指定字段1，指定字段2

2.22.1、初始化数据

    public  List<pre> init() {
        List<pre> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
        pre pre = new pre();
        if (i < 5) {
            pre.setName("a" + i);
            pre.setAge(Integer.valueOf((int) (Math.random() * 100)));
            pre.setSex("男");
        } else {
            pre.setName("a" + i);
            pre.setAge(0);
            pre.setSex("女");
        }
            list.add(pre);
        }
        return list;
    }

2.22.2、先按照age正序排序，再按照name正序排序（利用2.22.1初始化数据）

    List<pre> res=list.stream().sorted(Comparator.comparing(pre::getAge).thenComparing(pre ::getName)).collect(Collectors.toList());
    System.out.println(res);

2.22.3、先按照age倒序排序，再按照name正序排序（利用2.22.1初始化数据）

    List<pre> res=list.stream().sorted(Comparator.comparing(pre::getAge).reversed().thenComparing(pre ::getName)).collect(Collectors.toList());
    System.out.println(res);

2.22.4、先按照age正序排序，再按照name倒序排序（利用2.22.1初始化数据）

    List<pre> res=list.stream().sorted(Comparator.comparing(pre::getAge).thenComparing(pre ::getName).reversed()).collect(Collectors.toList());
    System.out.println(res);