java stream 流的基本用法-CSDN博客

本文链接：https://blog.csdn.net/qq_37072064/article/details/129094743

本文介绍了Java8引入的StreamAPI，通过示例展示了如何使用filter、map、flatMap、sort、distinct等方法对数据进行过滤、转换和操作，提供了一种替代传统for循环的高效编程方式。

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

在日常代码编写中，我们经常会遇到对批数据进行过滤，分类，汇总等操作；而要取得我们想要的结果，免不了要进行for循环，其实还有一种方式，就是使用jdk8版本发布的stream流来进行处理。

示例

现在有一组数据{1,2,3,4,5}，需要获取大于3的数据，如何操作？

List<Integer> nums = Arrays.asList(1,2,3,4,5);
List<Integer> list = new ArrayList<>();
//for循环
for (Integer num:nums){
	if(num>3) list.add(num);
}
//stream
list = nums.stream().filter(num->num>3).collect(Collectors.toList());

以上是通过filter来对数据进行过滤
实际上，对于stream流来说，生命周期大致可以分为三步：创建stream,操作stream,终止stream

创建stream
最简单易懂的操作，只要继承了Collection，就可以调用Stream方法生成Stream对象。
注意，此时该对象是串流的，也有可以获取并行流的方法，有兴趣可以自行查阅。
操作stream

函数作用
filter 过滤
map 转换数据（1对1）
flatMap 转换数据（多个合并成一个，然后操作）
sort 排序
distinct 去重
limit 限制数量
skip 跳过数量
concat 合并
peek 遍历

函数	作用
filter	过滤
map	转换数据（1对1）
flatMap	转换数据（多个合并成一个，然后操作）
sort	排序
distinct	去重
limit	限制数量
skip	跳过数量
concat	合并
peek	遍历

终止stream

函数	作用
collect	根据Collectors指定返回数据（常用）
count	计数
max	获取最大值
min	获取最小值
findFirst	找到第一个满足条件元素
findAny	找到任意一个满足条件元素（并行流高效）
anyMatch	返回boolean值，是否有满足条件数据
allMatch	返回boolean值，所有数据都要满足条件
noneMatch	返回boolean，值没有数据满足条件
toArray	返回数组
iterator	返回迭代器
foreach	遍历

具体示例

filter

	public void filter()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> list =  nums.stream().filter(num->num>3).collect(Collectors.toList());
        System.out.println("大于3的数有："+list.toString());
    }
	 大于3的数有：[4, 5]

	public void map()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> list =  nums.stream()
                .map(num->num+1)
                .collect(Collectors.toList());
        System.out.println("所有数加1："+list.toString());
    }
    //结果
    所有数加1：[2, 3, 4, 5, 6]

flatMap

	public void flatMap()
    {
        //flatMap是对多个stream流的汇总
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> nums2 = Arrays.asList(7,8,9,10,11);
        List<List<Integer>> allNum = Arrays.asList(nums,nums2);
        List<Integer> list =  allNum.stream()
                .flatMap(item->item.stream())
                .collect(Collectors.toList());
        System.out.println("合并num："+list.toString());
    }
    //结果
    合并num：[1, 2, 3, 4, 5, 7, 8, 9, 10, 11]

sort

	public void sort()
    {
        List<Integer> nums = Arrays.asList(5,4,3,2,1);
        List<Integer> list =  nums.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println("默认排序："+list.toString());
    }
    //结果
   	默认排序：[1, 2, 3, 4, 5]

distinct

	public void distinct()
    {
        List<Integer> nums = Arrays.asList(1,1,3,4,5);
        List<Integer> list =  nums.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("去重："+list.toString());
    }
    //结果
    去重：[1, 3, 4, 5]

limit

	public void limit()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> list =  nums.stream()
                .limit(3)
                .collect(Collectors.toList());
        System.out.println("限制三个："+list.toString());
    }
    //结果
    限制三个：[1, 2, 3]

skip

	public void skip()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> list =  nums.stream()
                .skip(3)
                .collect(Collectors.toList());
        System.out.println("跳过三个："+list.toString());
    }
	//结果
    跳过三个：[4, 5]

concat

	public void concat()
    {
        //flatMap是对多个stream流的汇总
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> nums2 = Arrays.asList(7,8,9,10,11);
        List<Integer> list = Stream.concat(nums.stream(),nums2.stream())
                .collect(Collectors.toList());
        System.out.println("汇总num："+list.toString());
    }
    //结果
    汇总num：[1, 2, 3, 4, 5, 7, 8, 9, 10, 11]

peek

	public void peek()
    {
        //flatMap是对多个stream流的汇总
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        List<Integer> list = nums.stream()
                .peek(num-> {
                    System.out.println(num);
                })
                .collect(Collectors.toList());
    }
    //结果
    1
	2
	3
	4
	5

count

	public void count()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        long count = nums.stream().count();
        System.out.println("总数为："+count);
    }
    //结果
    总数为：5

	public void max()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Integer max = nums.stream().max(Integer::compareTo).orElse(null);
        System.out.println("最大值："+max);
    }
    //结果
    最大值：5

	public void min()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Integer max = nums.stream().min(Integer::compareTo).orElse(null);
        System.out.println("最小值："+max);
    }
    //结果
    最小值：1

findFirst

	public void findFirst()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Integer first = nums.stream().filter(num->num>2)
                .findFirst().orElse(null);
        System.out.println("获取大于2的第一个元素："+first);
    }
    //结果
    获取大于2的第一个元素：3

findAny

	public void findAny()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Integer any = nums.stream().filter(num->num>2)
                .findFirst().orElse(null);
        System.out.println("获取大于2的任意一个元素："+any);
    }
    //结果
    获取大于2的任意一个元素：3

anyMatch

	public void anyMatch()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        boolean hasMath = nums.stream().anyMatch(item->item>1);
        System.out.println("是否有大于1的数据："+hasMath);
        hasMath = nums.stream().anyMatch(item->item>8);
        System.out.println("是否有大于8的数据："+hasMath);
    }
    //结果
    是否有大于1的数据：true
	是否有大于8的数据：false

allMatch

	public void allMatch()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        boolean hasMath = nums.stream().allMatch(item->item>0);
        System.out.println("是否所有数据大于0："+hasMath);
        hasMath = nums.stream().allMatch(item->item>1);
        System.out.println("是否所有数据大于1："+hasMath);
    }
    //结果
    是否所有数据大于0：true
	是否所有数据大于1：false

toArray

	public void toArray()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Object[] list = nums.stream().toArray();
        for (Object o:list){
            System.out.println(o);
        }
    }
    //结果
    1
	2
	3
	4
	5

iterator

public void iterator()
    {
        
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Iterator<Integer> iterator = nums.stream().iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    //结果
    1
	2
	3
	4
	5

foreach

public void foreach()
    {
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        nums.stream()
                .forEach(num-> {
                    System.out.println(num);
                });
    }
    //结果
    1
	2
	3
	4
	5