JDK 1.8 新特性之Stream 详解个人笔记

最新推荐文章于 2024-04-07 16:40:43 发布
最新推荐文章于 2024-04-07 16:40:43 发布
阅读量167 收藏
点赞数
分类专栏： java 文章标签： java stream
原文链接：https://blog.csdn.net/chenhao_c_h/article/details/80691284
版权

本文转载自链接：https://blog.csdn.net/chenhao_c_h/article/details/80691284

首先对stream的操作可以分为两类，中间操作(intermediate operations)和结束操作(terminal operations):

  • 中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream。
  • 结束操作会触发实际计算，计算发生时会把所有中间操作积攒的操作以pipeline的方式执行，这样可以减少迭代次数。计算完成之后stream就会失效。

虽然大部分情况下stream是容器调用Collection.stream()方法得到的，但stream和collections有以下不同：

  • 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
  • 为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
  • 惰式执行。stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
  • 可消费性。stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。

一、获取stream

// 1、数组
String[] arr = new String[]{"ab", "cd", "ef"};
Stream<String> arrStream = Arrays.stream(arr);
// 2、集合
List<String> list = Arrays.asList("ab", "cd", "ef");
Stream<String> colStream = list.stream();
// 3、值
Stream<String> stream = Stream.of("ab", "cd", "ef");

二、stream方法使用

user类

public class User {
	private String name;
	private int age;

	public User() {
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

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

测试数据：

List<User> list = Arrays.asList(
	// name，age
	new User("张三", 11), 
	new User("王五", 20), 
	new User("王五", 91), 
	new User("张三", 8), 
	new User("李四", 44), 
	new User("李四", 44), 
	new User("李四", 44)
);

1、forEach() 使用该方法迭代流中的每个数据

// java 8 前
System.out.println("java 8 前");
for (User user : list) {
	System.out.println(user);
}
// java 8 lambda
System.out.println("java 8 lambda");
list.forEach(user -> System.out.println(user));

// java 8 stream lambda
System.out.println("java 8 stream lambda");
list.stream().forEach(user -> System.out.println(user));

java 8 前
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
java 8 lambda
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
java 8 stream lambda
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}

2、sorted() 使用该方法排序数据

System.out.println("-----排序前-----");
list.forEach(user -> System.out.println(user));
System.out.println("-----排序后-----");
// java 8 前
System.out.println("java 8 前");
Collections.sort(list, new Comparator<User>() {
	@Override
	public int compare(User o1, User o2) {
		return Integer.valueOf(o1.getAge()).compareTo(Integer.valueOf(o2.getAge()));
	}
});
for (User user : list) {
	System.out.println(user);
}
// java 8 stream 方法引用
System.out.println("java 8 stream 方法引用");
list.stream().sorted(Comparator.comparing(User::getAge)).forEach(user -> System.out.println(user));

-----排序前-----
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
-----排序后-----
java 8 前
User{name=‘张三’, age=8}
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘王五’, age=91}
java 8 stream 方法引用
User{name=‘张三’, age=8}
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘王五’, age=91}

3、filter()：使用该方法过滤

// 输出年龄大于50的人
System.out.println("-----过滤前-----");
list.forEach(user -> System.out.println(user));
System.out.println("-----过滤后-----");
// java 8 前
System.out.println("java 8 前");
for (User user : list) {
	if (user.getAge() > 50) {
		System.out.println(user);
	}
}
// java 8 stream
System.out.println("java 8 stream");
list.stream().filter((User user) -> user.getAge() > 50).forEach(user -> System.out.println(user));

-----过滤前-----
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
-----过滤后-----
java 8 前
User{name=‘王五’, age=91}
java 8 stream
User{name=‘王五’, age=91}

4、limit()：使用该方法截断

// 从第三个开始截断，只输出前三个
System.out.println("-----截断前-----");
list.forEach(user -> System.out.println(user));
System.out.println("-----截断后-----");
// java 8 前
System.out.println("java 8 前");
for (int i = 0; i < 3; i++) {
	System.out.println(list.get(i));
}
// java 8 stream
System.out.println("java 8 stream");
list.stream().limit(3).forEach(user -> System.out.println(user));

-----截断前-----
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
-----截断后-----
java 8 前
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
java 8 stream
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}

5、skip()：与limit互斥，使用该方法跳过元素

// 跳过前三个元素，从第四个开始输出
System.out.println("-----跳过前-----");
list.forEach(user -> System.out.println(user));
System.out.println("-----跳过后-----");
// java 8 前
System.out.println("java 8 前");
for (int i = 3; i < list.size(); i++) {
	System.out.println(list.get(i));
}
// java 8 stream
System.out.println("java 8 stream");
list.stream().skip(3).forEach(user -> System.out.println(user));

-----跳过前-----
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
-----跳过后-----
java 8 前
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
java 8 stream
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}

6、distinct()：使用该方法去重，注意：必须重写对应泛型的hashCode()和equals()方法

// 因为Arrays.asList() 返回的是Arrays的内部类ArrayList，操作remove，add会报错
List<User> users = new ArrayList(list);
// 为list去除重复数据
System.out.println("-----去重前-----");
list.forEach(user -> System.out.println(user));
System.out.println("-----去重后-----");
// java 8 前
System.out.println("java 8 前");
for (int i = 0; i < users.size() - 1; i++) {
	for (int j = users.size() - 1; j > i; j--) {
		if (users.get(j).getAge() == users.get(i).getAge()
				&& users.get(j).getName().equals(users.get(i).getName())) {
			users.remove(i);
		}
	}
}
for (User user : users) {
	System.out.println(user);
}
// java 8 stream
System.out.println("java 8 stream");
users.stream().distinct().forEach(user -> System.out.println(user));

-----去重前-----
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
-----去重后-----
java 8 前
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
java 8 stream
User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}

根据上述方法，完成去重+按照年龄大于40以后从小到大+只取前二

// 因为Arrays.asList() 返回的是Arrays的内部类ArrayList，操作remove，add会报错
List<User> users = new ArrayList(list);
list.stream().distinct().filter(user -> user.getAge() > 40)
		.sorted(Comparator.comparing(User::getAge)).limit(2)
		.forEach(user -> System.out.println(user));

User{name=‘李四’, age=44}
User{name=‘王五’, age=91}

7、max，min，sum，avg，count

IntSummaryStatistics num = list.stream().mapToInt(u -> u.getAge()).summaryStatistics();
System.out.println("总共人数：" + num.getCount());
System.out.println("平均年龄：" + num.getAverage());
System.out.println("最大年龄：" + num.getMax());
System.out.println("最小年龄：" + num.getMin());
System.out.println("年龄之和：" + num.getSum());

总共人数：7
平均年龄：37.42857142857143
最大年龄：91
最小年龄：8
年龄之和：262

8、map()：接收一个方法作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

// 只输出所有人的年龄
list.stream().forEach(user -> System.out.println(user));
System.out.println("映射后----->");
List<Integer> ages = list.stream().map(user -> user.getAge()).collect(Collectors.toList());
ages.forEach(age -> System.out.println(age));

// 小写转大写
List<String> words = Arrays.asList("aaa", "vvvv", "cccc");
System.out.println("全部大写---->");
List<String> collect = words.stream().map(str -> str.toUpperCase()).collect(Collectors.toList());
collect.forEach(s -> System.out.println(s));

User{name=‘张三’, age=11}
User{name=‘王五’, age=20}
User{name=‘王五’, age=91}
User{name=‘张三’, age=8}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
User{name=‘李四’, age=44}
映射后----->
11
20
91
8
44
44
44
全部大写---->
AAA
VVVV
CCCC

9、flatMap()：对每个元素执行mapper指定的操作，并用所有mapper返回的Stream中的元素组成一个新的Stream作为最终返回结果，通俗易懂就是将原来的stream中的所有元素都展开组成一个新的stream

// 创建一个 装有两个泛型为integer的集合
Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5));
// 将两个合为一个
Stream<Integer> integerStream = stream
		.flatMap((Function<List<Integer>, Stream<Integer>>) integers -> integers.stream());
// 为新的集合
List<Integer> collect = integerStream.collect(Collectors.toList());
System.out.println("新stream大小:" + collect.size());
System.out.println("-----合并后-----");
collect.forEach(o -> System.out.println(o));

新stream大小:5
-----合并后-----
1
2
3
4
5

10、findFirst() ：使用该方法获取第一个元素

User user = list.stream().findFirst().get();
System.out.println(user);

User{name=‘张三’, age=11}

11、reduce() ：多面手

reduce 操作可以实现从一组元素中生成一个值
sum()、max()、min()、count()等都是reduce操作，将他们单独设为函数只是因为常用

例如：找到年龄最大的

Optional<User> reduce = list.stream().reduce((s1, s2) -> s1.getAge() > s2.getAge() ? s1 : s2);
User user = reduce.get();
System.out.println(user);

Optional<User> max = list.stream().max(Comparator.comparing(User::getAge));
System.out.println(max.get());

User{name=‘王五’, age=91}
User{name=‘王五’, age=91}

例如：求所有人的年龄和

// 求年龄之和
Integer reduce = list.stream().reduce(0, // 该参数为初始值
    (integer, user) -> integer + user.getAge(), // 该参数为累加器，新元素如何累加
    (integer, integer2) -> integer + integer2);// 多个部分如何合并
System.out.println(reduce);

262

12、使用collect()做字符串join

// 使用Collectors.joining()拼接字符串
Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六");
Stream<String> stream2 = Stream.of("张三", "李四", "王五", "赵六");
String s = stream.collect(Collectors.joining()); // 张三李四王五赵六
String s1 = stream1.collect(Collectors.joining("-")); // 张三-李四-王五-赵六
String s2 = stream2.collect(Collectors.joining("-", "(", ")")); // (张三-李四-王五-赵六)
System.out.println(s);
System.out.println(s1);
System.out.println(s2);

张三李四王五赵六
张三-李四-王五-赵六
(张三-李四-王五-赵六)

参考文献：https://github.com/CarpenterLee/JavaLambdaInternals/blob/master/4-Streams%20API(I).md

一个兴趣使然的无名小号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
stream流排序
qq_36763236的博客
12-21 2万+
List 倒序排列 List<Double> salesData = new ArrayList<>(); Collections.reverse(salesData); java8 stream多字段排序 List<类> rankList = new ArrayList<>(); 代表某个集合 //返回 对象集合以类属性一升序排序 rankList.stream().sorted(Comparator.comparing(类::属性一));
java stream使用指南-------sorted使用及进阶
热门推荐
ql_7256的博客
05-02 2万+
文章目录引入数据准备1. 依赖2. 相关类初体验基础用法1. 逆序几种写法2. 多级排序3. null值处理进阶1. 本质2. 拓展 引入 用了一段时间的jdk8的新特性，lambda表达式、方法引用、stream流，用起来是真的顺手啊，最近碰到了一个排序的问题，引发了一些思考，然后就写了这篇博客，归纳总结sorted的用法，在做笔记的同时也让自己有更深的理解。 数据准备 1. 依赖 我喜欢用google的集合工具类，让我构造测试数据更简便。然后也用lombok，依赖： <!--goo
java8 Stream字段排序sorted()
一生编程，快乐编程
09-18 2989
多个字段排序，先对第一个排序字段排序，当第一个排序字段相同时，会使用第二个排序字段进行排序。Comparator.reverseOrder()是对属性按照降序进行排序，Comparator.reverseOrder()更好理解，也更好用些。如果是三个以上的字段排序，就继续用 thenComparing 连接。java8中，可以用Stream流的sorted()进行排序。reversed()在多字段排序时，很容易混乱，不建议使用。比较原始的写法，自己手写排序规则。reversed()是得到排序结果后再反转，
Stream.sorted
qq_43842093的博客
11-22 921
Stream支持并非操作，不存在Stream并发时，上边的方法可以实现分组后排序操作，存在Stream并发时就不行，会乱。然后就是两个并行流的排序，因为是并行流因此无法得到固定的顺序，因此在并行流中使用这两个方法一定要慎重。这两个方法都是有状态的中间操作，对于有序流排序结果是固定的，对于无序流则无法保证得到固定的排序结果。无参的方法按照自然顺序排序，有参数的方法根据自定义的比较器进行比较排序。这行代码是根据自定义的比较器进行排序，这里定义的作用就是逆序排序。对流中元素进行排序，排序后的元素放到新流中返回。
Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
最新发布
Tony666688888的博客
04-07 4359
java8 Stream中sorted排序
JDK1.8的linux版本
03-26
**JDK 1.8 Linux 版本详解** Java Development Kit (JDK) 是Java编程语言的核心组件，它为开发者提供了编译、调试和运行Java应用程序所需的全部工具。JDK 1.8是Oracle公司发布的一个重要版本，包含了对Java语言的多...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
通过使用这些新特性，开发者可以编写出更加优雅、高效的代码。了解并熟练掌握这两个特性，对于提升Java开发能力至关重要。在实际工作中，我们可以通过不断实践和应用，逐渐掌握它们的精髓，让代码更具表现力和可维护...
jdk1.8中文无懈可击版
04-23
JDK 1.8，也被称为Java 8，是Java历史上的一个重要版本，它引入了许多新特性，对开发者的工作流程产生了深远影响。 **1. Lambda表达式** Java 8最显著的变化之一是引入了Lambda表达式，这使得函数式编程在Java中变...
Java8 Stream详解.md
06-30
主要描述JDK8新特性Stream流的使用，有完整的笔记和配套的练习代码，Stream中的“中间操作符”，“终止操作符”都讲到了，简单易懂。有配套的笔记+代码，东西非常详细，哪怕初学者也可以看着文档做出来。
java8新特性视频详解
03-28
JDK8 新特性 文档笔记：https://blog.csdn.net/jiabaoyu114/article/details/123785733 1、简介 2、接口新特性应用 2.1、default方法设计及实现 2.2、接口中的static方法设计及实现 2.3、函数式接口设计及实现 3...
Stream sorted的使用以及注意事项
apple_51491580的博客
04-14 3961
1.sorted作用 返回由此流的元素组成的流，按照自然顺序排序。简单的来说就是排序，可以自定义排序方法，也可以使用sorted自带的。 2.sorted使用 2.1自然排序 List<Integer> list2 = new ArrayList<Integer>(); list2.add(15); list2.add(10); list2.add(5); Object[] object = list2.stream().sorted().toArray(); for
J中stream流（中间方法：filter、limit、skip、distinct（依赖hashCode和equals方法）、concat（合并Stream流）、map（转换数据类型、split））
Jackmat的博客
03-05 134
filter：注意点1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程。当一个数组中是引用数据类型的数组时，我们也可以使用Stream.of方法来获取Stream流。注意点2：修改Stream流中的数据，不会影响原来集合或者数组中的数据。1.遍历单列集合：（调用继承于Collection中的stream方法）3.遍历数组：（调用Arrays工具类中的stram方法）skip(将要调过元素的个数)：获取跳过之后的元素。limit(将要获取元素的个数)：获取前几个元素。
Stream - forEach、forEachOrdered
06-21 553
voidforEach​(Consumer<? superT>action) voidforEachOrdered​(Consumer<? superT>action) 这两个方法功能类似，使用方法一致，区别就在于并行处理的时候forEachOrdered是严格按照流中元素顺序执行，而forEach是无序的因此效率高一点。 这里就那forEach为例进行说明； forEach方法作用就是遍历流中元素对元素执行参数函数，这个方法对于集合中是java基本数据类型的...
JDK 8 新特性：Stream
qq_43429919的博客
04-08 223
文章目录JDK 8 新特性之StreamLambdaStream管道管道源中间操作结束操作Stream Api常用操作List to List1. List< Object > To List< Object >List to Map1. List< Object > To MapJDK 8 新特性之Stream Lambda 参考文档： java.util.stream Lambda也是一种匿名方法，将方法作为参数进行传递的编程思想 优点：代码简洁 缺点：可读性差；不
stream流详解(JDK1.8的特性)
卷NM呢！不干了！
06-10 5015
Stream流 一 : Stream流的介绍 二 : 获取Stream流的方式 三 : Stream流中的常用方法 1.forEach（终结方法） 2.过滤：filter 3.映射(转换)：map 4.统计个数：count（终结方法） 5.取用前几个（截取）：limit 6.跳过前几个元素：skip 7.组合（合并流）：concat 8.筛选：distinct 9.映射(打开后再转换)：flatMap 10.自然排序：sorted 11.定制排序：sorted(Comparator com) 12.检测匹配
Java 用stream流取出个人信息
Lu程序员之路的博客
10-17 251
Java 用stream流取出个人信息
JDK1.8新特性总结 - 篇三(并行流与顺序流)
爱喝咖啡的程序员的博客
05-27 1818
一. 并行流与串行流 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块中的流。JDK8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream Api可以声明式的通过parallel()与sequential()在并行流和串行流(又被称作“顺序流”)之间进行切换。 二. Fork/Join框架 Fork/Join框架就是...
Java 关于jdk1.8的Stream流的一些使用总结
Shaochen_的博客
08-17 7485
Java 关于jdk1.8的Stream流的一些使用总结 最近看了一些关于jdk1.8新出的stream流的一些使用方式，发现很多东西在开发中能节省不少的代码量，并且十分方便，所以在这里做一些总结。 1 . 使用场景 下面都是自己的一些理解，如果有错误，请多指教； stream流主要对集合进行操作，在真正的项目中有许多操作结合这样的场景，比如说我们从数据库查询出来的数据，...
java1.8新特性之Stream(流式思想）
qq_42051855的博客
08-26 428
java1.8新特性之Stream(流式思想） 文章目录前言一、使用流式思想的好处。二、Stream（流式思想）详解1.对Collecton集合进行筛选：2.map集合3.数组 前言 流式思想的出现主要得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 以下是本篇文章正文内容. 一、使用流式思想的好处。 使用流式思想能够极大地简化我们的代码，提高代码的可读性以及美观性。流式思想主要运用于对于集合的操作。 二、Stream（流式思想）详解 1.对Co
JDK1.8新特性详解：Lambda、Stream API与时间日期API
"本文概述了JDK1.8的关键特性，包括Lambda表达式...JDK1.8的这些新特性极大地提升了Java的开发效率和程序性能，使得代码更加简洁、高效，并提供了更好的并发处理能力。对于开发者来说，理解和掌握这些新特性至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值