Java8新特性之Stream流实战

最新推荐文章于 2023-07-21 13:31:10 发布
最新推荐文章于 2023-07-21 13:31:10 发布
阅读量3.7k 收藏 56
点赞数 19
分类专栏： # Java8新特性 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18948359/article/details/86527799
版权

Stream 流的各种实战

学习了 Stream 之后，我们会遇到一个问题，就是如何使用Stream 流来进行我们的数据处理。

准备工作

创建一个 Employ 类

public class Employ{
	
	private String id;
	private String name;
	private int age;
	private String dept;
	private int gender;
	
	public Employ(){
	}
	
	public Employ(String id, String name, int age, String dept, int gender){
		this.id = id;
		this.name = name;
		this.age = age;
		this.dept = dept;
		this.gender = gender;
	}
	
	public void getInfo(){
		System.out.println("编码:"+this.id+"，名称:"+ this.name +"， 年龄:"+ this.age +"， 部门:"+ this.dept + "，性别:" +this.gender);
	}
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getDept() {
		return dept;
	}
	public void setDept(String dept) {
		this.dept = dept;
	}
	public int getGender() {
		return gender;
	}
	public void setGender(int gender) {
		this.gender = gender;
	}
}

forEach()、limit()、skip() 方法

import java.util.*;

public class TestDemo {

	public static void main(String[] args) {

		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1)	
		);
		
		// forEach 方法
		employList.stream().forEach(Employ :: getInfo);
		
		// limit 方法
		System.out.println("+++++++++++++++++++ limit方法 +++++++++++++++++++++");
		employList.stream().limit(3).forEach(Employ :: getInfo);
		
		// skip 与 limit 方法， 跳过第一个，然后向后取3个
		System.out.println("+++++++++++++++++++ skip 方法与 limit+++++++++++++++++++++");
		employList.stream().skip(1).limit(3).forEach(Employ :: getInfo);
		
	}
}

控制台输出

编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
编码:0002，名称:李四， 年龄:15， 部门:COO，性别:1
编码:0003，名称:王五， 年龄:26， 部门:HR，性别:1
编码:0004，名称:赵六， 年龄:34， 部门:COO，性别:1
编码:0005，名称:李刚， 年龄:55， 部门:HR，性别:1
编码:0006，名称:李华， 年龄:23， 部门:CTO，性别:1
编码:0007，名称:王麻子， 年龄:30， 部门:HR，性别:1
+++++++++++++++++++ limit方法 +++++++++++++++++++++
编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
编码:0002，名称:李四， 年龄:15， 部门:COO，性别:1
编码:0003，名称:王五， 年龄:26， 部门:HR，性别:1
+++++++++++++++++++ skip 方法与 limit+++++++++++++++++++++
编码:0002，名称:李四， 年龄:15， 部门:COO，性别:1
编码:0003，名称:王五， 年龄:26， 部门:HR，性别:1
编码:0004，名称:赵六， 年龄:34， 部门:COO，性别:1

distinct()、 Collectors.toSet()、Collectors.toList() 方法

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TestDemo {

	public static void main(String[] args) {

		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1));

		// 使用 distinct 来去重
		Stream<String> stream = employList.stream().map(Employ::getDept).distinct();
		List<String> nameList = stream.collect(Collectors.toList()); // 将数据转为list
		nameList.forEach(System.out::println);
		System.out.println( "==========================" );
		
		// 使用 Collectors.toSet() 无序+去重
		Stream<String> stream1 = employList.stream().map(Employ::getDept).distinct();
		Set<String> nameList1 = stream1.collect(Collectors.toSet());
		nameList1.forEach(System.out::println);
		System.out.println( "==========================" );
		
		// 使用 Collectors.toList() 转换为 list
		Stream<String> stream2=  employList.stream().map(i->i.getName());
        List<String> nameList2= stream2.collect(Collectors.toList());
        nameList2.forEach(System.out::println);
	}
}

sorted() 排序，以及 reversed() 倒置

import java.util.*;

public class TestDemo {
	
	public static void main(String[] args) {
        // 创建数据
		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1)	
		);
		
		// sorted 方法排序
		employList.stream().sorted(Comparator.comparing( employ -> employ.getAge())).forEach(Employ :: getInfo);
		
		System.out.println("=====================================================");
		
		// reversed 方法倒置排序
		employList.stream().sorted(Comparator.comparing(Employ:: getAge).reversed()).forEach(Employ :: getInfo);
	}
}

控制台输出

编码:0002，名称:李四， 年龄:15， 部门:COO，性别:1
编码:0006，名称:李华， 年龄:23， 部门:CTO，性别:1
编码:0003，名称:王五， 年龄:26， 部门:HR，性别:1
编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
编码:0007，名称:王麻子， 年龄:30， 部门:HR，性别:1
编码:0004，名称:赵六， 年龄:34， 部门:COO，性别:1
编码:0005，名称:李刚， 年龄:55， 部门:HR，性别:1
=====================================================
编码:0005，名称:李刚， 年龄:55， 部门:HR，性别:1
编码:0004，名称:赵六， 年龄:34， 部门:COO，性别:1
编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
编码:0007，名称:王麻子， 年龄:30， 部门:HR，性别:1
编码:0003，名称:王五， 年龄:26， 部门:HR，性别:1
编码:0006，名称:李华， 年龄:23， 部门:CTO，性别:1
编码:0002，名称:李四， 年龄:15， 部门:COO，性别:1

map() 方法与 max()、min()、count() 的用法

import java.util.*;
import java.util.stream.Stream;

public class TestDemo {

	public static void main(String[] args) {

		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1));

		// 使用 map 方法以及 max 方法获取年龄最大的对象年龄
		Optional<Integer> opAgeMax = employList.stream().map(Employ::getAge).max((x, y) -> x.compareTo(y));
		if (opAgeMax.isPresent()) {
			System.out.println("max:" + opAgeMax.get()); // max:55
		} else {
			System.out.println("max:没找到");
		}

		// 使用 min 方法获取 年龄最小的对象年龄
		Optional<Integer> opAgeMin = employList.stream().map(Employ::getAge).min((x, y) -> x.compareTo(y));
		if (opAgeMin.isPresent()) {
			System.out.println("min:" + opAgeMin.get()); // min:15
		} else {
			System.out.println("min:没找到");
		}

		// count 方法
		long count = employList.stream().count(); // 计算有几个值，和 employList.size() 一样
		System.out.println(count); // 7
		System.out.println("==================");

		// 将数据按照年龄排序
		Stream<Integer> stream = employList.stream().map(employ -> employ.getAge()).sorted();
		stream.forEach(i -> System.out.println(i));
	}
}

控制台输出

max:55
min:15
7
===========================
15
23
26
30
30
34
55

DoubleSummaryStatistics 对数据的操作

import java.util.*;
import java.util.stream.Collectors;

public class TestDemo {

	public static void main(String[] args) {

		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1));

		
		DoubleSummaryStatistics dss= employList.stream().collect(Collectors.summarizingDouble(Employ::getAge));
		System.out.println("max:"+dss.getMax());		// max:55.0
        System.out.println("min:"+dss.getMin());		// min:15.0
        System.out.println("sum:"+dss.getSum());		// sum:213.0
        System.out.println("average:"+dss.getAverage());	// average:30.428571428571427
        System.out.println("count:"+dss.getCount());		// count:7
	}
}

使用 reduce() 方法

下面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，请留意这个区别。

import java.util.stream.Stream;

public class Reduce {

	public static void main(String[] args) {

		// 连接字符串
		String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
		System.out.println(concat); // ABCD

		// 过滤，字符串连接
		concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);
		System.out.println(concat);

		// 求最小值
		double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
		System.out.println(minValue); // -3.0

		// 求和， 有起始值
		int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
		System.out.println(sumValue); // 10

		// 求和， 无起始值
		sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
		System.out.println(sumValue); // 10
	}
}

groupingBy 分组

import java.util.*;
import java.util.stream.Collectors;

public class TestDemo {

	public static void main(String[] args) {

		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1));

		// 使用分组
		Map<String, List<Employ>> map = employList.stream().collect(Collectors.groupingBy(Employ::getDept));
		System.out.println(map);
		
		

		// 进一步对数据进行处理
		map.keySet().forEach( key -> {
			String name = map.get(key).stream().map( Employ::getName ).reduce("|名称：", (x,y) -> {return x+","+y;});
			System.out.println("key:"+key+"|count:"+ map.get(key).size() +name);
		});
	}
}

控制台输出

{COO=[Employ@214c265e, Employ@448139f0],HR=[Employ@7cca494b, Employ@7ba4f24f, Employ@3b9a45b3, Employ@7699a589],CTO=[Employ@58372a00]}
key:COO|count:2|名称：,李四,赵六
key:HR|count:4|名称：,张三,王五,李刚,王麻子
key:CTO|count:1|名称：,李华

anyMatch()、findAny()、findFirst() 方法

findAny、findFirst 的返回值都是 Optional 类型，避免了 Stream 序列为空时返回 null。

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TestDemo {

	public static void main(String[] args) {

		List<Employ> employList = Arrays.asList(new Employ("0001", "张三", 30, "HR", 1),
				new Employ("0002", "李四", 15, "COO", 1), new Employ("0003", "王五", 26, "HR", 1),
				new Employ("0004", "赵六", 34, "COO", 1), new Employ("0005", "李刚", 55, "HR", 1),
				new Employ("0006", "李华", 23, "CTO", 1), new Employ("0007", "王麻子", 30, "HR", 1));

		// 使用 anyMatch 来查找
		boolean bEixst = employList.stream().anyMatch(i -> i.getName().equals("李四"));
		System.out.println(bEixst);		// true
		
		// 用来查找任意一个对象
		Optional<Employ> opWorker=  employList.stream().findAny();
        if(opWorker.isPresent()){
            System.out.println(opWorker.get());	// Employ@4eec7777
            opWorker.get().getInfo();			// 编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
        }
        else {
            System.out.println("没找到");
        }
        System.out.println("==========================");
        
        // 使用 filter 过滤数据
        Stream<Employ> streamEmploy = employList.stream().filter( employ -> employ.getDept().equals("HR"));
        List<Employ> filterEmployList = streamEmploy.collect(Collectors.toList());
        filterEmployList.forEach( Employ :: getInfo );
        
        System.out.println("==========================");
        Optional<Employ> opEmploy = employList.stream().filter( employ -> employ.getDept().equals("HR")).findFirst();
        System.out.println(opWorker.get());
	}
}

控制台输出：

true
Employ@4eec7777
编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
==========================
编码:0001，名称:张三， 年龄:30， 部门:HR，性别:1
编码:0003，名称:王五， 年龄:26， 部门:HR，性别:1
编码:0005，名称:李刚， 年龄:55， 部门:HR，性别:1
编码:0007，名称:王麻子， 年龄:30， 部门:HR，性别:1
==========================
Employ@4eec7777
Wayfreem
关注
  • 19
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
Java8-Stream使用实战
wyd987100的博客
06-12 1187
Java8-Stream使用实战结合了我们自己的业务写了些简单的样例，绝大部分用到了Lamada表达式，也是Java8的新特性，看不懂的话先自己百度学习下；Stream有相当多的优势，函数式编程的方式条理非常清晰，很多复杂的计算，原来要十几行，现在只需要一行就能搞定，为了清晰，把每一个操作单独成一行了。import java.util.*; import java.util.stream.Colle
JAVA 8 Stream优雅使用结合实战分析
最新发布
2401_84408291的博客
04-18 637
由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！a进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》**[外链图片转存中…(img-uSRMC0ef-1713388978270)]
9张图，32个案例带你轻松玩转Java stream
zjj2006的专栏
01-30 1653
大家好，我是君哥。 Java8 中增加了 Stream 处理，可以配合 Lambda 表达式来使用，让操作集合非常便利。虽然我们平时经常使用 Stream，但用到的方法其实非常少，这篇文章就来完整的介绍 Stream 的使用。 Stream 提供的方法非常多，按照调用当前方法是否结束流处理，可以分为中间操作和结束操作。 对于中间操作，又可以分为有状态的操作和无状态操作： 无状态的操作是指当前元素的操作不受前面元素的影响。 有状态的操作是指当前元素的操作需要等所有元素处理完之后才能进
java8流—stream最全实战
IT_Most的博客
10-22 779
java8流stream最全操作~
java8新特性之stream
庄生晓梦的博客
12-29 270
上一章我们讲了java8新特性之lambda表达式，作为一个匿名函数，极大的简化了代码。今天我们来聊聊java8的另一个可以简化代码的特性——stream。 lambda表达式是stream的基础，建议先学习lambda表达式在学习stream相关知识。 1、首先，stream是什么？ 刚接触可能觉得stream和对文件进行操作的io流类似，但实际上这两者一点关系都没有。 stream是一...
Java流Stream实战-常用api案例解析
weixin_43805705的博客
03-02 612
本文介绍java 8 Stream流的常用高频api，通过实战级别的案例进行演示。实现结合实际业务、开发需要来应用技术，不让技术讲解枯燥无味，带来技术落地成生产力的价值。
java8新特性之stream的collect实战教程
08-18
Java8新特性之Stream的Collect实战教程 Java8中引入了Stream API，它是一个功能强大且灵活的数据处理工具。Stream API提供了一个高效的方式来处理数据，特别是在处理大量数据时。Stream API的核心是collect方法，它...
java8新特性导师讲授精简版
06-06
在本精简版的Java 8新特性导师讲授中，我们将重点关注四大核心概念：Lambda表达式、Stream流、方法引用以及一些其他相关的重要更新。 1. Lambda表达式： Lambda表达式是Java 8中最引人注目的特性之一，它为函数式...
java8新特性实战_Lambda表达式.docx
02-02
java8新特性的简单使用介绍
java8stream源码-lambdasinaction:java8新特性
06-04
java8流源码Java8InAction 该存储库包含 Java 8 实战：Lambdas、Streams 和函数式编程一书中示例和测验的所有源代码。 您可以在这里购买这本书：或在亚马逊上 所有示例的源代码都可以在目录中找到 第 1 章：Java 8：...
Java8中的Stream API实战
实践求真知
03-19 281
一参考 https://www.runoob.com/java/java8-streams.html 二实战 package Stream; import java.util.ArrayList; import java.util.Arrays; import java.util.IntSummaryStatistics; import java.util.List; import...
java8特性-＞流式编程-＞流式编程初步-＞生成流
Jeffrey_oWang的博客
11-02 245
1）流式编程初步 原则：用代码去描述“做什么”而不是“怎么做” 特点：并没有指定操作以什么顺序或者在哪个线程中进行，相比之下的循环就需要指定顺序和线程，因此也丧失优化的机会。 示例： List<String> words = new ArrayList(); long count = words.stream() .filter(w -> w.length()>12) .count(); 对应的循环版本： List<String> words = new A
Java 8 Stream使用实战 看这一篇就够了
q378992971的博客
12-20 288
获取流 [Collection].stream() Stream.of() 终结方法 返回值类型是void 非终结方法 返回值类型是Stream 数组初始化 List<String> list = new ArrayList<>(){"1一", "1测试", "1测试啥", "1厉害了222", "1张三"}; forEach list.stream().forEach(System.out::println); count list.stream().count(); l
JAVA Stream流实战开发经验总结
2301_76607156的博客
03-23 334
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由。
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合
LoveSummer
03-01 2070
用传统的迭代处理也不是很难，但代码就显得冗余了，跟Stream相比高下立判。Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda，给我们操作集合（Collection）提供了极大的便利。StreamStream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。Stream可以由数组或集合创建，对流的操作分为两种：中间操作，每次返回一个新的流，可以有多个。
java Stream类的 超全API及实战总结
qq_25720801的博客
07-20 1218
【代码】java Stream类的 超全API及实战总结。
Java8实战-函数式数据处理-Steam流之收集器
weixin_42872138的博客
07-21 372
Collectors类的静态工厂方法toList 把流中所有对象收集到一个List使用示例:List dishes = menuStream.collect(toList());toSet 把流中所有对象收集到一个Set，删除重复项使用示例:Set dishes = menuStream.collect(toSet());toCollection 把流中所有对象收集到给定的供应源创建的集合。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wayfreem

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

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

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

打赏作者

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

抵扣说明：

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

余额充值