how2j.cn

本视频是解读性视频,所以希望您已经看过了本知识点的内容,并且编写了相应的代码之后,带着疑问来观看,这样收获才多。 不建议一开始就观看视频



16分30秒
本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)



步骤 1 : 传统方式与聚合操作方式遍历数据   
步骤 2 : Stream和管道的概念   
步骤 3 : 管道源   
步骤 4 : 中间操作   
步骤 5 : 结束操作   
步骤 6 : 练习-聚合操作   
步骤 7 : 答案-聚合操作   

步骤 1 :

传统方式与聚合操作方式遍历数据

edit
遍历数据的传统方式就是使用for循环,然后条件判断,最后打印出满足条件的数据

for (Hero h : heros) {
if (h.hp > 100 && h.damage < 50)
System.out.println(h.name);
}

使用聚合操作方式,画风就发生了变化:

heros
.stream()
.filter(h -> h.hp > 100 && h.damage < 50)
.forEach(h -> System.out.println(h.name));
传统方式与聚合操作方式遍历数据
package lambda; import java.util.ArrayList; import java.util.List; import java.util.Random; import charactor.Hero; public class TestAggregate { public static void main(String[] args) { Random r = new Random(); List<Hero> heros = new ArrayList<Hero>(); for (int i = 0; i < 5; i++) { heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100))); } System.out.println("初始化后的集合:"); System.out.println(heros); System.out.println("查询条件:hp>100 && damage<50"); System.out.println("通过传统操作方式找出满足条件的数据:"); for (Hero h : heros) { if (h.hp > 100 && h.damage < 50) System.out.println(h.name); } System.out.println("通过聚合操作方式找出满足条件的数据:"); heros .stream() .filter(h -> h.hp > 100 && h.damage < 50) .forEach(h -> System.out.println(h.name)); } }
步骤 2 :

Stream和管道的概念

edit

heros
.stream()
.filter(h -> h.hp > 100 && h.damage < 50)
.forEach(h -> System.out.println(h.name));

要了解聚合操作,首先要建立Stream管道的概念
Stream 和Collection结构化的数据不一样,Stream是一系列的元素,就像是生产线上的罐头一样,一串串的出来。
管道指的是一系列的聚合操作。

管道又分3个部分
管道源:在这个例子里,源是一个List
中间操作: 每个中间操作,又会返回一个Stream,比如.filter()又返回一个Stream, 中间操作是“懒”操作,并不会真正进行遍历。
结束操作:当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream,但是会返回int、float、String、 Collection或者像forEach,什么都不返回, 结束操作才进行真正的遍历行为,在遍历的时候,才会去进行中间操作的相关判断

注: 这个Stream和I/O章节的InputStream,OutputStream是不一样的概念。
把Collection切换成管道源很简单,调用stream()就行了。

heros.stream()

但是数组却没有stream()方法,需要使用

Arrays.stream(hs)

或者

Stream.of(hs)
package lambda; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Random; import charactor.Hero; public class TestAggregate { public static void main(String[] args) { Random r = new Random(); List<Hero> heros = new ArrayList<Hero>(); for (int i = 0; i < 5; i++) { heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100))); } //管道源是集合 heros .stream() .forEach(h->System.out.println(h.name)); //管道源是数组 Hero hs[] = heros.toArray(new Hero[heros.size()]); Arrays.stream(hs) .forEach(h->System.out.println(h.name)); } }
每个中间操作,又会返回一个Stream,比如.filter()又返回一个Stream, 中间操作是“懒”操作,并不会真正进行遍历。
中间操作比较多,主要分两类
对元素进行筛选 和 转换为其他形式的流
对元素进行筛选:
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator<T>) 指定排序
limit 保留
skip 忽略
转换为其他形式的流
mapToDouble 转换为double的流
map 转换为任意类型的流
中间操作
package charactor; public class Hero implements Comparable<Hero>{ public String name; public float hp; public int damage; public Hero(){ } public String getName() { return name; } public void setName(String name) { this.name = name; } public float getHp() { return hp; } public void setHp(float hp) { this.hp = hp; } public int getDamage() { return damage; } public void setDamage(int damage) { this.damage = damage; } public Hero(String name) { this.name =name; } //初始化name,hp,damage的构造方法 public Hero(String name,float hp, int damage) { this.name =name; this.hp = hp; this.damage = damage; } @Override public int compareTo(Hero anotherHero) { if(damage<anotherHero.damage) return 1; else return -1; } @Override public String toString() { return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n"; } }
package lambda; import java.util.ArrayList; import java.util.List; import java.util.Random; import charactor.Hero; public class TestAggregate { public static void main(String[] args) { Random r = new Random(); List<Hero> heros = new ArrayList<Hero>(); for (int i = 0; i < 5; i++) { heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100))); } //制造一个重复数据 heros.add(heros.get(0)); System.out.println("初始化集合后的数据 (最后一个数据重复):"); System.out.println(heros); System.out.println("满足条件hp>100&&damage<50的数据"); heros .stream() .filter(h->h.hp>100&&h.damage<50) .forEach(h->System.out.print(h)); System.out.println("去除重复的数据,去除标准是看equals"); heros .stream() .distinct() .forEach(h->System.out.print(h)); System.out.println("按照血量排序"); heros .stream() .sorted((h1,h2)->h1.hp>=h2.hp?1:-1) .forEach(h->System.out.print(h)); System.out.println("保留3个"); heros .stream() .limit(3) .forEach(h->System.out.print(h)); System.out.println("忽略前3个"); heros .stream() .skip(3) .forEach(h->System.out.print(h)); System.out.println("转换为double的Stream"); heros .stream() .mapToDouble(Hero::getHp) .forEach(h->System.out.println(h)); System.out.println("转换任意类型的Stream"); heros .stream() .map((h)-> h.name + " - " + h.hp + " - " + h.damage) .forEach(h->System.out.println(h)); } }
当进行结束操作后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream,但是会返回int、float、String、 Collection或者像forEach,什么都不返回,。
结束操作才真正进行遍历行为,前面的中间操作也在这个时候,才真正的执行。
常见结束操作如下:
forEach() 遍历每个元素
toArray() 转换为数组
min(Comparator<T>) 取最小的元素
max(Comparator<T>) 取最大的元素
count() 总数
findFirst() 第一个元素
结束操作
package lambda; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Random; import org.omg.Messaging.SYNC_WITH_TRANSPORT; import charactor.Hero; public class TestAggregate { public static void main(String[] args) { Random r = new Random(); List<Hero> heros = new ArrayList<Hero>(); for (int i = 0; i < 5; i++) { heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100))); } System.out.println("遍历集合中的每个数据"); heros .stream() .forEach(h->System.out.print(h)); System.out.println("返回一个数组"); Object[] hs= heros .stream() .toArray(); System.out.println(Arrays.toString(hs)); System.out.println("返回伤害最低的那个英雄"); Hero minDamageHero = heros .stream() .min((h1,h2)->h1.damage-h2.damage) .get(); System.out.print(minDamageHero); System.out.println("返回伤害最高的那个英雄"); Hero mxnDamageHero = heros .stream() .max((h1,h2)->h1.damage-h2.damage) .get(); System.out.print(mxnDamageHero); System.out.println("流中数据的总数"); long count = heros .stream() .count(); System.out.println(count); System.out.println("第一个英雄"); Hero firstHero = heros .stream() .findFirst() .get(); System.out.println(firstHero); } }
步骤 6 :

练习-聚合操作

edit Or  姿势不对,事倍功半! 点击查看做练习的正确姿势
首选准备10个Hero对象,hp和damage都是随机数。
分别用传统方式和聚合操作的方式,把hp第三高的英雄名称打印出来
步骤 7 :

答案-聚合操作

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

4分2秒 本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)


答案-聚合操作
package lambda; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Random; import charactor.Hero; public class TestAggregate { public static void main(String[] args) { Random r = new Random(); List<Hero> heros = new ArrayList<Hero>(); for (int i = 0; i < 10; i++) { heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100))); } System.out.println("初始化集合后的数据 (最后一个数据重复):"); System.out.println(heros); //传统方式 Collections.sort(heros,new Comparator<Hero>() { @Override public int compare(Hero o1, Hero o2) { return (int) (o2.hp-o1.hp); } }); Hero hero = heros.get(2); System.out.println("通过传统方式找出来的hp第三高的英雄名称是:" + hero.name); //聚合方式 String name =heros .stream() .sorted((h1,h2)->h1.hp>h2.hp?-1:1) .skip(2) .map(h->h.getName()) .findFirst() .get(); System.out.println("通过聚合操作找出来的hp第三高的英雄名称是:" + name); } }


HOW2J公众号,关注后实时获知布最新的教程和优惠活动,谢谢。


问答区域    
2019-04-22 【总结】聚合操作
simple_曹泽



随时欢迎交流、指正,感谢! /* * 1、管道源 * collection.stream()方法 * Arrays.stream(array)方法 * Stream.of(array)方法 */ /* * 2、中间操作,并不会真的进行遍历,而是在3结束操作中才真正得到执行 * 对元素进行筛选: * filter匹配、distinct去除重复(根据equals判断)、sorted自然排序 * sorted(Comparator<T>) 指定排序、limit保留、skip忽略、 * 转换为其他形式的流 : * mapToDouble转换为double的流 * map 转换为任意类型的流 */ /* * 3、stream的结束操作 * forEach() 遍历每个元素 toArray() 转换为数组 min(Comparator<T>) 取最小的元素 max(Comparator<T>) 取最大的元素 count() 总数 findFirst() 第一个元素 */ 更多lambda表达式参考:https://blog.csdn.net/hui1setouxiang/article/details/88418531
package lambda;

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

/*
 * 	需求:1、准备10个学生,名字、成绩均随机
 * 		2、用传统、聚合的方式分别打印出成绩第三的学生名字
 * 	思路:传统方式,对List进行排序,取出第2个元素即可(排序采用lambda表达式)
 * 		聚合方式,先获取Stream,排序,跳过前2,取出第一个元素
 * 	注意:最后的findFirst().get()才能获取到Student对象
 */
public class AggregateLambdaDemo {
	private static List<Student> students = new ArrayList<>();
	private static List<Student> students1 = new ArrayList<>();
	private static List<Student> students2 = new ArrayList<>();

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		initStudents();
		students1.addAll(students);
		students2.addAll(students);

		// 传统方式
		System.out.println(getThirdGradeStudent1());

		// 聚合方式
		System.out.println(getThirdGradeStudent2());
	}

	private static String getThirdGradeStudent2() {
		// TODO Auto-generated method stub
		return students2.
				/*
				 * 1、管道源
				 * collection.stream()方法
				 * Arrays.stream(array)方法
				 * Stream.of(array)方法
				 */
				stream().
		/*
		 * 2、中间操作,并不会真的进行遍历,而是在3结束操作中才真正得到执行
		 * 对元素进行筛选:
		 * filter匹配、distinct去除重复(根据equals判断)、sorted自然排序
		 * sorted(Comparator<T>) 指定排序、limit保留、skip忽略、
		 * 转换为其他形式的流 :
		 * mapToDouble转换为double的流
		 * map 转换为任意类型的流
		 */
				sorted((stu1, stu2) -> 
				Integer.compare(stu2.getGrade(), stu1.getGrade())).
				skip(2).map(stu -> stu.getName()).
				/*
				 * 3、stream的结束操作
				 * forEach() 遍历每个元素
					toArray() 转换为数组
					min(Comparator<T>) 取最小的元素
					max(Comparator<T>) 取最大的元素
					count() 总数
					findFirst() 第一个元素
				 */
				findFirst().get();
	}

	private static String getThirdGradeStudent1() {
		// TODO Auto-generated method stub
		students1.sort((stu1, stu2) -> Integer.compare(stu2.getGrade(), stu1.getGrade()));
		return students1.get(2).getName();
	}

	private static void initStudents() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			String name = i + "号学生";
			int grade = new Random().nextInt(101);
			students.add(new Student(name, grade));
		}

		for (Student stu : students) {
			System.out.printf("%s的成绩为:%d%n", stu.getName(), stu.getGrade());
		}
	}

}

class Student {
	private String name;
	private int grade;

	public Student(String name, int grade) {
		super();
		this.name = name;
		this.grade = grade;
	}

	public String getName() {
		return name;
	}

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

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}
}

							





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2019-04-22 交作业(一),欢迎暂时没思路的朋友来交流参考
simple_曹泽



随时欢迎交流、指正,感谢! /* * 需求:1、准备10个学生,名字、成绩均随机 * 2、用传统、聚合的方式分别打印出成绩第三的学生名字 * 思路:传统方式,对List进行排序,取出第2个元素即可(排序采用lambda表达式) * 聚合方式,先获取Stream,排序,跳过前2,取出第一个元素 * 注意:最后的findFirst().get()才能获取到Student对象 */ 个人学习博客:https://blog.csdn.net/hui1setouxiang 欢迎交流指正,内容是根据版主推荐的《Core Java》写的一些关键章节(内部类、lambda表达式、String类、集合、IO流等)的总结。 祝您生活顺心,学习愉快,共勉~
package lambda;

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

/*
 * 	需求:1、准备10个学生,名字、成绩均随机
 * 		2、用传统、聚合的方式分别打印出成绩第三的学生名字
 * 	思路:传统方式,对List进行排序,取出第2个元素即可(排序采用lambda表达式)
 * 		聚合方式,先获取Stream,排序,跳过前2,取出第一个元素
 * 	注意:findFirst().get()才能获取到Student对象
 */
public class AggregateLambdaDemo {
	private static List<Student> students = new ArrayList<>();
	private static List<Student> students1 = new ArrayList<>();
	private static List<Student> students2 = new ArrayList<>();

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		initStudents();
		students1.addAll(students);
		students2.addAll(students);

		// 传统方式
		System.out.println(getThirdGradeStudent1());

		// 聚合方式
		System.out.println(getThirdGradeStudent2());
	}

	private static String getThirdGradeStudent2() {
		// TODO Auto-generated method stub
		return students2.stream().sorted((stu1, stu2) -> Integer.compare(stu2.getGrade(), stu1.getGrade())).skip(2)
				.findFirst().get().getName();
	}

	private static String getThirdGradeStudent1() {
		// TODO Auto-generated method stub
		students1.sort((stu1, stu2) -> Integer.compare(stu2.getGrade(), stu1.getGrade()));
		return students1.get(2).getName();
	}

	private static void initStudents() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			String name = i + "号学生";
			int grade = new Random().nextInt(101);
			students.add(new Student(name, grade));
		}

		for (Student stu : students) {
			System.out.printf("%s的成绩为:%d%n", stu.getName(), stu.getGrade());
		}
	}

}

class Student {
	private String name;
	private int grade;

	public Student(String name, int grade) {
		super();
		this.name = name;
		this.grade = grade;
	}

	public String getName() {
		return name;
	}

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

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}
}

							





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2019-04-12 作业
2019-04-12 这样不知道行不
2019-03-01 作业
2019-01-29 这句没看懂
2019-01-28 关于 .min((h1,h2)->h1.damage-h2.damage)
2019-01-23 会用了 但是可能不会主动想起来使用
2019-01-21 sorted((h1,h2)->h1.hp>=h2.hp?1:-1)是三元表达式还是Lambda表达式
2018-11-14 关于lambda返回值
2018-11-02 交作业20181102
2018-08-28 作业!!!
2018-08-28 作业!!
2018-08-03 自己写的作业
2018-08-03 作业
2018-07-31 交作业
2018-06-27 常用吗???
2018-06-21 可以说是比传统方式简洁明了了
2018-06-07 提交作业
2018-05-29 对应不上使用场景
2018-04-20 map 转换为任意类型的流 ,具体指啥意思?
2017-12-30 怎么这章那么少人问啊?
2017-08-01 gethp()方法的问题
2017-05-16 关于答案中的聚合方式
2017-05-16 关于答案中的聚合方式




提问之前请登陆
提问已经提交成功,正在审核。 请于 我的提问 处查看提问记录,谢谢
关于 JAVA 中级-Lambda-聚合操作 的提问

尽量提供截图代码异常信息,有助于分析和解决问题。 也可进本站QQ群交流: 1001964108
提问尽量提供完整的代码,环境描述,越是有利于问题的重现,您的问题越能更快得到解答。
对教程中代码有疑问,请提供是哪个步骤,哪一行有疑问,这样便于快速定位问题,提高问题得到解答的速度
在已经存在的几千个提问里,有相当大的比例,是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本,可以节约自己大量的学习时间。 站长把教学中用的软件版本整理了,都统一放在了这里, 方便大家下载: http://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图