Java8之Stream 集合聚合操作集锦（含日常练习Demo）

爱被打了一巴掌 2022-03-01 12:54 192阅读 0赞

Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。

直接上代码：

基础实体类：

![20190322164526598.png][]

练习代码：

public static void main(String[] args) {
    		Student stuA = new Student(1, "A", "M", 184);
    		Student stuB = new Student(2, "B", "G", 163);
    		Student stuC = new Student(3, "C", "M", 175);
    		Student stuD = new Student(4, "D", "G", 158);
    		Student stuE = new Student(5, "A", "M", 158);
    		List<Student> list = new ArrayList<>();
    		list.add(stuA);
    		list.add(stuB);
    		list.add(stuC);
    		list.add(stuD);
    		list.add(stuE);
    		
    		// stream-forEach循环
    		System.out.println("***********stream-forEach***********");
    		list.stream().forEach(stu -> System.out.println("stream-forEach: " + stu.getName()));
    		
    		// stream-filter过滤即执行逻辑
    		System.out.println("***********stream-filter count***********");
    		long count = list.stream().filter(stu -> stu.height > 180).count();
    		list.stream().filter(stu -> stu.height > 180)
    		             .forEach(stu -> System.out.println("stream-filter: " + stu));
    		
    		// Stream-toMap 为了避免key冲突情况，(key1, key2) -> key1 表示冲突时取前者
    		System.out.println("***********Stream-toMap 字段:对象***********");
    		Map<String, Student> maps = list.stream()
    				.collect(Collectors.toMap(Student::getName, Function.identity(), (key1, key2) -> key1));
    		System.out.println("key-对象" + maps);
    		
    		Map<String, Object> newMaps = list.stream()
    				.collect(Collectors.toMap(Student::getName, Student::getHeight, (key1, key2) -> key1));
    		System.out.println("key-字段" + newMaps);
    		
    		// Stream-distinct 去重
    		System.out.println("***********Stream-distinct去重  必须重写equals和hashcode方法***********");
    		list.stream()
    			.distinct()
    			.forEach(b -> System.out.println("Stream-distinct去重  " + b.getName()+ "," + b.getHeight()));
    		
    		list.stream()
    			.filter(StreamUtil.distinctByKey(b -> b.getSex()))
    			.forEach(b -> System.out.println("Stream-distinct指定字段去重  " + b.getName()+ "," + b.getSex())); 
    		
    		// 过滤后得到新集合
    		System.out.println("***********Stream操作后获取聚合集合***********");
    		List<Student> newList = list.stream().filter(stu -> stu.height > 165)
    											 .collect(Collectors.toList());
    		System.out.println("新集合: " + newList);
    		
    		// stream-聚合操作  最大值，最小值
    		System.out.println("**************stream-聚合操作  最大值，最小值************");
    		System.out.println("sum: " + list.stream().mapToDouble(Student::getHeight).sum());
    		System.out.println("max: " + list.stream().mapToDouble(Student::getHeight).max().getAsDouble());
    		System.out.println("min: " + list.stream().mapToDouble(Student::getHeight).min().getAsDouble());
    		System.out.println("avg: " + list.stream().mapToDouble(Student::getHeight).average().getAsDouble());
    		
    		// Stream排序
    		System.out.println("**************stream-聚合操作  排序************");
    		List<Student> collect = list.stream().filter(stu -> stu.getHeight() > 165)
    					 .sorted((e1,e2) -> Float.compare(e1.getHeight(), e2.getHeight()))
    					 .collect(Collectors.toList());
    		System.out.println("stream 排序" + collect);
    	}

指定字段去重：

public class StreamUtil {
    	
    	/**
    	 * 指定字段去重
    	 * @param keyExtractor
    	 * @return
    	 */
    	static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    	        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
    	        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    	} 
    
    }

日常练习Demo：

package com.mine.stream;
    
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * 
     * @author 柯贤铭
     * @date   2019年3月22日
     * @email  806857264@qq.com
     */
    public class TestForStream {
    
    	public static void main(String[] args) {
    		List<Transaction> transactions = null;
    		Trader raoul = new Trader("Raoul", "Cambridge");
    		Trader mario = new Trader("Mario", "Milan");
    		Trader alan = new Trader("Alan", "Cambridge");
    		Trader brian = new Trader("Brian", "Cambridge");
    		
    		transactions = Arrays.asList(
    				new Transaction(brian, 2011, 300),
    				new Transaction(raoul, 2012, 1000),
    				new Transaction(raoul, 2011, 400),
    				new Transaction(mario, 2012, 400),
    				new Transaction(mario, 2012, 710),
    				new Transaction(alan , 2012, 950));
    		// ①找出2011年发生的所有交易， 并按交易额排序（从低到高）
    		// 方式一：
    		Long begin = System.currentTimeMillis();
    		List<Transaction> newTr = transactions.stream().filter(tran -> tran.getYear() == 2011)
    				                              .collect(Collectors.toList());
    		newTr.sort(Comparator.comparing(t -> t.getValue()));
    		Long end = System.currentTimeMillis();
    		System.out.println("耗时: " + (end - begin) + " " + newTr);
    		
    		// 方式二: 差距是35倍左右！
    		Long begin2 = System.currentTimeMillis();
    		List<Transaction> collect = transactions.stream().filter(tran -> tran.getYear() == 2011)
    												 .sorted((e1,e2) -> Integer.compare(e1.getValue(), e2.getValue()))
    												 .collect(Collectors.toList());
    		Long end2 = System.currentTimeMillis();
    		System.out.println("耗时: " + (end2 - begin2) + " " + collect);
    		
    		// ②交易员都在哪些不同的城市工作过？
    		// 方式一:
    		transactions.stream()
    					.filter(StreamUtil.distinctByKey(tran -> tran.getTrader().getCity()))
    					.collect(Collectors.toList())
    					.forEach(t -> System.out.println(t.getTrader().getCity()));
    		
    		// 方式二:
    		List<String> collCityTwo = transactions.stream()
    											.map(e -> e.getTrader().getCity())
    											.distinct()
    											.collect(Collectors.toList());
    		System.out.println("城市为: " + collCityTwo);
    		
    		//③查找所有来自剑桥的交易员，并按姓名排序
    		List<Trader> collPerson = transactions.stream().filter(tran -> tran.getTrader().getCity().equals("Cambridge"))
    											  .map(Transaction::getTrader)
    											  .sorted((e1,e2) -> e1.getName().compareTo(e2.getName()))
    											  .collect(Collectors.toList());
    		System.out.println(collPerson);
    		
    		// ⑤有没有交易员是在米兰工作的？
    		long count = transactions.stream().filter(tran -> tran.getTrader().getCity().equals("Milan")).count();
    		System.out.println("是否有人在米兰工作: " + (count > 0));
    		
    		// ⑥打印生活在剑桥的交易员的所有交易额总和
    		int sum = transactions.stream()
    				              .filter(e -> e.getTrader().getCity().equals("Cambridge"))
    				              .mapToInt(Transaction::getValue)
    				              .sum();
    		System.out.println("总额为: " + sum);
    		
    		// ⑦所有交易中，最高的交易额是多少
    		int max = transactions.stream()
    	              .mapToInt(Transaction::getValue)
    	              .max()
    	              .getAsInt();
    		System.out.println("最大值是: " + max);
    		
    		// ⑧找到交易额最小的交易
    		Transaction transaction = transactions.stream()
    								              .min((e1,e2) -> Integer.compare(e1.getValue(), e2.getValue()))
    								              .get();
    		System.out.println("最小值交易是: " + transaction);
    	}
    }
    
    
    class Trader {
    	private String name;
    	private String city;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getCity() {
    		return city;
    	}
    	public void setCity(String city) {
    		this.city = city;
    	}
    	@Override
    	public String toString() {
    		return "Trader [name=" + name + ", city=" + city + "]";
    	}
    	public Trader(String name, String city) {
    		super();
    		this.name = name;
    		this.city = city;
    	}
    }
    
    class Transaction {
    	private Trader trader;
    	private int year;
    	private int value;
    	public Trader getTrader() {
    		return trader;
    	}
    	public void setTrader(Trader trader) {
    		this.trader = trader;
    	}
    	public int getYear() {
    		return year;
    	}
    	public void setYear(int year) {
    		this.year = year;
    	}
    	public int getValue() {
    		return value;
    	}
    	public void setValue(int value) {
    		this.value = value;
    	}
    	@Override
    	public String toString() {
    		return "Transaction [trader=" + trader + ", year=" + year + ", value=" + value + "]";
    	}
    	public Transaction(Trader trader, int year, int value) {
    		super();
    		this.trader = trader;
    		this.year = year;
    		this.value = value;
    	}
    }

[20190322164526598.png]: /images/20220301/4fe92f31616e45b3a23dadd67d359a80.png