Java 8 Stream流的几种常见使用

已于 2023-06-29 10:20:00 修改
阅读量143 收藏 1
点赞数
分类专栏： Java技术知识 文章标签： java
于 2023-06-25 17:05:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45130092/article/details/131377976
版权

中间操作、终止操作

只有中间操作没有终止操作的话，这些操作不会立即执行，也就是不会立即对元素进行处理，而是返回一个新的 Stream 对象，这个新的 Stream 对象会在遇到终止操作时才会执行中间操作中定义的逻辑。

简单来说，中间操作返回的是一个“惰性求值”的 Stream 对象，只有在遇到终止操作时才会触发实际的计算，这种方式可以提高计算效率。

中间操作和终止操作分别有哪些？

  • 中间操作：
    • filter、limit、skip、distinct、sorted
    • map
    • parallel
  • 终止操作
    • forEach、sum、min、max、count、average
    • anyMatch、allMatch、noneMatch
    • reduce、collect

filter

使用 filter 方法可以根据指定的条件过滤出符合条件的元素。

ArrayList<String> list = new ArrayList<>();
list.add("《日日是好日》");
list.add("《三国演义》");
list.add("《孙子兵法》");
list.add("《小狗钱钱》");
Stream<String> stream = list.stream().filter(element -> element.contains("日"));
stream.forEach(System.out::println);
// 输出：《日日是好日》

limit

limit 方法可以截取指定数量的元素，返回一个新的流。

List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 5);
Stream<Integer> distinct = numbers.stream().limit(3);
distinct.forEach(System.out::println);
// 输出：
// 1
// 2
// 3

skip

skip 方法可以跳过指定数量的元素。

List<Integer> numbers = Arrays.asList(8, 2, 3, 2, 5);
Stream<Integer> skip = numbers.stream().skip(2);
skip.forEach(System.out::println);
// 输出：
// 3
// 2
// 5

distinct

使用 distinct 方法可以去除流中重复的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 5);
Stream<Integer> distinctNumbers = numbers.stream().distinct();
distinctNumbers.forEach(System.out::println);
// 输出：
// 1
// 2
// 3
// 5

sorted

使用 sorted 方法可以对流中的元素进行排序。

int[] numbers = {5, 8, 1, 3, 9};
IntStream sortedNumbers = Arrays.stream(numbers).sorted();
sortedNumbers.forEach(System.out::println);
// 输出：
// 1
// 3
// 5
// 8
// 9

对流中的对象进行排序，需要实现 Comparable 接口或者使用 Comparator 接口。

1、实现 Comparable 接口

package com.qf.cmf.javabase.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        return Integer.compare(this.age, o.age);
    }
}

public class StreamSortedExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("A", 20));
        people.add(new Person("B", 25));
        people.add(new Person("C", 18));
        people.add(new Person("D", 30));

        // 使用Comparable接口进行排序
        Collections.sort(people);
        System.out.println(people);
    }
}
// 输出：
// [Person{name='C', age=18}, Person{name='A', age=20}, Person{name='B', age=25}, Person{name='D', age=30}]

2、 Comparator 接口

package com.qf.cmf.javabase.stream;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class StreamSortedExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("A", 20));
        people.add(new Person("C", 25));
        people.add(new Person("B", 18));
        people.add(new Person("D", 30));

        // 使用Comparator接口进行排序
        people.stream().sorted(Comparator.comparing(Person::getName)).forEach(p -> System.out.println(p.getName() + " " + p.getAge()));
    }
}
// 输出：
// A 20
// B 18
// C 25
// D 30

map

使用 map 方法可以将一个流中的元素按照指定的方式进行转换，生产一个新的流。

ArrayList<String> list = new ArrayList<>();
list.add("《日日是好日》");
list.add("《三国演义》");
list.add("《孙子兵法》");
list.add("《小狗钱钱》");
Stream<Integer> stream = list.stream().map(String::length);
stream.forEach(System.out::println);
// 输出：
// 7
// 6
// 6
// 6

forEach

forEach 方法可以用来遍历 Stream 中的每一个元素，它的语法如下：

void forEach(Consumer<? super T> action)

其中，action 表示对每个元素要执行的操作，它是一个 Consumer 接口的实例。

List<String> list = Arrays.asList("Java", "Python", "JavaScript", "C++");

// 使用 forEach() 方法遍历 Stream 中的每一个元素
list.stream().forEach(System.out::println);

// 输出：
// Java
// Python
// JavaScript
// C++

sum、min、max、count、average

使用 sum、min、max、count、average 等方法可以对流中的元素进行统计

sum 求和

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().mapToInt(Integer::intValue).sum();
System.out.println(sum); // 输出 15

min 求最小值

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int min = numbers.stream().mapToInt(Integer::intValue).min().orElse(0);
System.out.println(min); // 输出 1

求最大值

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int max = numbers.stream().mapToInt(Integer::intValue).max().orElse(0);
System.out.println(max); // 输出 5

统计元素个数

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream().count();
System.out.println(count); // 输出 5

求平均值

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
double average = numbers.stream().mapToInt(Integer::intValue).average().orElse(0);
System.out.println(average); // 输出 3.0

anyMatch、allMatch、noneMatch

使用 anyMatch、allMatch、noneMatch 等方法可以判断流中的元素是否符合指定的条件。

anyMatch：返回一个 boolean 值，表示 Stream 中是否存在至少一个元素符合指定的条件。

allMatch：返回一个 boolean 值，表示 Stream 中的所有元素是否都符合指定的条件。

noneMatch：返回一个 boolean 值，表示 Stream 中是否不存在任何一个元素符合指定的条件。

ArrayList<String> list = new ArrayList<>();
list.add("《日日是好日》");
list.add("《三国演义》");
list.add("《孙子兵法》");
list.add("《小狗钱钱》");
boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("技"));
boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("术"));
// 输出
// false
// true
// true

reduce

reduce 函数的语法如下：

T reduce(BinaryOperator<T> accumulator)

使用 reduce 方法可以将流中的元素按照指定的方式进行归约，生成一个新的值。

Integer[] ints = {0, 1, 2, 3};
List<Integer> list = Arrays.asList(ints);

Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);
Optional<Integer> optional1 = list.stream().reduce(Integer::sum);
System.out.println(optional.orElse(0));
System.out.println(optional1.orElse(0));
// 输出：
// 6
// 6

int reduce = list.stream().reduce(6, (a, b) -> a + b);
System.out.println(reduce);

int reduce1 = list.stream().reduce(6, Integer::sum);
System.out.println(reduce1);
// 输出：
// 12
// 12

reduce 可以设定初始值，如果设定了的话初始值也会加上运算。

collect

使用 collect 方法可以将流中的元素收集到一个集合中。

ArrayList<String> list = new ArrayList<>();
list.add("《日日是好日》");
list.add("《三国演义》");
list.add("《孙子兵法》");
list.add("《小狗钱钱》");
List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
List<String> list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
List<String> list3 = list.stream().collect(Collectors.toList());
String list4 = list.stream().collect(Collectors.joining(", ")).toString();
System.out.println(list1);
System.out.println(list2);
System.out.println(list3);
System.out.println(list4);
// 输出：
// [7, 6, 6, 6]
// [《日日是好日》, 《三国演义》, 《孙子兵法》, 《小狗钱钱》]
// [《日日是好日》, 《三国演义》, 《孙子兵法》, 《小狗钱钱》]
// 《日日是好日》, 《三国演义》, 《孙子兵法》, 《小狗钱钱》

总结

Stream 是非常强大的，感兴趣可以深入去学习。

“行动是治愈恐惧的良药，而犹豫拖延将不断滋养恐惧。"

Lola陈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java8：流的使用
qq_43578218的博客
05-12 139
流的创建和API的基本使用 在java8中提供了一套流式的数据处理，也就是Stream API，这套API的主要作用就是对数据进行处理，作为程序员平时打交道最多的可能就是集合了，那么流和我们迭代遍历有什么不同呢 Stream API 迭代遍历 相当于一套流水线，对数据一次性处理 每次迭代都需要分支进行计算，有时需要多次迭代才能得到最终结果 适应现代多核计算机，在几乎不消耗额外资...
Java8中流的使用
鱼人的博客
08-20 409
1. 引入流 流是Java API的新成员，它允许你以声明式方式处理数据集合。就现在来说，你可以把它看成遍历数据集的高级迭代器。 流操作 java.util.stream.Stream中的stream接口定义了许多操作。它们可以被分为两大类：中间操作和终端操作。可以被连接起来的流操作称为中间操作，关闭流的操作称为终端操作。 filter、map和limit可以连成一条流水线 collect触发流水线执行并关闭它 中间操作：filter，map、limit、distinct、sorted等，返回一个流
java8 stream常用方法
热门推荐
lockie的博客
05-20 3万+
一. 什么是 Stream Stream 中文称为“流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。 二. 流操作 整个流操作就是一条流水线，将元素放在流水线上一个个地进行处理。 其中数据源便是原始集合，然后将如 List<T> 的集合转换为 Stream<T> 类型的流，并对流进...
Java8之常用的流（Stream）操作
qq_43305367的博客
11-03 987
Java8常用的Stream和Collectors操作
java8 Stream 常用
彭xiao民的技术博客
03-21 426
java8Stream常用 //1.stream某一个元素计数 long count = myInfoList.stream().mapToInt(item -> item.getAge()).sum(); System.out.println(count); //2.stream过滤后某一个元素计数 long count2 = myInfoList.stream().filter(i...
Java8 stream常用方法
weixin_44000133的博客
12-14 1076
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。 ...
使用Java实现对dbf文件的简单读写
11-26
使用 Java 实现对 dbf 文件的简单读写需要使用以下几个类： 1. DBFWriter：用于 dbf 文件的写操作，提供了写入 dbf 文件的方法。 2. JDBField：用于表示 dbf 文件中的字段信息，包括字段名、字段类型、字段长度等。...
Java服务器端开发面试.doc
06-07
Java的内部类，有哪几种声明方式，有没有static的区别 集合，collection，array。 set, list, queue这些接口间的区别，set不可重复， arraylist的实现和linkedlist的实现区别，HashMap, HashTable。涉及到各种效率...
java面试笔试资料包括JAVA基础核心知识点深度学习Spring面试题等资料合集.zip
08-20
第八题 Java并发类库提供的线程池有哪几种 分别有什么特点.pdf 第六题 synchronized和ReentLock有什么区别.pdf 第四题 ArrayList LinkedList Vector的区别.pdf docker讲得最清楚.doc Dubbo是什么？能做什么？.doc ...
JAVA内存溢出问题总结
01-14
从程序类方面来说，内存溢出的原因有很多，以下是常见的几种： 1、查询数据库的时候递归循环了，应尽量使用精简的关联 SQL 查询。 在查询数据库时，应该避免使用递归循环的方式，这样可以减少内存的使用量。同时，...
Java8 Stream流的常用方法和讲解
m0_71355126的博客
06-24 733
Java8 Stream 中如何使用和一些常用方法
Java8_stream流的常见用法
早起一杯咖啡
07-02 1039
先看下几个最近项目中用到的stream流的例子： if (CollectionUtils.isNotEmpty(schoolVOList)) { pushUserListRequest.setSchoolIds(schoolVOList.stream().map(SchoolVO::getSchoolId).collect(Collectors.toList())); } //根据用户ID分组 L...
JAVA8 流基本使用
zhanghe687的博客
01-11 197
参考地址： 用Stream来优化老代码，瞬间干净优雅了！https://mp.weixin.qq.com/s/DiFib195GFYOWTAu0__cIg
玩转 Java8 Stream，常用方法大合集
weixin_44975537的博客
04-07 223
玩转 Java8 Stream，常用方法大合集
Java8新特性 stream流常用方法
PPX、小布的博客
06-08 248
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Java 8 Stream流的常见操作
淡墨青衫、剑轻吟
01-23 281
Java 8 Stream流的常见操作
详解Java8中流(Stream)的使用
境里婆娑
03-28 692
文章列表一、回忆Lambda表达式二、什么是流1、流只能遍历一次2、外部迭代和内部迭代三、流操作1、谓词筛选2、筛选各异元素3、截段流4、跳过元素5、map和flatMap6、查找和匹配7、归约reduce 写在前面： 我是「境里婆娑」。我还是从前那个少年，没有一丝丝改变，时间只不过是考验，种在心中信念丝毫未减，眼前这个少年，还是最初那张脸，面前再多艰险不退却。 写博客的目的就是分享给大家一起学习交流，如果您对 Java感兴趣，可以关注我，我们一起学习。 前言：还没接触过流的同学可以深入研究下此篇文章，
java8 流_java8之流的基本使用(二)
weixin_33267354的博客
02-21 181
概述流(stream())是java8的一个新特性,主要的作用就是将各种类型的集合转换为流,然后的方便迭代数据用的.例如://将List类型的集合转换为流list.stream()转换为流之后可以进行一系列的迭代操作,比自己去拿出list的值一个个操作要方便的多.使用流的好处声明性 -- 更简洁、更易读可复合 -- 更灵活可并行 -- 性能更好流的使用方法介绍使用流之前,必须先对函数式接口、lam...
java Stream流
最新发布
10-03
Java Stream流是Java 8新引入的一种处理集合数据的抽象概念。它允许我们以声明性的方式对数据进行操作，而不是通过传统的循环和条件语句。Stream流可以被看作是一种高级迭代器，它可以串行或并行地处理数据，并且...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值