Lambda系列教材（三）- java 集合的聚合操作

工具版本兼容问题

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

16分30秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

步骤 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是不一样的概念。

步骤 3 :

管道源

edit 顶折

纠问

把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));
		
	}
}

步骤 4 :

中间操作

edit 顶折

纠问

每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
中间操作比较多，主要分两类
对元素进行筛选和转换为其他形式的流
对元素进行筛选：
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator<T>) 指定排序
limit 保留
skip 忽略
转换为其他形式的流
mapToDouble 转换为double的流
map 转换为任意类型的流

Hero.java
TestAggregate.java

代码行数较多，请点击查看

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));
         
    }
}

步骤 5 :

结束操作

edit 顶折

纠问

当进行结束操作后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。结束操作不会返回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 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

首选准备10个Hero对象，hp和damage都是随机数。
分别用传统方式和聚合操作的方式，把hp第三高的英雄名称打印出来

步骤 7 :

答案-聚合操作

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

4分2秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

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);
        
    }
}

Lambda系列教材（二）- 方法引用

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

问答区域

2024-07-12 利用Stream及Lambda聚合操作实现数据筛选

虚心求学

关于 JAVA 中级-Lambda-聚合操作的提问

初始化后的数据 [Hero6，994，878][Hero1，957，24][Hero7，911，181][Hero3，822，587][Hero2，541，343][Hero9，527，779][Hero0，304，919][Hero4，279，210][Hero8，228，978][Hero5，141，69] 查询条件 hp 第三高普通方法筛选后的数据： Hero7 管道流的方法筛选后的数据 Hero7

public static void main(String[] args) {
		List<Hero>hs = getHeros(10);
		System.out.println("初始化后的数据");
		hs.stream()
		.sorted(((h1,h2)->-Float.compare(h1.hp,h2.hp)))
		.forEach(p->System.out.print(p));
		System.out.println();
		System.out.println("查询条件  hp 第三高");
		System.out.println("普通方法筛选后的数据：");
		System.out.println(NormalFind(hs).name);
		System.out.println();
		System.out.println("管道流的方法筛选后的数据");
		hs.stream()
		.sorted(((h1,h2)->-Float.compare(h1.hp,h2.hp)))
		.limit(3)
		.skip(2)
		.forEach(p->System.out.println(p.name));
		
		
	}	
	public static Hero NormalFind(List<Hero>hs)
	{
		hs.sort((h1,h2)->{
			if(h1.hp<h2.hp)return 1;
			else if(h1.hp==h2.hp)return 0;
			else return -1;
				});
		return hs.get(2);
	}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-06-20 答案

大D

关于 JAVA 中级-Lambda-聚合操作的提问

答案

 Random r = new Random();
        List<Hero> list =new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(new Hero("hero"+i,r.nextInt(100),r.nextInt(100)));
        }
        System.out.println("遍历集合中的每个数据");
        list.stream().forEach(h -> System.out.println(h));
        Comparator<Hero> cp=new Comparator<Hero>() {
            @Override
            public int compare(Hero o1, Hero o2) {

                return o1.hp>=o2.hp?1:-1;
            }
        };
        Collections.sort(list,cp);
        System.out.println("第三");
        System.out.println(list.get(2));
        Hero h=list.stream().sorted((h1,h2) ->h1.hp>=h2.hp?1:-1).skip(2).findFirst().get();
        System.out.println(h);

1 个答案

wr123
答案时间：2023-11-28

package collection; import comparator.Hero; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Random; public class TestCollection { public static void main(String[] args) { Random r =new Random(); List<Hero> heros = new ArrayList<Hero>(); for (int i = 0; i < 10; i++) { //通过随机值实例化hero的hp和damage heros.add(new Hero("hero "+ i, r.nextInt(100), r.nextInt(100))); } System.out.println("初始化后的集合："); System.out.println(heros); Collections.sort(heros,Hero::CompareHero); System.out.println(heros); System.out.println("通过传统方式找出来的hp第三高的英雄名称是:" +heros.get(7).getName()); 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); } }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-12-15 懒操作是什么概念，有没有知道的

JacobNie98

关于 JAVA 中级-Lambda-聚合操作 -Stream和管道的概念的提问

如题，懒操作是什么

1 个答案

巧夺天工
答案时间：2024-03-18

其实就是联试调用，调用这个方法，返回的还是刚刚那个对象；可以把类属性set的方法改成这样，就可以一次性全部调用，全部设置 Hero hero = new Hero(); hero.setName("可可"); hero.setHp(100); Hero hero2 = new Hero(); hero2.setName("可可").setHp(100);

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-12-15 聚合操作意思是都不用预先申明一个接口了，可以这样理解吧？

JacobNie98

关于 JAVA 中级-Lambda-聚合操作 -Stream和管道的概念的提问

聚合操作意思是都不用预先申明一个接口了不用像前面lambda表达式里面先声明一个接口，接口里一个方法

1 个答案

hoolich
答案时间：2022-04-19

/*首选准备10个Hero对象，hp和damage都是随机数。分别用传统方式和聚合操作的方式，把hp第三高的英雄名称打印出来*/ package lambda; import charactor.Hero; import java.util.*; public class TestAggregate { public static void main(String[] args) { //首选准备10个Hero对象，hp和damage都是随机数。 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))); } //匿名类 Comparator<Hero> c = new Comparator<Hero>() { @Override public int compare(Hero h1, Hero h2) { return h2.hp>=h1.hp?1:-1; } }; Collections.sort(heros,c); Hero hero=heros.get(2); System.out.println("通过传统方式找出来的hp第三高的英雄名称是:"+hero.name); heros .stream() .sorted((h1,h2)->h2.hp>=h1.hp?1:-1) .limit(3) .skip(2) .forEach(h->System.out.print("通过聚合操作方式找出来的hp第三高的英雄名称是:"+h.name)); } }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-12-15 聚合操作意思是都不用预先申明一个接口了，可以这样理解吧？

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 31 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢

关于 JAVA 中级-Lambda-聚合操作的提问

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 578362961

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

上传截图