【JAVA stream流】

最新推荐文章于 2024-04-05 15:29:09 发布
最新推荐文章于 2024-04-05 15:29:09 发布
阅读量403 收藏
点赞数 2
分类专栏： Java集合 文章标签： java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rita_zf/article/details/124180697
版权

目录

java lambda表达式 forEach sort filter map reduce用法

lambda表达式遍历集合

迭代器获遍历集合

public class Lambda4CollectionTest {
    @Test
    public void test01(){
        List<Integer> list = new ArrayList<>(){{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            Integer next = it.next();
            System.out.println(next);
        }
    }
  }

lambda表达式遍历集合

public class Lambda4CollectionTest {
 @Test
    public void test02(){
        List<Integer> list = new ArrayList<>(){{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
       list.forEach((num) -> {
            System.out.println(num);
        });
    }
 }

lambda表达式遍历集合简写

public class Lambda4CollectionTest {
 @Test
    public void test03(){
        List<Integer> list = new ArrayList<>(){{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        // 一行语句不用花括号
        list.forEach((num) -> System.out.println(num));
    }
 }

public class Lambda4CollectionTest {
 @Test
    public void test04(){
        List<Integer> list = new ArrayList<>(){{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        // 一行语句不用花括号
        list.forEach(System.out::println);
    }
 }

使用stream流遍历集合

public class Lambda4CollectionTest {
@Test
    public void test05(){
        List<Integer> list = new ArrayList<>(){{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        // 串行流
        list.stream().forEach(System.out::println);
    }
 }

使用parallelStream并行流遍历集合输出的元素是无序的

public class Lambda4CollectionTest {
@Test
    public void test06(){
        List<Integer> list = new ArrayList<>(){{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        // 并行流
        list.parallelStream().forEach(System.out::println);
    }
}

输出遍历后的集合

6
5
7
9
4
8
0
3
1
2

streamAPI之filter

需求：挑出集合中的偶数生成一个新集合
迭代器遍历集合方式一：

public class Lambda4CollectionTest {
 @Test
    public void test07() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        ArrayList<Integer> newList = new ArrayList<>();
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            Integer next = it.next();
            if (next % 2 == 0){
                newList.add(next);
            }
        }
        newList.forEach(System.out::println);
    }

输出挑出集合中的偶数并生成了一个新集合

0
2
4
6
8

使用lambda表达式 filter方式二：
filter中predicate返回的是布尔值
在这里插入图片描述
collect(Collectors.toList)生成一个新的集合
在这里插入图片描述

public class Lambda4CollectionTest {
@Test
    public void test08() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        List<Integer> newList = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
        newList.forEach(System.out::println);
    }
}

同样挑出集合中的偶数并生成了一个新集合

0
2
4
6
8

streamAPI之map

需求：使集合中的每一个元素乘以10然后生成一个新集合
迭代器遍历集合方式一：

public class Lambda4CollectionTest {
@Test
    public void test09() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        ArrayList<Integer> newList = new ArrayList<>();
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            Integer next = it.next();
                newList.add(next*10);
        }
        newList.forEach(System.out::println);
    }
}

输出

0
10
20
30
40
50
60
70
80
90

使用lambda表达式map方式二：
map中 Function是传进一个参数类型并且返回一个参数类型
在这里插入图片描述

public class Lambda4CollectionTest {
 @Test
    public void test10() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        List<Integer> newList = list.stream().map(num -> num * 10).collect(Collectors.toList());
        newList.forEach(System.out::println);
    }
}

输出

0
10
20
30
40
50
60
70
80
90

streamAPI之reduce

需求：使集合中的每一个元素相加得到集合元素中的和
迭代器遍历集合方式一：

public class Lambda4CollectionTest {
 @Test
    public void test11() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        int sum = 0;
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            Integer next = it.next();
           sum += next;
        }
        System.out.println(sum);
    }
}

输出

45

使用lambda表达式reduce合并每个元素方式二：
在这里插入图片描述

public class Lambda4CollectionTest {
@Test
    public void test12() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        Integer sum = list.stream().reduce((num0, num1) -> {
            return num0 + num1;
        }).get();
        System.out.println(sum);
    }
}

输出

45

streamAPI综合练习

需求：挑出集合中的偶数其每个偶数乘以2后并合计偶数总和
迭代器遍历集合方式一：

public class Lambda4CollectionTest {
 @Test
    public void test13() {
        List<Integer> list = new ArrayList<>() {{
            for (int i = 0; i < 10; i++) {
                add(i);
            }
        }};
        Integer sum = 0;
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            Integer next = it.next();
            if (next % 2 == 0){
                sum += next * 2;
            }
        }
        System.out.println(sum);
    }
}

40

使用 stream.of方法方式二：

public class Lambda4CollectionTest {
@Test
    public void test14() {
        Stream<Integer> stream = Stream.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        Integer sum = stream.filter(num -> num % 2 == 0).map(num -> num * 2).reduce((num0, num1) -> {
            return num0 + num1;
        }).get();
        System.out.println(sum);
    }
}

输出

40

lambda表达式遍历map

词频统计

public class Lambda4CollectionTest {
@Test
    public void test15() {
        Map<String, Integer> map = new HashMap<>();
        // 词频统计
        String content = "2022 04 13 2022 04 11 2022";
        String[] words = content.split(" ");
        for (String word : words) {
            if (map.containsKey(word)){
                Integer integer = map.get(word);
                map.put(word, ++integer);
            }else {
                map.put(word, 1);
            }
        }
        map.forEach((k, v) -> System.out.println(k + " >>> " + v));
    }
}

输出

11 >>> 1
13 >>> 1
04 >>> 2
2022 >>> 3

lambda表达式集合排序

词频统计后进行排序
排序方式一：

public class Lambda4CollectionTest {
@Test
    public void test16() {
        Map<String, Integer> map = new HashMap<>();
        // 词频统计
        String content = "2022 04 13 2022 04 11 2022";
        String[] words = content.split(" ");
        for (String word : words) {
            if (map.containsKey(word)){
                Integer integer = map.get(word);
                map.put(word, ++integer);
            }else {
                map.put(word, 1);
            }
        }
        map.forEach((k, v) -> System.out.println(k + " >>> " + v));
        System.out.println("++++++++++++++++++++");
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        ArrayList<Map.Entry<String, Integer>> list = new ArrayList<>();
        Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            list.add(entry);
        }
            list.sort(new Comparator<Map.Entry<String, Integer>>() {
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    return o2.getValue() - o1.getValue();
                }
            });
            list.forEach(entry -> System.out.println(entry.getKey() + " >>> " + entry.getValue()));
        }

输出

11 >>> 1
13 >>> 1
04 >>> 2
2022 >>> 3
++++++++++++++++++++
2022 >>> 3
04 >>> 2
11 >>> 1
13 >>> 1

排序方式二：

public class Lambda4CollectionTest {
@Test
    public void test17() {
        Map<String, Integer> map = new HashMap<>();
        // 词频统计
        String content = "2022 04 13 2022 04 11 2022";
        String[] words = content.split(" ");
        for (String word : words) {
            if (map.containsKey(word)){
                Integer integer = map.get(word);
                map.put(word, ++integer);
            }else {
                map.put(word, 1);
            }
        }
        map.forEach((k, v) -> System.out.println(k + " >>> " + v));
        System.out.println("++++++++++++++++++++");
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        ArrayList<Map.Entry<String, Integer>> list = new ArrayList<>();
        Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            list.add(entry);
        }

        list.sort((entry0, entry1) -> entry1.getValue() - entry0.getValue());
        list.forEach(entry -> System.out.println(entry.getKey() + " >>> " + entry.getValue()));
    }
}

输出

11 >>> 1
13 >>> 1
04 >>> 2
2022 >>> 3
++++++++++++++++++++
2022 >>> 3
04 >>> 2
11 >>> 1
13 >>> 1
Rita_zzf
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaStream流
08-22
Java Stream流 详细文档
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
JAVA8 Stream接口，map操作，filter操作，flatMap操作
热门推荐
鸭鸭的博客
06-10 7万+
这篇，我们来看Stream的一些中间操作，关于中间操作的一些介绍，可以看《JAVA8 stream接口 中间操作和终端操作》 1，filter操作，我们先看方法的定义 Stream<T> filter(Predicate<? super T> predicate); 这个方法，传入一个Predicate的函数接口，关于Predicate函数接口定义，可以查看《JAV...
Java------Stream流式编程常用API【.stream，filter()，map()】（三）
cz_chen_zhuo的博客
08-01 888
基于数组生成流对象。既可以通过Stream.of（），也可以直接调用.stream方法。test方法产生一个boolean结果，为true则为新流的元素保留，为false则舍弃该元素。map是通过对keySet，以及Values集合生成流对象。list里放list的结构，流操作时，需要进行两次流转换。针对数组、List、Map、Set生成流对象。也可以再进行一次filter过滤方法。基于collection对象生成流。可以使用或、与进行多条件判断。分为基础API和高阶API。示例2，返回Map形式的流。..
java-Stream原理及相关操作详解(filter、map、flatMap、peek、reduce、anyMatch等等)
最新发布
supermanman_的博客
04-05 1292
Stream流本质上是一个执行计算的过程，将流当中的中间操作组成一个流管道的形式，流管道由源（可能是数组，集合，生成器函数，I / O通道等），零个或多个中间操作 （将流转换为另一个流，如filter(Predicate) ）组成，以及终端操作 （产生结果或副作用，例如count()、forEach(Consumer) 、collect(?
java stream filter map collector使用
dreamzuora的博客
07-13 603
class People{ String name; int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { ret...
Java8特性之Stream的常用方法:filter，map，sorted
睡竹的博客
01-12 4889
Java8特性之Stream的常用方法:filter，map，sorted
手把手带你读java源码之JAVA-stream-中间操作map,flatmap,filter,unordered,peek,distinct,sorted,limit,skip(万字图文详解)
Thepatterraining的博客
03-03 1390
这篇文章主要介绍了JAVA8新增的stream流，作为最常用的一个工具，你是否常常不会用或者用错呢？本文自顶向下一步步的手把手带你通读它的源码，做到不仅会用，还可以用好，甚至学习其中的精妙之处以后自己也可以实现。本文中包括了所有中间操作，比如map,faltMap,filter,unordered,peek,distinct,sorted,limit,skip。本文章属于手把手带你读java源码系列文章，做到每一行源码都有注释，告诉你其中的原理和为什么要这么做。
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
JAVA8 Stream方法使用详解Filter、map等用法(一)
小&哥
11-29 1万+
文章目录 一、筛选和切片 1、谓词筛选filter 2、筛选不同的元素distinct 3、截断流limit 4、跳过元素 二、映射 1、map对每个元素应用函数 2、流的扁平化 三、查找和匹配 1、至少匹配一个 2、匹配所有 3、查找元素 4、查找第一个元素 流可以让我们从外部迭代转向内部迭代，流可以理解为按需加载(只有消费者消费的时候才开始生产)，集合是供应商驱动(先把仓库装满，再开始卖)。流可
Java8 Stream API中filter和map怎么选择
YangZzzzzzzzzzz的博客
05-20 2330
基本原则: filter是满足条件的留下，是对原数组的过滤；map则是对原数组的加工，映射成一对一映射的新数组 说人话就是改变了了长度了用filter,没改变长度,只是对某一个或者几个做改变用map public static void main(String[] args) { List<String> list = Arrays.asList("java","c++","c","python","php","c","c"); String res =
Java8 stream使用
努力奋斗
11-26 378
Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda，给我们操作集合（Collection）提供了极大的便利。 那么什么是Stream？ Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。 Stream可以由数组或集合创建，对流的操作分为两种： 中间操作，每次返回一个新的流，可以有多个。 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个..
Java8 Stream接口流式方法：map操作、filter操作以及flatMap操作
Java笔记虾
01-17 2197
点击关注公众号，利用碎片时间学习关于stream 流式操作，在rt.jar 包里面，ReferencePipeline管道方式操作数据 下面集成所有操作方法，利用这些流，处理大数据的方式，...
Java8新特性 Stream简介 stream().filter和stream().map区别
yogima的博客
04-28 1万+
需要使用Stream，首先要使用.stream()或.parallelStream()将集合生成流，其中最常用的是它的filter和map方法，简单写了下，如下： import java.io.*; import java.util.stream.Collectors; import java.util.List; import java.util.ArrayList; class test { public static void main (String[] args) { List&lt
java利用stream和lambda得到数对并进行遍历
weixin_45929885的博客
09-08 196
java利用stream和lambda得到数对并进行遍历 final List<Integer> num1 = Arrays.asList(1, 2, 3); final List<Integer> num2 = Arrays.asList(3, 4); List<int[]> collect = num1.stream().flatMap(i -> num2.stream().map(k -> new int[
Stream流中forEach,filter和map的简单运用
qq_52351105的博客
07-28 1594
在Stream流中有几种常用方法： 1.逐一处理：forEach 2. 过滤：filter 3. 映射：map 下面只是举例简单的代码实现，与之前的Consumer，Predicate， Function三个核心函数式接口有很重要的联系。 forEach代码： import java.util.stream.Stream; public class DemoforEach { public static void main(String[] args) { Stream<Integer>
java Stream流
10-03
Java Stream流是Java 8新引入的一种处理集合数据的抽象概念。它允许我们以声明性的方式对数据进行操作，而不是通过传统的循环和条件语句。Stream流可以被看作是一种高级迭代器，它可以串行或并行地处理数据，并且...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rita_zzf

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值