Java8关于list.stream()的一些简单用法

最新推荐文章于 2024-03-26 16:00:14 发布
最新推荐文章于 2024-03-26 16:00:14 发布
阅读量1.3w 收藏 18
点赞数 1
分类专栏： Java 文章标签： stream java8 lambda list filter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/delongcpp/article/details/106641269
版权

一些简单用法记录一下。

文中使用几个第三方jar包如下：

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.10</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>


    </dependencies>

测试所需实体类：

package com.gerrard.stream;

import lombok.Data;

/**
 * 测试bean.
 */
@Data
public class StreamBean {

    private String name;

    private String sex;

    private  int age;
}

测试代码：

package com.gerrard.stream;

import org.apache.commons.collections4.CollectionUtils;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by Gerrard on 2020/06/09.
 *
 * Stream简单用法测试.
 */
public class StreamTest {

    public static void main(String[] args) {

        StreamTest streamTest = new StreamTest();

        // 初始化测试数据.
        List<StreamBean> streamBeanList = streamTest.initList();

        System.out.println("初始化List如下：");
        // 控制台循环打印初始化数据.
        streamBeanList.forEach(item -> System.out.println(item.getName() + "|" + item.getSex() + "|" + item.getAge()));

        System.out.println("\nFilter测试（查询list性别为女的所有数据）：");
        streamTest.testFilter(streamBeanList, "女");

        System.out.println("\nSorted测试：");
        streamTest.testSorted(streamBeanList);

        System.out.println("\nMap测试：");
        streamTest.testMap(streamBeanList);

        System.out.println("\nCollectors测试：");
        streamTest.testCollectors(streamBeanList);

        System.out.println("\nStatistics测试：");
        streamTest.testStatistics(streamBeanList);
    }

    /**
     * Statistics测试.
     *
     * @param streamBeanList
     */
    public void testStatistics(List<StreamBean> streamBeanList) {

        IntSummaryStatistics intSummaryStatistics = streamBeanList.stream().mapToInt(x -> x.getAge()).summaryStatistics();

        System.out.println("年龄最大的是：" + intSummaryStatistics.getMax());
        System.out.println("年龄最小的是：" + intSummaryStatistics.getMin());
        System.out.println("年龄总和是：" + intSummaryStatistics.getSum());
        System.out.println("平均年龄是：" + intSummaryStatistics.getAverage());
        System.out.println("人数总和是：" + intSummaryStatistics.getCount());


    }

    /**
     * Collectors过滤抽取合并字符串测试.
     *
     * @param streamBeanList
     */
    public void testCollectors(List<StreamBean> streamBeanList) {

        if (CollectionUtils.isNotEmpty(streamBeanList)) {

            // 所有男性的姓名合并字符串用逗号分隔.
            String collect = streamBeanList.stream().filter(item -> item.getSex().equals("男")).map(item -> item.getName()).collect(Collectors.joining(", "));

            System.out.println(collect);
        }

    }

    public void testMap(List<StreamBean> streamBeanList) {

        // 通过map抽取bean列表的所有姓名

        if (CollectionUtils.isNotEmpty(streamBeanList)) {

            System.out.println("抽取列表实体所有姓名：");

            List<String> collect = streamBeanList.stream().map(item -> item.getName()).collect(Collectors.toList());

            collect.stream().forEach(item -> System.out.println(item));

            System.out.println("将列表所有姓名添加前缀A_：");

            List<StreamBean> collect1 = streamBeanList.stream().map(item -> {
                item.setName("A_" + item.getName());
                return item;
            }).sorted(Comparator.comparing(StreamBean::getSex)).collect(Collectors.toList());

            collect1.stream().forEach(item -> System.out.println(item.getName() + " | " + item.getSex()));

        }


    }

    /**
     * 测试排序.
     *
     * @param streamBeanList
     */
    public void testSorted(List<StreamBean> streamBeanList) {

        if (CollectionUtils.isNotEmpty(streamBeanList)) {

            System.out.println("按性别排序");

            List<StreamBean> result = streamBeanList.stream().sorted(Comparator.comparing(StreamBean::getSex)).collect(Collectors.toList());

            result.stream().forEach(item -> System.out.println(item.getName() + " | " + item.getSex() + " | " + item.getAge()));

            System.out.println("按性别排序2");

            List<StreamBean> result2 = streamBeanList.stream().sorted(Comparator.comparing(StreamBean::getSex).reversed()).collect(Collectors.toList());

            result2.stream().forEach(item -> System.out.println(item.getName() + " | " + item.getSex() + " | " + item.getAge()));

            System.out.println("按年龄排序1");

            List<StreamBean> result3 = streamBeanList.stream().sorted(Comparator.comparing(StreamBean::getAge)).collect(Collectors.toList());

            result3.stream().forEach(item -> System.out.println(item.getName() + " | " + item.getSex() + " | " + item.getAge()));

            System.out.println("按年龄排序2");

            List<StreamBean> result4 = streamBeanList.stream().sorted(Comparator.comparing(StreamBean::getAge).reversed()).collect(Collectors.toList());

            result4.stream().forEach(item -> System.out.println(item.getName() + " | " + item.getSex() + " | " + item.getAge()));

        }

    }

    /**
     * Filter测试.
     *
     * @param sex 根据性别筛选.
     */
    public void testFilter(List<StreamBean> streamBeanList, String sex) {

        if (CollectionUtils.isNotEmpty(streamBeanList)) {

            List<StreamBean> result = streamBeanList.stream().filter(item -> item.getSex().equals(sex)).collect(Collectors.toList());

            result.stream().forEach(item -> System.out.println(item.getName() + " | " + item.getSex()));

        }

    }

    /**
     * 初始化数据.
     *
     * @return List<StreamBean>.
     */
    public List<StreamBean> initList() {

        List<StreamBean> streamBeanList = new ArrayList<StreamBean>();

        StreamBean bean1 = new StreamBean();
        bean1.setName("刘某");
        bean1.setSex("男");
        bean1.setAge(66);

        StreamBean bean2 = new StreamBean();
        bean2.setName("张某");
        bean2.setSex("女");
        bean2.setAge(55);

        StreamBean bean3 = new StreamBean();
        bean3.setName("王某");
        bean3.setSex("男");
        bean3.setAge(58);

        StreamBean bean4 = new StreamBean();
        bean4.setName("梁某");
        bean4.setSex("女");
        bean4.setAge(44);

        StreamBean bean5 = new StreamBean();
        bean5.setName("周某");
        bean5.setSex("男");
        bean5.setAge(43);

        CollectionUtils.addAll(streamBeanList, bean1, bean2, bean3, bean4, bean5);

        return streamBeanList;
    }
}

输出结果：

初始化List如下：
刘某|男|66
张某|女|55
王某|男|58
梁某|女|44
周某|男|43

Filter测试（查询list性别为女的所有数据）：
张某 | 女
梁某 | 女

Sorted测试：
按性别排序
张某 | 女 | 55
梁某 | 女 | 44
刘某 | 男 | 66
王某 | 男 | 58
周某 | 男 | 43
按性别排序2
刘某 | 男 | 66
王某 | 男 | 58
周某 | 男 | 43
张某 | 女 | 55
梁某 | 女 | 44
按年龄排序1
周某 | 男 | 43
梁某 | 女 | 44
张某 | 女 | 55
王某 | 男 | 58
刘某 | 男 | 66
按年龄排序2
刘某 | 男 | 66
王某 | 男 | 58
张某 | 女 | 55
梁某 | 女 | 44
周某 | 男 | 43

Map测试：
抽取列表实体所有姓名：
刘某
张某
王某
梁某
周某
将列表所有姓名添加前缀A_：
A_张某 | 女
A_梁某 | 女
A_刘某 | 男
A_王某 | 男
A_周某 | 男

Collectors测试：
A_刘某, A_王某, A_周某

Statistics测试：
年龄最大的是：66
年龄最小的是：43
年龄总和是：266
平均年龄是：53.2
人数总和是：5

 

完事，没有啥深度，就简简单单的记录一下。

杰拉拉德
关注
  • 1
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA8 stream中三个参数的reduce方法对List进行分组统计操作
09-07
主要介绍了JAVA8 stream中三个参数的reduce方法对List进行分组统计操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
常用的 遍历（数组和对象）方法 排序等
DumBnessA的博客
06-17 507
常用的 遍历（数组和对象）方法 1 forEach 用于遍历【数组】 data.forEach(( item, index ) => { console.log('元素：', item ,'；下标：', index) }) 2 Object.keys() 和 forEach() 结合遍历【对象】 Object.keys(testData).forEach((key)=>{ console.log(key) //键 console.log(testData[key]
List.stream() 各方法应用
Bulldozer_GD的博客
09-14 1万+
List.Stream流 Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。 函数式编程带来的好处尤为明显。这种代码更多地表达了业务逻辑的意图，而不是它的实现机制。易读的代码也易于维护、更可靠、更不容易出错。 面对一对多结构，查询主实体时需要附带主实体的子实体列表怎么写？查出主列表，循环差子列表 List的Stream流操作可以简化我们的代码，减少程序运行的压力，应对上面的问题，以前的话是先查出对应的li
Java中list.stream()各种常用方法汇总
最新发布
gongjin28_csdn的博客
03-26 825
filter()关于Java 8List的stream()方法，整理了多种流操作方法及其应用场景和代码示例：在Java 8中，当我们使用List这类集合时，利用stream()方法可以非常方便地进行各种高级操作。以下汇总各种用法。
java List的stream()方法解析(亲测)
gb4215287的博客
05-26 6249
java List的stream()方法解析
JAVA中List集合Stream流详解
A1916403680的博客
09-17 2401
JAVA中List集合Stream流详解
JAVA8中list.stream()的一些简单使用
qq_15740137的博客
12-08 7028
list.stream()的一些简单使用方法
Java List常用方法Stream()简要总结
热门推荐
BHSZZY的博客
02-10 1万+
一、简介 Java中，ArrayList应该是比较常用的一个对象了；那么它的stream()方法大家了解过吗？ 如果可以熟练使用stream()方法，就可以方便地获取list中元素的某个特定字段、对list中的元素进行筛选、或者把list转成map。 下方是常用的4种stream()用法。 二、代码样例 import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Set; import j
怎么break java8 stream的foreach
12-21
怎么break java8 stream的foreach 简介 我们通常需要在java stream中遍历处理里面的数据，其中foreach是最最常用的方法。 但是有时候我们并不想处理完所有的数据，或者有时候Stream可能非常的长，或者根本就是无限的...
Java中对List去重 Stream去重的解决方法
08-27
主要介绍了Java中对List去重, Stream去重的问题解答，文中给大家介绍了Java中List集合去除重复数据的方法，需要的朋友可以参考下
java8 List 实用方法App.java
05-19
实用方法，使用java8 stream对List 分组，去重，自定义排序
JAVA JDK8 List分组的实现和用法
08-26
今天小编就为大家分享一篇关于JAVA JDK8 List分组的实现和用法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
List的Stream流操作
TechnicianWang的博客
12-06 1万+
1.过滤filter(T->boolean),保留boolean为true的元素。 list.stream().filter(user->user.getAge()>20).collect(Collectors.toList()) 保留年龄大于20的用户数据流，再将其转换为List。 2.去重distinct(),去除重复元素，这个方法是通过类的equals方法来判断两个元素是否相等，需要对原有元素重写equals方法。 list.strean().distinct()..
List集合中stream流的常用用法
YXAAA520的博客
11-01 3817
List集合关于stream流的常用用法
Java中List集合Stream流详解
kim5659的博客
02-25 4274
java list stream
list.stream常用操作
weixin_45866849的博客
07-14 2806
Java8中对集合可以采用流的方式进行一系列的操作，我们直接通过一些例子说明。
系统讲解java中list.stream()的用法
weixin_42206151的博客
11-08 1160
在Java 8及以后的版本中，引入了新的Stream API，这个API提供了一组新的操作方法，可以便捷。中间操作是懒执行的，只有在触发终止操作时，中间操作才会被执行，中间操作函数还有对应的子中间操作函数可调用。中间操作可以被连续地串联起来形成一个操作流水线，最终由终止操作来触发流的执行。它定义了比较两个对象的规则，用于在排序、查找等操作中确定对象的顺序。终止操作是惰性求值的，也就是说，只有在调用终止操作时，中间操作才会被执行。类型的参数，该接口接受一个输入元素，并返回指定类型的元素流。
List Stream 常用方法
ndidai的博客
06-20 5366
public class Student { private String name; private Integer age; private Integer math; private Integer english; //get set public Student(String name, Integer age, Integer math, Integer english) { super(); this.name = name; this.age = age; ...
java List.stream.filter
10-11
Java中的List接口提供了一个stream方法，该方法返回一个流对象，可以使用流操作对列表进行处理。其中，filter操作是一种流操作，用于根据指定的条件过滤列表中的元素。 filter方法接受一个Predicate参数，该参数是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值