java8Stream

已于 2022-07-28 21:03:37 修改
阅读量943 收藏
点赞数
分类专栏： 【Java】 文章标签： java 开发语言
于 2022-07-28 21:02:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32015565/article/details/126043891
版权

文章目录


记录下java的一些Stream用法。。。

Stream

用来测试的类 Employee

public class Employee {
    private String name;  // 姓名
    private int salary; // 薪资
    private int age; // 年龄
    private String sex; //性别
    private String area;  // 地区
    private Status status;

    public Employee() {
    }

    public Employee(String name, int salary, int age, String sex, String area) {
        this.name = name;
        this.salary = salary;
        this.age = age;
        this.sex = sex;
        this.area = area;
    }

    public Employee(String name, int salary, int age, String sex, String area, Status status) {
        this.name = name;
        this.salary = salary;
        this.age = age;
        this.sex = sex;
        this.area = area;
        this.status = status;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return salary == employee.salary &&
                age == employee.age &&
                Objects.equals(name, employee.name) &&
                Objects.equals(sex, employee.sex) &&
                Objects.equals(area, employee.area);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, salary, age, sex, area);
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", area='" + area + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getArea() {
        return area;
    }

    public void setArea(String area) {
        this.area = area;
    }

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }

    public enum  Status{
        FREE,BUSY,VOCATION
    }
}

初始化测试对象

List<Employee> emps = Arrays.asList(
     new Employee("张三", 10000, 25, "男", "海南", Employee.Status.FREE),
     new Employee("李四", 20000, 26, "女", "浙江", Employee.Status.BUSY),
     new Employee("王五", 15000, 28, "男", "海南", Employee.Status.VOCATION),
     new Employee("赵六", 15600, 28, "男", "海南", Employee.Status.FREE),
     new Employee("赵六", 20000, 51, "女", "广东", Employee.Status.VOCATION));"));

中间操作

filter
/**  
 * filter()   接收lambda，从流中排除某些元素，获取条件符合的元素  
 */  
@Test  
public void test1() {  
   Stream<Employee> stream = list.stream().filter((e) -> e.getAge() > 25);    
   stream.forEach(System.out::println);  
}

结果：
Employee{name='李四', salary=20000, age=26, sex='女', area='浙江'}
Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}
Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}
Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}
limit
/**
 * limit()  截断流，使其不超过指定量
 */
@Test
public void test2() {
    Stream<Employee> stream = emps.stream().limit(1);
    stream.forEach(System.out::println);
}

结果：
Employee{name='张三', salary=10000, age=25, sex='男', area='海南'}
skip
/**
 * skip()   跳过指定的个数，返回后续的流，与limit互补
 */
@Test
public void test3() {
    Stream<Employee> stream = emps.stream().skip(2);
    stream.forEach(System.out::println);
}

结果：
Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}
Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}
Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}
distinct
/**
 * distinct()
 * 通过流所生成的元素的hashcode和equals去除重复元素，需要流对应的对象重写hashcode和equals
 */
@Test
public void test4() {
    emps.stream().distinct().forEach(System.out::println);
}
map
/**
     * map()
     * 接收lambda，将元素转换成其他元素或提取信息。
     * 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新元素
     * 类似：add
     */
    @Test
    public void test5() {
        List<String> strs = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
        strs.stream().map((str) -> str.toUpperCase()).forEach(System.out::println);

        System.out.println("------------------------");

        emps.stream().map((e) -> e.getName()).forEach(System.out::println);
        emps.stream().map(Employee::getName).forEach(System.out::println);

        System.out.println("------------------------");

        // map中处理的是aaa，bbb，ccc每次传入的，然后返回一个流，于是就返回了多个流，放入一个流中
        Stream<Stream<Character>> stream = strs.stream().map(TestStreamApi::filterCharacter);
        stream.forEach((s) -> s.forEach(System.out::println));

    }

    public static Stream<Character> filterCharacter(String str) {
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
flatMap
/**
 * flatMap
 * 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
 * 类似：addAll
 */
@Test
public void test6() {
    List<String> strs = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
    Stream<Character> stream = strs.stream().flatMap(TestStreamApi::filterCharacter);
    stream.forEach(System.out::println);
}

结果：
a
a
a
b
b
b
c
c
c
d
d
d
e
e
e
sort
/**
 * 排序
 * sort()——自然排序(Comparable)
 * sort(Comparator com)——定制排序(Comparator)
 */
@Test
public void test7() {
    List<String> strs = Arrays.asList("ccc", "eee", "aaa", "ddd", "bbb");
    strs.stream().sorted().forEach(System.out::println);

    System.out.println("-------------------");
    Stream<Employee> stream = emps.stream().sorted((e1, e2) -> {
        if (e1.getAge() == e2.getAge()) {
            return e1.getName().compareTo(e2.getName());
        } else {
            return e1.getAge();
        }
    });
    stream.forEach(System.out::println);
}

结果：
aaa
bbb
ccc
ddd
eee
-------------------
Employee{name='张三', salary=10000, age=25, sex='男', area='海南'}
Employee{name='李四', salary=20000, age=26, sex='女', area='浙江'}
Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}
Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}
Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}

终止操作

allMatch
/**
 * allMatch   检查是否匹配所有元素
 * 需要所有元素有，就返回true
 */
@Test
public void test() {
    boolean b = emps.stream().allMatch(employee -> employee.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b);
}

结果：
false
anyMatch
/**
 * anyMatch     检查是否匹配任意一个元素
 * 其中之一有，就返回true
 */
@Test
public void test2() {
    boolean b = emps.stream().anyMatch(e -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println("b = " + b);
}

结果：
b=true
noneMatch
/**
     * noneMatch    检查所有元素，没有一个元素匹配
     */
    @Test
    public void test3() {
        boolean b = emps.stream().noneMatch(e -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println("b = " + b);

    }

结果：
b = false
findFirst 和 findAny
/**
     * findFirst    返回当前流的第一个元素
     * findAny      返回当前流的任意一个元素
     */
    @Test
    public void test4() {
        Optional<Employee> op = emps.stream()
                .sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary()))
                .findFirst();
        System.out.println("employee = " + op.get());

        System.out.println("-----------------");
        Optional<Employee> op1 = emps.parallelStream().filter(e -> e.getStatus().equals(Employee.Status.FREE)).findAny();
        System.out.println("employee1 = " + op1.get());
    }

结果：
employee = Employee{name='002', salary=20000, age=26, sex='女', area='浙江'}
-----------------
employee1 = Employee{name='003', salary=15600, age=28, sex='男', area='海南'}
count、max和min
/**
     * count    返回当前流的元素个数
     * max      返回当前流的最大值
     * min      返回当前流的最小值
     */
    @Test
    public void test5() {
        long count = emps.stream().count();
        System.out.println("count = " + count);

        Optional<Employee> op = emps.stream().max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println("op = " + op.get());

        Optional<Employee> op1 = emps.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println("op1 = " + op1.get());
    }

结果：
count = 4
op = Employee{name='004', salary=15000, age=28, sex='男', area='海南'}
op1 = Employee{name='001', salary=10000, age=25, sex='男', area='海南'}
reduce
/**
     * 规约  reduce，可以将流中元素反复结合起来，得到一个新值
     */
    @Test
    public void test() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 将参数1 identity作为x，将list中的元素作为y，执行x+y，在将结果作为x，list中的下一个元素作为y反复执行
        Integer sum = list.stream().reduce(1, (x, y) -> x + y);
        System.out.println("sum = " + sum);

        System.out.println("-------------------");
        Integer sum2 = emps.stream().map(Employee::getSalary).reduce(0, (x, y) -> x + y);
        System.out.println("sum2 = " + sum2);

        Optional<Integer> op = emps.stream().map(Employee::getSalary).reduce(Integer::sum);
        System.out.println("op.get() = " + op.get());
    }

结果：
sum = 56
-------------------
sum2 = 80600
op.get() = 80600
collect
/**
     * 搜集  collect，将流转换为其他形式。接收一个Collectors接口的实现，用于给Stream中元素做汇总方法
     */
    @Test
    public void test2() {
        List<String> list = emps.stream().map(Employee::getName).collect(Collectors.toList());
        for (String s : list) {
            System.out.println(s);
        }

        System.out.println("---------------------------------");
        Set<String> set = emps.stream().map(Employee::getName).collect(Collectors.toSet());
        set.forEach(System.out::println);

        System.out.println("--------------总数-------------------");
        Long count = emps.stream().collect(Collectors.counting());
        System.out.println("count = " + count);

        System.out.println("--------------平均数-------------------");
        Double average = emps.stream().collect(Collectors.averagingInt(Employee::getAge));
        System.out.println("average = " + average);
    }

结果：
张三
李四
王五
赵六
赵六
---------------------------------
李四
张三
王五
赵六
--------------总数-------------------
count = 5
--------------平均数-------------------
average = 31.6

// 分组
    @Test
    public void test3() {
        Map<Employee.Status, List<Employee>> map = emps.stream().collect(Collectors.groupingBy(e -> e.getStatus()));
        Map<Employee.Status, List<Employee>> map1 = emps.stream().collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println("map = " + map);
        System.out.println("map1 = " + map1);
    }

结果：
map = {FREE=[Employee{name='张三', salary=10000, age=25, sex='男', area='海南'}, Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}], VOCATION=[Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}, Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}], BUSY=[Employee{name='李四', salary=20000, age=26, sex='女', area='浙江'}]}
map1 = {FREE=[Employee{name='张三', salary=10000, age=25, sex='男', area='海南'}, Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}], VOCATION=[Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}, Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}], BUSY=[Employee{name='李四', salary=20000, age=26, sex='女', area='浙江'}]}

// 多级分组
    @Test
    public void test4() {
        Map<Employee.Status, Map<String, List<Employee>>> map = emps.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
                    if (e.getAge() <= 35) {
                        return "青年";
                    } else if (e.getAge() <= 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                }
        )));
        System.out.println("map = " + map);
    }

结果：
map = {VOCATION={青年=[Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}], 老年=[Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}]}, BUSY={青年=[Employee{name='李四', salary=20000, age=26, sex='女', area='浙江'}]}, FREE={青年=[Employee{name='张三', salary=10000, age=25, sex='男', area='海南'}, Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}]}}

// 分片
    @Test
    public void test5() {
        Map<Boolean, List<Employee>> map = emps.stream().collect(Collectors.partitioningBy(e -> e.getSalary() > 20000));
        System.out.println("map = " + map);
    }

结果：
map = {false=[Employee{name='张三', salary=10000, age=25, sex='男', area='海南'}, Employee{name='李四', salary=20000, age=26, sex='女', area='浙江'}, Employee{name='王五', salary=15000, age=28, sex='男', area='海南'}, Employee{name='赵六', salary=15600, age=28, sex='男', area='海南'}, Employee{name='赵六', salary=20000, age=51, sex='女', area='广东'}], true=[]}

// 连接
    @Test
    public void test6() {
        String s = emps.stream()
                .map(Employee::getName).collect(Collectors.joining(","));
        System.out.println("s = " + s);
    }

结果：
s = 张三,李四,王五,赵六,赵六

关于stream使用暂时记录到这，后续遇到的也记录进来

可以看看我的学习——基于Hexo的个人博客：
网站：http://www.fuzm.wang
—————————————————————————
作为初学者，很多知识都没有掌握，见谅，如有错误请指出，以期进步，感谢！。后续有新的学习，继续补充上来。

liwangC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 Stream学习
01-05
Java8 Stream教程，简单易懂
Stream流分组
啥也没有
03-24 3万+
java Stream流分组案例
带sex的net域名_sex.com(性)域名争夺再升级 色情能抵千万美金？
weixin_36178216的博客
12-24 8万+
加利福尼亚最高法院将对sex.com域名的所有权进行最终的听证。美国圣弗朗西斯科市第9巡回法庭请求加州最高法院对此事加以干预，对此域名可能引发的高达100万美元的损失赔偿进行裁决。关于sex.com的域名之争已经持续了六年之久，其中涉及各方包括sex.com的创建者和CEO加利-克莱曼、VeriSign和NSI公司、以及前司法部门官员史蒂夫-米遏尔-科恩等。如果加 州法院的裁决对克莱曼有利的话，V...
JAVA8 新特性 - stream流各种用法（遍历、最大、最小、平均值、分组、求和、过滤、排序）
AKANGYONG的博客
02-14 672
【代码】JAVA8 新特性 - stream流各种用法（遍历、最大、最小、平均值、分组、求和、过滤、排序）
Stream最详细的使用介绍
木小四的博客
10-23 1778
Java8中Stream的使用
java 集合操作_java8-Stream集合操作快速上手
weixin_30564897的博客
02-15 234
目录Stream简介为什么要使用Stream实例数据源FilterMapFlatMapReduceCollectOptional并发调试Stream简介Java 8引入了全新的Stream API。这里的Stream和I/O流不同，它更像具有Iterable的集合类，但行为和集合类又有所不同。stream是对集合对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作...
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
主要介绍了Java 8 Stream Collectors 功能与操作方法,结合实例形式详细分析了Java 8 Stream Collectors 功能、操作方法及相关注意事项,需要的朋友可以参考下
Java8 Stream 各种实例
09-05
看完不会你骂我 想要代码简洁美观 高大上
Java8 Stream flatmap中间操作用法解析
08-18
主要介绍了Java8 Stream flatmap中间操作用法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java8 streamList转换使用详解
08-18
主要介绍了java8 streamList转换使用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
四个福利性在线网站分享，每一个都让你欲罢不能……
热门推荐
weixin_43363835的博客
02-03 317万+
随着社会的不断发展，我们网络上的一些资源就像雨后春笋一般的拔地而起，许多东西我们的来不及上车就被新的事物给掩盖了，但是对于一些好用的网站来说是真的很不错，小编今天就和你们分享一些最具福利性的在线网站！ 你们准备好了吗？老司机准备发车了： 一.TinEye.com—图片搜索引擎 如果你的电脑或者你的手机里有一张不知道哪里来的图片，你想要将图片的源地址给找出来该怎么做？一般的时候我们都是束手无策，但是有了这个网站就不一样，可以图片上传带上去进行查找...
js如何将字符串‘https://www.qq.com/s?name=laoxie&age=18&sex=male&‘转成对象?
qq_44472790的博客
02-11 4544
将字符串'https://www.qq.com/s?name=laoxie&amp;age=18&amp;sex=male&amp;'转成对象{name:'laoxie',age:18,sex:male}输出； var str = 'https://www.qq.com/s?name=laoxie&amp;age=18&amp;sex=male&amp;'; var arr =str.split...
【sex.com最贵的域名】
KYNG
06-06 5万+
世界最贵的20个域名：sex.com 居首 国外域名专业资讯网站DN Journal 今天列举出了全球最贵的20大域名，其中，sex.com以1300万美元位居第一，同样可以看到的是，和成人有关的porn.com位列第三。 　　具体榜单如下： 　　1、Sex.com 1300万美元 交易年份：2010年 　　2、Fund.com 1000万美元 交易年份：2008年 　　3、Porn.c...
观看 B站视频-Mysql-随堂笔记
weixin_44121529的博客
03-29 1788
Mysql学习
java8新特性stream接口（3）
weixin_30607029的博客
06-19 314
package com.test.lambda; public class Person { 　　enum Sex{ 　　　　MALE,FEMALE 　　} 　　private String name; 　　private Sex sex; 　　private int age; 　　public String getName() { 　　　　return name; 　　} 　　pu...
java中stream用法,Java8中Stream 的一些用法
weixin_28829173的博客
03-21 215
数据结构和数据准备@Data@AllArgsConstructor@NoArgsConstructorstatic class StreamItem {Integer id;String name;Boolean sex;}List list = Lists.newArrayList(new StreamItem(1, "a", true), new StreamItem(2, "b", fals...
Linux命令
weixin_44265425的博客
06-14 21万+
Linux 学习笔记 LINUX常用操作命令和命令行编辑快捷键 终端快捷键: Ctrl + a/Home 切换到命令行开始 Ctrl + e/End 切换到命令行末尾 Ctrl + l 清除屏幕内容，效果等同于 clear Ctrl + u 清除剪切光标之前的内容 Ctrl + k 剪切清除光标之后的内容 Ctrl + y 粘贴刚才所删除的字符 Ctrl + r 在历史命令中查找 (这个非常好用，输入关键字就调出以前的命令了) Ctrl + c 终止命令 ctrl + o 重复执行命令 Ctrl + d 退
Java流（Stream）操作实例-筛选、映射、查找匹配
Ron.Zheng
11-24 7万+
Java流（Stream）操作实例-筛选、映射、查找匹配
英语词根词缀记忆大全
J2EE JS 后台 前端 出国 英语
02-27 20万+
转的别人的，以备经常查看 http://www.douban.com/note/65124458/ 英语词根词缀记忆大全 第一部分 通过词缀认识单词 （常用前缀一） 1、a- ① 加在单词或词根前面，表示"不，无，非" acentric 无中心的（a+centric中心的） asocial 不好社交的（a+social好社交的） amoral 非道德性的（a+mo
java 8 stream
最新发布
03-01
Java 8引入了Stream API，它是一种处理集合数据的新方式。Stream API提供了一种流式操作的方式，可以对集合进行过滤、映射、排序、聚合等操作，使得代码更加简洁、易读和高效。 Stream是一个来自数据源的元素队列并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值