Java8-Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合

于 2024-04-29 00:41:21 发布
阅读量981 收藏 21
点赞数 20
分类专栏： 程序员 文章标签： windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84103344/article/details/138296237
版权

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3、使用Stream的静态方法：of()、iterate()、generate()

Stream stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println); // 0 2 4 6 8 10 Stream stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

输出结果：

0 3 6 9 0.6796156909271994 0.1914314208854283 0.8116932592396652

stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：

image.png

如果流中的数据量足够大，并行流可以加快处速度。

除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：

Optional findFirst = list.stream().parallel().filter(x->x>6).findFirst();

3 Stream的使用

在使用stream之前，先理解一个概念：Optional 。

Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

接下来，大批代码向你袭来！我将用20个案例将Stream的使用整得明明白白，只要跟着敲一遍代码，就能很好地掌握。

image

案例使用的员工类

这是后面案例中使用的员工类：

List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, “female”, “New York”));
personList.add(new Person(“Owen”, 9500, “male”, “New York”));
personList.add(new Person(“Alisa”, 7900, “female”, “New York”));

class Person {
private String name; // 姓名 private int salary; // 薪资 private int age; // 年龄 private String sex; //性别 private String area; // 地区 // 构造方法 public Person(String name, int salary, int age,String sex,String area) {
this.name = name;
this.salary = salary;
this.age = age;
this.sex = sex;
this.area = area;
} // 省略了get和set，请自行添加 }

3.1 遍历/匹配（foreach/find/match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。

image.png

3.1 遍历/匹配（foreach/find/match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。

![

// import已省略，请自行添加，后面代码亦是 public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(7, 6, 9, 3, 8, 2, 1); // 遍历输出符合条件的元素 list.stream().filter(x -> x > 6).forEach(System.out::println); // 匹配第一个 Optional findFirst = list.stream().filter(x -> x > 6).findFirst(); // 匹配任意（适用于并行流） Optional findAny = list.parallelStream().filter(x -> x > 6).findAny(); // 是否包含符合特定条件的元素 boolean anyMatch = list.stream().anyMatch(x -> x < 6);
System.out.println(“匹配第一个值：” + findFirst.get());
System.out.println(“匹配任意一个值：” + findAny.get());
System.out.println(“是否存在大于6的值：” + anyMatch);
}
}

3.1 遍历/匹配（foreach/find/match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
image.png

3.2 筛选（filter）

筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。

image

案例一：筛选出Integer集合中大于7的元素，并打印出来

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
Stream stream = list.stream();
stream.filter(x -> x > 7).forEach(System.out::println);
}
}

预期结果：

8 9

案例二： 筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集），后文有详细介绍。

public class StreamTest {
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, 23, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, 25, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, 21, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, 24, “female”, “New York”));
personList.add(new Person(“Owen”, 9500, 25, “male”, “New York”));
personList.add(new Person(“Alisa”, 7900, 26, “female”, “New York”));

List fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName)
.collect(Collectors.toList());
System.out.print(“高于8000的员工姓名：” + fiterList);
}
}

运行结果：

高于8000的员工姓名：[Tom, Anni, Owen]

3.3 聚合（max/min/count)

max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。

image.png

案例一：获取String集合中最长的元素。

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(“adnm”, “admmt”, “pot”, “xbangd”, “weoujgsd”);

Optional max = list.stream().max(Comparator.comparing(String::length));
System.out.println(“最长的字符串：” + max.get());
}
}

输出结果：

最长的字符串：weoujgsd

案例二：获取Integer集合中的最大值。

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(7, 6, 9, 4, 11, 6); // 自然排序 Optional max = list.stream().max(Integer::compareTo); // 自定义排序 Optional max2 = list.stream().max(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println(“自然排序的最大值：” + max.get());
System.out.println(“自定义排序的最大值：” + max2.get());
}
}

输出结果：

自然排序的最大值：11 自定义排序的最大值：11

案例三：获取员工工资最高的人。

public class StreamTest {
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, 23, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, 25, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, 21, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, 24, “female”, “New York”));
personList.add(new Person(“Owen”, 9500, 25, “male”, “New York”));
personList.add(new Person(“Alisa”, 7900, 26, “female”, “New York”));

Optional max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
System.out.println(“员工工资最大值：” + max.get().getSalary());
}
}

输出结果：

员工工资最大值：9500

案例四：计算Integer集合中大于6的元素的个数。

import java.util.Arrays;
import java.util.List;

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);

long count = list.stream().filter(x -> x > 6).count();
System.out.println(“list中大于6的元素个数：” + count);
}
}

输出结果：

list中大于6的元素个数：4

3.4 映射(map/flatMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

  • map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

  • flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

image

image

案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。

public class StreamTest {
public static void main(String[] args) {
String[] strArr = { “abcd”, “bcdd”, “defde”, “fTr” };
List strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());

List intList = Arrays.asList(1, 3, 5, 7, 9, 11);
List intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());

System.out.println(“每个元素大写：” + strList);
System.out.println(“每个元素+3：” + intListNew);
}
}

输出结果：

每个元素大写：[ABCD, BCDD, DEFDE, FTR] 每个元素+3：[4, 6, 8, 10, 12, 14]

案例二：将员工的薪资全部增加1000。

public class StreamTest {
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, 23, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, 25, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, 21, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, 24, “female”, “New York”));
personList.add(new Person(“Owen”, 9500, 25, “male”, “New York”));
personList.add(new Person(“Alisa”, 7900, 26, “female”, “New York”)); // 不改变原来员工集合的方式 List personListNew = personList.stream().map(person -> {
Person personNew = new Person(person.getName(), 0, 0, null, null);
personNew.setSalary(person.getSalary() + 10000);
return personNew;
}).collect(Collectors.toList());
System.out.println(“一次改动前：” + personList.get(0).getName() + “–>” + personList.get(0).getSalary());
System.out.println(“一次改动后：” + personListNew.get(0).getName() + “–>” + personListNew.get(0).getSalary()); // 改变原来员工集合的方式 List personListNew2 = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 10000);
return person;
}).collect(Collectors.toList());
System.out.println(“二次改动前：” + personList.get(0).getName() + “–>” + personListNew.get(0).getSalary());
System.out.println(“二次改动后：” + personListNew2.get(0).getName() + “–>” + personListNew.get(0).getSalary());
}
}

输出结果：

一次改动前：Tom–>8900 一次改动后：Tom–>18900 二次改动前：Tom–>18900 二次改动后：Tom–>18900

案例三：将两个字符数组合并成一个新的字符数组。

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(“m,k,l,a”, “1,3,5,7”);
List listNew = list.stream().flatMap(s -> { // 将每个元素转换成一个stream String[] split = s.split(“,”);
Stream s2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());

System.out.println(“处理前的集合：” + list);
System.out.println(“处理后的集合：” + listNew);
}
}

输出结果：

处理前的集合：[m-k-l-a, 1-3-5] 处理后的集合：[m, k, l, a, 1, 3, 5]

3.5 归约(reduce)

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

image.png

案例一：求Integer集合的元素之和、乘积和最大值。

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(1, 3, 2, 8, 11, 4); // 求和方式1 Optional sum = list.stream().reduce((x, y) -> x + y); // 求和方式2 Optional sum2 = list.stream().reduce(Integer::sum); // 求和方式3 Integer sum3 = list.stream().reduce(0, Integer::sum); // 求乘积 Optional product = list.stream().reduce((x, y) -> x * y); // 求最大值方式1 Optional max = list.stream().reduce((x, y) -> x > y ? x : y); // 求最大值写法2 Integer max2 = list.stream().reduce(1, Integer::max);

System.out.println(“list求和：” + sum.get() + “,” + sum2.get() + “,” + sum3);
System.out.println(“list求积：” + product.get());
System.out.println(“list求和：” + max.get() + “,” + max2);
}
}

输出结果：

list求和：29,29,29 list求积：2112 list求和：11,11

案例二：求所有员工的工资之和和最高工资。

public class StreamTest {
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, 23, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, 25, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, 21, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, 24, “female”, “New York”));
personList.add(new Person(“Owen”, 9500, 25, “male”, “New York”));
personList.add(new Person(“Alisa”, 7900, 26, “female”, “New York”)); // 求工资之和方式1： Optional sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum); // 求工资之和方式2： Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),
(sum1, sum2) -> sum1 + sum2); // 求工资之和方式3： Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum); // 求最高工资方式1： Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
Integer::max); // 求最高工资方式2： Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
(max1, max2) -> max1 > max2 ? max1 : max2);

System.out.println(“工资之和：” + sumSalary.get() + “,” + sumSalary2 + “,” + sumSalary3);
System.out.println(“最高工资：” + maxSalary + “,” + maxSalary2);
}
}

输出结果：

工资之和：49300,49300,49300 最高工资：9500,9500

3.6 收集(collect)

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

collect主要依赖java.util.stream.Collectors类内置的静态方法。

3.6.1 归集(toList/toSet/toMap)

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

下面用一个案例演示toList、toSet和toMap：

public class StreamTest {
public static void main(String[] args) {
List list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
List listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
Set set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, 23, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, 25, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, 21, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, 24, “female”, “New York”));

最后

本人也收藏了一份Java面试核心知识点来应付面试，借着这次机会可以送给我的读者朋友们

目录：

全靠这套面试题，才让我有惊无险美团二面拿offer （面经解析）

Java面试核心知识点

一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！

全靠这套面试题，才让我有惊无险美团二面拿offer （面经解析）

Java面试核心知识点

已经有读者朋友靠着这一份Java面试知识点指导拿到不错的offer了

全靠这套面试题，才让我有惊无险美团二面拿offer （面经解析）

(“Lily”, 7800, 21, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, 24, “female”, “New York”));

最后

本人也收藏了一份Java面试核心知识点来应付面试，借着这次机会可以送给我的读者朋友们

目录：

[外链图片转存中…(img-kjgk8v2O-1714322470241)]

Java面试核心知识点

一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！

[外链图片转存中…(img-Ot4G8oJf-1714322470242)]

Java面试核心知识点

已经有读者朋友靠着这一份Java面试知识点指导拿到不错的offer了

[外链图片转存中…(img-1l8UebSw-1714322470242)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84103344
关注
  • 20
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于Stream()和Collectors.joining（）字符串连接器
qq_40673345的博客
06-11 1万+
工作时发现一个很棒的拼接字符串的方法： final String[] strs= {"x", "y", "z"}; Stream<String> stream = Stream.of(strs); // 拼接成 [x, y, z] 形式 String result1 = stream.collect(Collectors.joining(", ", "[", "]")); // ...
JAVA Lambda表达式过滤
春困秋乏_夏打盹
07-16 4279
JAVA Lambda表达式过滤 1. list字符串去重 List<String> unique = list.stream().distinct().collect(Collectors.toList()); 2.集合对象去重 // Person 对象 public class Person { private String id; private String name; private String sex; <!--省略
java8 stream collectors.joining
qq_43319321的博客
04-08 5971
详细讲讲Java 8流（stream）收集器（Collectors）中的joining()方法。该方法会返回一个Collectors实例，方便在流收集器上的链式操作。 Collectors.joining() 方法以遭遇元素的顺序拼接元素。我们可以传递可选的拼接字符串，前缀和后缀
Stream流的使用步骤，获取，中间方法，终结方法
m0_74000465的博客
05-28 805
这段代码我先将上面的集合获取到流stream中，然后调用stream的filter过滤方法得到新的流stream1；，如果传递了基本数据类型的数组作为参数，那么会把整个数组的地址作为一个元素放到Stream中。注意：使用toMap方法时，流中的数据的键不能重复，否则会直接报错。concat可以连接类型相同的流，获取到的新的流的类型不变；不同的是，获取数组的Stream流方法是类 Arrays的。concat也可以连接类型不同的流，获取到的新的流的类型。为了简化代码的书写，也为了避免流的误操作，通常采用。
Java8 StreamFilter
qq_44885775的博客
04-26 549
Java8 StreamFilter
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合.md
最新发布
06-20
Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的 Lambda，给我们操作集合（Collection）提供了极大的便利。 Stream将要处理的元素集合看作一种流，在流的过程中，借助`Stream API`对流中的...
java8-集合元素归约.pdf
07-10
Java 8 引入了 Stream API，极大地增强了对集合数据的操作能力。在处理集合时，有时我们需要将所有元素聚合到一个单一的值上，这就是所谓的“归约”操作。`Stream.reduce()` 方法就是用于实现这一功能的关键工具。在...
Pratice-Java-8:实用Java -8和您的新功能
05-16
2. **流(Stream)**：Java 8的流API提供了一种全新的处理数据的方式，它可以用于集合、数组或其他数据源。流API支持序列和并行操作，允许进行复杂的过滤、映射和归约操作。例如，`List<String> names = Arrays.asList...
java8源码-java8-learn:java8-学习
06-04
Stream API是Java 8中的另一个重要改进，它提供了一种声明式处理数据的方式，使得对集合的操作更加高效和简洁。Stream API支持串行和并行操作，可以用于过滤、映射、归约等操作。例如，找出大于5的整数： ```java ...
GuavaGWT-Java8-Test:使用 Java8 测试 GuavaGWT
07-02
GuavaGWT-Java8-Test 是一个项目，旨在探讨如何在 Google Web Toolkit (GWT) 环境中利用 Java 8 的新特性来测试 Guava 库。Guava 是 Google 提供的一个广泛使用的 Java 工具包，包含了许多实用的集合、缓存、并发和I...
java 集合stream流 详解
u012758488的博客
08-10 2806
Stream distinct() 返回由该流的去重（根据Object.equals(Object) ）之后的不同元素组成的流。static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流。使用默认方法stream()生成流， default Stream stream()中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作。对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。...
Java8新特性——StreamAPI(二)
大闲人柴毛毛
08-28 2万+
1. 收集器简介收集器用来将经过筛选、映射的流进行最后的整理，可以使得最后的结果以不同的形式展现。collect方法即为收集器，它接收Collector接口的实现作为具体收集器的收集方法。Collector接口提供了很多默认实现的方法，我们可以直接使用它们格式化流的结果；也可以自定义Collector接口的实现，从而定制自己的收集器。这里先介绍Collector常用默认静态方法的使用，自定义收集器会
stream().filter()的用法
热门推荐
点点滴滴
09-08 13万+
stream.filter一般适用于list集合,主要作用就是模拟sql查询，从集合中查询想要的数据。filter里面的参数user是指集合里面的每一项 public class StreamTest{ public static void main(String[] args){ List<User> list = new ArrayList<>(); //定义三个用户对象 User user1 = new User();
求HashSet中的最大值
会编程的林俊杰的博客
03-19 3108
求HashSet中的最大值  先对集合中的数据进行初始化： public static void main(String[] args) { Set<Integer> set = new HashSet<>(); set.add(1); set.add(9); set.add(6); set.add(8); set.add(4); } 利用集合的max()方法： Integer res = Collections.max(set); Sys
Java8-Stream join
lf_haven的博客
09-01 6710
java8 sream join
Java8Stream流的sorted()排序===使用Comparator排序
dsl
01-05 1万+
sorted()方法排序，一个是Comparable(自然排序)，一个是Comparator接口，像Integer、String等这些基本类型的包装类已经实现了Comparable接口， Comparable接口======》java.lang包下的 方法CompareTo(Object o)，除了基本类型包装类外，一些常用的pojo类要使用CompareTo(Object o)排序，就要实现Comparable接口，在pojo类里重写compareTo()方法 Comparator接口======.
Stream的运用
weixin_42848855的博客
03-05 1067
java8 stream的使用
Stream流的简单应用
Momo_daddy的博客
09-12 674
Stream流应用的简单场景
java8 stream:两万字
04-29
Java 8 Stream 是一种新的 API，它引入了一些新的概念和操作，以便更容易地...虽然介绍Java 8 Stream 的文章有两万字，但这是为了让读者更好地理解和掌握这个新的 API。如果读者认真阅读，那么他们将会从中受益匪浅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值