Java8 stream流式表达式用法

最新推荐文章于 2024-05-06 18:26:10 发布
最新推荐文章于 2024-05-06 18:26:10 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： springboot 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36715887/article/details/120189702
版权

一、stream 介绍（抄录一波）

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

以上的流程转换为 Java 代码为：

List<Integer> transactionsIds = 
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum();

二、案列编写 动手写一遍或者运行一下基本就学会啦

1.创建案例需要使用的实体

public class User {

    private String name;

    private int  salary;

    private String address;

    private int age;

    private String sex;
    private String province;
    private String city;
    private String area;

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


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

/**
     * 判断两个对象是否相同 默认是判断对象的所有属性是否全部相同
     * 重写单独属性equals和hashCode
     * 只要此属性的值相同，则认为两个对象就是相同的
     * @param o
     * @return
     */

  @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }


}

2.foreach/find/match的用法

@SpringBootTest
class StreamApplicationTests {


    List<User> initUserList(){
        List<User> list = new ArrayList<>();
        list.add(new User("xiaoHu", 150000,  24, "man","Henan","Zhengzhou","Erqi"));
        list.add(new User("LetMe", 160000,  27, "man","Zhejiang","Hangzhou","Xihu"));
        list.add(new User("Mlxg", 170000,  26, "man","Shandong","Jinan","Qianfoshan"));
        list.add(new User("xiaoMing", 160000,  25, "man","Jiangsu","Nanjing","Yuhuatai"));
        list.add(new User("Miss", 180000,  18, "women","Henan","Zhoukou","chuanhuiqu"));
        list.add(new User("Uzi", 200000, 23, "man","Shandong","Qingdao","Laoshan"));
        return list;
    }


    List<User> initUserList2(){
        List<User> list = new ArrayList<>();
        list.add(new User("xiaoHu", 150000,  24, "man","Henan","Zhengzhou","Erqi"));
        list.add(new User("Gala", 160000,  27, "man","Zhejiang","Hangzhou","Xihu"));
        list.add(new User("Wei", 170000,  26, "man","Shandong","Jinan","Qianfoshan"));
        list.add(new User("xiaoMing", 160000,  25, "man","Jiangsu","Nanjing","Yuhuatai"));
        list.add(new User("YuShuang", 180000,  18, "women","Henan","Zhoukou","chuanhuiqu"));
        list.add(new User("Cryin", 200000, 23, "man","Shandong","Qingdao","Laoshan"));
        return list;
    }

     @Test //（foreach/find/match）
    void streamForeach() {
        List<User> users = initUserList();
        //队员薪资大于160000的打印出来信息
        users.stream().filter(u->u.getSalary()>160000).forEach(System.out::println);
        //队员薪资大于160000的第一个用户的信息
        Optional<User> first = users.stream().filter(u -> u.getSalary() > 160000).findFirst();
        //队员薪资大于160000的任意一个用户信息
        Optional<User> any = users.stream().filter(u -> u.getSalary() > 160000).findAny();

        System.out.println("薪资大于160000的第一个用户的信息" + first.get());
        System.out.println("薪资大于160000的任意一个用户信息" + any.get());
    }
}

输出结果 

User{name='Mlxg', salary=170000, address='null', age=26, sex='man'}
User{name='Miss', salary=180000, address='null', age=18, sex='women'}
User{name='Uzi', salary=200000, address='null', age=23, sex='man'}
薪资大于160000的第一个用户的信息User{name='Mlxg', salary=170000, address='null', age=26, sex='man'}
薪资大于160000的任意一个用户信息User{name='Mlxg', salary=170000, address='null', age=26, sex='man'}

3.筛选（filter） 并形成新的集合。形成新集合依赖collect

@Test //筛选（filter） 并形成新的集合。形成新集合依赖collect
    void streamFilter(){
        List<User> users = initUserList();
        //队员年龄大于25岁的人的集合
        Collection<User> collect = users.stream().filter(u -> u.getAge() > 25).collect(Collectors.toList());
        System.out.println("队员年龄大于25岁的人的集合:"+collect);
    }

输出：

队员年龄大于25岁的人的集合:[User{name='LetMe', salary=160000, address='null', age=27, sex='man'}, User{name='Mlxg', salary=170000, address='null', age=26, sex='man'}]

4.映射map

 @Test //映射map
    void streamMap(){
        List<User> users = initUserList();
        //队员年龄大于25岁人的姓名的集合
        List<String> collect = users.stream().filter(u -> u.getAge() > 25).map(User::getName).collect(Collectors.toList());
        //将队员所有人名字改成大写
        List<String> collect1 = users.stream().map(User::getName).map(String::toUpperCase).collect(Collectors.toList());
        System.out.println("队员年龄大于25岁人的姓名的集合:"+collect);
        System.out.println("将队员所有人名字改成大写"+collect1);
    }

输出：

队员年龄大于25岁人的姓名的集合:[LetMe, Mlxg]
将队员所有人名字改成大写[XIAOHU, LETME, MLXG, XIAOMING, MISS, UZI]

5.归约(reduce)是把一个流缩减成一个值，能实现对集合求和等

@Test //归约(reduce)是把一个流缩减成一个值，能实现对集合求和等
    void streamReduce(){
        List<User> users = initUserList();
        //队员所有人的薪资之和
        Optional<Integer> reduce = users.stream().map(User::getSalary).reduce(Integer::sum);
        System.out.println("队员所有人的薪资之和"+reduce.get());
        //队员最高薪资
        Optional<Integer> reduce1 = users.stream().map(User::getSalary).reduce(Integer::max);
        System.out.println("队员最高薪资"+reduce1.get());
    }

输出：

队员所有人的薪资之和1020000
队员最高薪资200000

6.collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合

 @Test //collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合
    void streamCollect() throws JsonProcessingException {
        List<User> users = initUserList();
        //队员是河南人的集合
        List<User> heNan = users.stream().filter(u -> u.getProvince().equals("Henan")).collect(Collectors.toList());
        System.out.println("队员是河南人的集合"+heNan);

        //大于25岁的队员
        Map<String, User> collect = users.stream().filter(x -> x.getAge() > 25).collect(Collectors.toMap(User::getName, p -> p));
        String s = new ObjectMapper().writeValueAsString(collect);
        System.out.println("大于21岁的队员"+s);
    }

输出：

队员是河南人的集合[User{name='xiaoHu', salary=150000, address='null', age=24, sex='man'}, User{name='Miss', salary=180000, address='null', age=18, sex='women'}]
大于21岁的队员{"Mlxg":{"name":"Mlxg","salary":170000,"address":null,"age":26,"sex":"man","province":"Shandong","city":"Jinan","area":"Qianfoshan"},"LetMe":{"name":"LetMe","salary":160000,"address":null,"age":27,"sex":"man","province":"Zhejiang","city":"Hangzhou","area":"Xihu"}}

PS：ObjectMapper()对象是实现json的核心 当没有导入json依赖时 可以从这个类

7.统计 

  @Test //统计
    void streamCount(){
        //队员人数
        List<User> users = initUserList();
        long count = users.stream().count();
        System.out.println("队员人数"+count);
        //队员平均工资
        Double collect = users.stream().collect(Collectors.averagingInt(u -> u.getSalary()));
        Double collect1 = users.stream().collect(Collectors.averagingDouble(User::getSalary));
        System.out.println("队员平均工资"+collect+"====队员平均工资"+collect1);
        //队员最大薪资
        Optional<Integer> collect2 = users.stream().map(User::getSalary).collect(Collectors.maxBy(Integer::compare));
        System.out.println("队员最大薪资"+collect2.get());
    }

输出：

队员人数6
队员平均工资170000.0====队员平均工资170000.0
队员最大薪资200000

8.分组

public void streamGroup() throws JsonProcessingException {
        List<User> users = initUserList();
        // 将队员按省份分组
        Map<String, List<User>> collect = users.stream().collect(Collectors.groupingBy(User::getProvince));
        System.out.println(collect);
        // 将队员按省份分组 再按性别分组
        Map<String, Map<String, List<User>>> collect1 = users.stream().collect(Collectors.groupingBy(User::getProvince, Collectors.groupingBy(User::getSex)));
        String s = new ObjectMapper().writeValueAsString(collect1);
        System.out.println(s);
    }

输出：

{Zhejiang=[User{name='LetMe', salary=160000, address='null', age=27, sex='man'}], Henan=[User{name='xiaoHu', salary=150000, address='null', age=24, sex='man'}, User{name='Miss', salary=180000, address='null', age=18, sex='women'}], Jiangsu=[User{name='xiaoMing', salary=160000, address='null', age=25, sex='man'}], Shandong=[User{name='Mlxg', salary=170000, address='null', age=26, sex='man'}, User{name='Uzi', salary=200000, address='null', age=23, sex='man'}]}
{"Zhejiang":{"man":[{"name":"LetMe","salary":160000,"address":null,"age":27,"sex":"man","province":"Zhejiang","city":"Hangzhou","area":"Xihu"}]},"Henan":{"man":[{"name":"xiaoHu","salary":150000,"address":null,"age":24,"sex":"man","province":"Henan","city":"Zhengzhou","area":"Erqi"}],"women":[{"name":"Miss","salary":180000,"address":null,"age":18,"sex":"women","province":"Henan","city":"Zhoukou","area":"chuanhuiqu"}]},"Jiangsu":{"man":[{"name":"xiaoMing","salary":160000,"address":null,"age":25,"sex":"man","province":"Jiangsu","city":"Nanjing","area":"Yuhuatai"}]},"Shandong":{"man":[{"name":"Mlxg","salary":170000,"address":null,"age":26,"sex":"man","province":"Shandong","city":"Jinan","area":"Qianfoshan"},{"name":"Uzi","salary":200000,"address":null,"age":23,"sex":"man","province":"Shandong","city":"Qingdao","area":"Laoshan"}]}}

9.joining

  @Test //joining 将每个队员的名字连接起来
    public void streamJoining(){
        List<User> users = initUserList();
        //将每个队员的名字连接起来
        String collect = users.stream().map(User::getName).collect(Collectors.joining("-"));
        System.out.println("将每个队员的名字连接起来"+collect);
    }

输出：

将每个队员的名字连接起来xiaoHu-LetMe-Mlxg-xiaoMing-Miss-Uzi

10.sort排序

 @Test//sort
    void streamSorted(){
        List<User> users = initUserList();
        //工资由低到高
        List<User> collect = users.stream().sorted(Comparator.comparing(User::getSalary)).collect(Collectors.toList());
        //工资由低到高 工资相等时 再按年龄由低到高
        List<String> collect1 = users.stream().sorted(Comparator.comparing(User::getSalary).reversed().thenComparing(User::getAge)).map(User::getName).collect(Collectors.toList());
        System.out.println("工资由低到高:"+collect);
        System.out.println("工资由低到高 工资相等时 再按年龄由低到高"+collect1);
    }

输出：

工资由低到高:[User{name='xiaoHu', salary=150000, address='null', age=24, sex='man'}, User{name='LetMe', salary=160000, address='null', age=27, sex='man'}, User{name='xiaoMing', salary=160000, address='null', age=25, sex='man'}, User{name='Mlxg', salary=170000, address='null', age=26, sex='man'}, User{name='Miss', salary=180000, address='null', age=18, sex='women'}, User{name='Uzi', salary=200000, address='null', age=23, sex='man'}]
工资由低到高 工资相等时 再按年龄由低到高[Uzi, Miss, Mlxg, xiaoMing, LetMe, xiaoHu]

10.distinct limit skip

   @Test//distinct limit skip
    void streamDistinct(){
        List<User> users = initUserList();
        List<User> users1 = initUserList2();
        //两个队队员的总人数
        List<String> collect = Stream.concat(users.stream(), users1.stream()).distinct().map(User::getName).collect(Collectors.toList());
        System.out.println("两个队队员的总人数"+collect);

        //两个队伍薪资最高的前四名
        List<String> collect1 = Stream.concat(users.stream(), users1.stream()).distinct().collect(Collectors.toList()).stream().sorted(Comparator.comparing(User::getSalary).reversed())
                .limit(4).map(User::getName).collect(Collectors.toList());

        System.out.println("两个队伍薪资最高的前四名"+collect1);

        //跳过两个队伍薪资最高的前四名前两人
        List<String> collect2 = collect1.stream().skip(2).collect(Collectors.toList());
        System.out.println("跳过两个队伍薪资最高的前四名前两人"+collect2);
    }

输出：

两个队队员的总人数[xiaoHu, LetMe, Mlxg, xiaoMing, Miss, Uzi, Gala, Wei, YuShuang, Cryin]
两个队伍薪资最高的前四名[Uzi, Cryin, Miss, YuShuang]
跳过两个队伍薪资最高的前四名前两人[Miss, YuShuang]

Java小许
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
如何在java 8 stream表达式实现if/else逻辑
08-19
主要介绍了如何在java 8 stream表达式实现if/else逻辑,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
stream表达式常用用法
lichao_wan的博客
10-30 2609
1.定义一个对象集合，填充一些数据             List&lt;Student&gt; stuList = new ArrayList&lt;&gt;()；         stuList.add(new Student(1L, "刘一", 20, "男"));         stuList.add(new Student(2L, "钱二", 20, "男"));         
优雅解释stream表达式
qq_41614359的博客
05-14 481
优雅解释stream表达式故事开头Stream（流）总结 故事开头 现实生活中没有完美的人生，正如舞台上没有纯粹的喜剧 首先也可以先了解一下: 传送门 照着样例自己动手敲一遍就会了 Stream（流） 串行stream() − 为集合创建串行流。 串行 一个线程做完所有事情 优点:不存在什么线程安全问题，保证处理的先后顺序。 缺点:速度比较慢。 并行parallelStream() − 为集合创建并行流 并行 多个线程一起做 优点:处理速度快 缺点:线程安全处理不得当会引发灾难。 回到正文 pa
Java的Stream表达式
浅水一角的博客
04-24 666
title:Java的Stream表达式 Java的Stream表达式 一、如何理解Stream Java8新特性 Stream可以理解为管道，管道里的流水就是数据，管道里可以对水进行处理，如过滤，消毒，净化等等操作。最后流出的水才能喝。 所以我理解Stream关注的是对数据的加工计算。对比java集合框架，集合框架关注的是如何存取数据。 一个stream操作主要有3个部分：源头、中间操作、终止操作。 中间操作可以有0个或多个 但不是立马执行的，只有终止操作被调用后中间操作才会一起执行（惰性执.
java Stream流与Lambda表达式
weixin_45703155的博客
04-01 1922
Stream流：
JAVA8新特性Lambda表达式、Stream使用
11-19
需要环境：JDK8 下载下来后 直接导入IDE工具中，运行TestLambda、TestLambda2、TestLambda3、PracticeLambda、TestStream中的main方法就可以看见结果
JAVA8 新特性（四）Stream 表达式
HAN_789的博客
06-05 821
Stream 表达式
Stream流与Lambda表达式（一） 杂谈
weixin_34130269的博客
02-20 170
一、流 转换为数组、集合 package com.java.design.java8.Stream; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; i...
JAVA STREAM常用表达式
weixin_42868663的博客
08-02 184
User类： package com.test.demo.bean; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @Data @AllArgsConstructor @NoArgsConstructor public class User { private int id; private String UserName; private int a
Java8中的Stream流式操作教程之王者归来
08-25
主要给大家介绍了关于Java8中Stream流式操作的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java8中Lambda表达式使用和Stream API详解
08-26
主要给大家介绍了关于Java8中Lambda表达式使用和Stream API的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java8 Stream API 详细使用方法与操作技巧指南
08-19
主要介绍了Java8 Stream API 详细使用方法与操作技巧,总结分析了Java8 Stream API 基本功能、使用方法与操作注意事项,需要的朋友可以参考下
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 【Java8】Lambda表达式 和 Stream API 详解笔记 md文档
链表刷题集
yajunjiao的专栏
04-30 859
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Linux下网络编程-简易Epll服务器和客户端
最新发布
weixin_45256307的博客
05-06 228
Linux下网络编程-简易Epll服务器和客户端
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1386
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
《设计一款蓝牙热敏打印机》
唐顺才的博客
05-06 121
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1191
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
java 8 stream
03-01
Java 8引入了Stream API，它是一种处理集合数据的新方式。Stream API提供了一种流式操作的方式，可以对集合进行过滤、映射、排序、聚合等操作，使得代码更加简洁、易读和高效。 Stream是一个来自数据源的元素队列并支持聚合操作。它可以是集合、数组、I/O channel、产生器等。Stream操作可以顺序执行，也可以并行执行。 Java 8 Stream API的特点包括： 1. 延迟执行：Stream操作通常是延迟执行的，只有在终止操作时才会触发实际的计算。 2. 内部迭代：Stream API使用内部迭代的方式，不需要显式地编写循环，使得代码更加简洁。 3. 函数式编程：Stream API支持函数式编程风格，可以通过Lambda表达式来定义操作。 4. 并行处理：Stream API提供了并行处理的能力，可以充分利用多核处理器的优势，提高处理速度。 使用Stream API可以通过一系列的中间操作和终止操作来对集合进行处理。中间操作包括过滤、映射、排序等操作，终止操作包括聚合、收集、遍历等操作。 下面是一些常用的Stream操作方法： 1. filter(Predicate<T> predicate)：根据指定条件过滤元素。 2. map(Function<T, R> mapper)：将元素进行映射转换。 3. sorted(Comparator<T> comparator)：对元素进行排序。 4. distinct()：去除重复的元素。 5. limit(long maxSize)：限制元素的数量。 6. skip(long n)：跳过指定数量的元素。 7. forEach(Consumer<T> action)：对每个元素执行指定操作。 8. collect(Collector<T, A, R> collector)：将元素收集到集合中。 9. reduce(BinaryOperator<T> accumulator)：对元素进行归约操作。 10. parallel()：启用并行处理。 以上只是Stream API的一部分常用操作，还有更多的操作方法可以根据具体需求使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值