Lambda表达式4:Stream的查找匹配，归纳，收集

￡神魔★判官ぃ 2024-04-20 08:07 88阅读 0赞

### 1、基础介绍 ###

#### 1.1、查找与匹配 ####

> allMatch–检查是否全部匹配  
> anyMatch–检查是否至少匹配一个元素  
> noneMatch–检查是否没有匹配所有元素  
> findFirst–返回第一个元素  
> findAny–返回当前流中的任意元素  
> count–返回流中元素的总个数  
> max–返回流中最大数  
> min–返回流中最小值

List<Student> list = Arrays.asList(
    			new Student(1,"张三",60,Status.a),
    			new Student(2,"李四",70,Status.b),
    			new Student(3,"王五",80,Status.c),
    			new Student(4,"赵六",90,Status.a),
    			new Student(5,"田七",100,Status.a));
    @Test
    public void Test2(){
    	Long count = list.stream().count();
    	System.out.println(count);// 输出：5
    	
    	Optional<Student> optional =
    	list.stream().max((x,y) -> x.getId().compareTo(y.getId()));
    	System.out.println(optional.get());// 输出：Student [id=5, name=田七, score=100]
    	
    	Optional<Integer> optional2 = 
    			list.stream().map(Student::getScore).min(Integer::compareTo);
    	System.out.println(optional2.get());// 输出：60
    	
    	Optional<Student> optional3 = 
    			list.stream().min((x,y)->Integer.compare(x.getScore(), y.getScore()));
    			System.out.println(optional3.get());// 输出：Student [id=1, name=张三, score=60]
    }
    
    @Test
    public void test1(){
    	boolean b = list.stream().allMatch((s) -> s.getName().equals(Status.a));
    	System.out.println(b);// 输出：false
    	
    	b = list.stream().anyMatch((s) -> s.getName().equals(Status.a));
    	System.out.println(b);// 输出：false
    	
    	b = list.stream().noneMatch((s) -> s.getName().equals(Status.a));
    	System.out.println(b);// 输出：true
    	
    	Optional<Student> optional =
    	list.stream().sorted((x,y) -> -Double.compare(x.getId(), y.getId())).findFirst();
    	System.out.println(optional.get());// 输出：Student [id=5, name=田七, score=100]
    
    	optional =
    	list.parallelStream().filter((e) -> e.getStatus().equals(Status.a)).findAny();
    	System.out.println(optional.get());// 输出：Student [id=1, name=张三, score=60]
    }

#### 1.2、归纳 ####

> reduce(T identity, BinaryOperator accumulator) – 可以将流中元素反复结合起来，得到一个值

@Test
    public void test3(){
    	List<Integer> tmp = Arrays.asList(1,2,3,4,5);
    	Integer sum = tmp.stream().reduce(0, (x,y) -> x + y);
    	System.out.println(sum);// 输出：15
    	Optional<Integer> optional = list.stream().map(Student::getScore).reduce(Integer::sum);
    	System.out.println(optional.get());// 输出：400
    }

#### 1.3、收集 ####

> collect–将流中转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

@Test
    public void test4(){
    	// 转成List
    	List<String> tmp = list.stream().map(Student::getName)
    	.collect(Collectors.toList());
    	tmp.forEach(System.out::print);// 输出：张三李四王五赵六田七
    	// 转成Set
    	Set<String> set = list.stream().map(Student::getName)
    			.collect(Collectors.toSet());
    	set.forEach(System.out::print);// 输出：张三李四王五赵六田七
    	// 转成HashSet
    	HashSet<String> hs = list.stream().map(Student::getName)
    			.collect(Collectors.toCollection(HashSet::new));
    	hs.forEach(System.out::print);// 输出：张三李四王五赵六田七
    	// 获取总数
    	long count = list.stream().collect(Collectors.counting());
    	System.out.println(count);// 输出：5
    	// 获取平均值
    	double avg = list.stream().collect(Collectors.averagingDouble(Student::getScore));
    	System.out.println(avg);// 输出：80.0
    	// 获取总和
    	double sum = list.stream().collect(Collectors.summingDouble(Student::getId));
    	System.out.println(sum);// 输出：15.0
    	// 最大值
    	Optional<Student> max = list.stream()
    			.collect(Collectors.maxBy((x,y) -> Integer.compare(x.getId(), y.getId())));
    	System.out.println(max.get());// 输出：Student [id=5, name=田七, score=100]
    	// 最小值
    	Optional<Integer> min = list.stream().map(Student::getScore)
    			.collect(Collectors.minBy((x,y) -> Integer.compare(x, y)));
    	System.out.println(min.get());// 输出：60
    }

@Test
    public void test5(){
    	// 分组(按状态分)
    	Map<Status, List<Student>> map =
    	list.stream().collect(Collectors.groupingBy(Student::getStatus));
    	System.out.println(map);
    	// 输出：{b=[Student [id=2, name=李四, score=70]], 
    	// a=[Student [id=1, name=张三, score=60], Student [id=4, name=赵六, score=90], Student [id=5, name=田七, score=100]], 
    	// c=[Student [id=3, name=王五, score=80]]}
    
    	// 多级分组(先按状态分，然后在按分数分)
    	Map<Status, Map<Object, List<Student>>> map1 = list.stream().collect(Collectors.groupingBy(Student::getStatus, Collectors.groupingBy((x) -> {
    		if(((Student) x).getScore() < 70){
    			return "及格";
    		}else if(x.getScore() >= 70 && x.getScore() <= 80){
    			return "良好";
    		}else{
    			return "优秀";
    		}
    	})));
    	System.out.println(map1);
    	// 输出：{b={良好=[Student [id=2, name=李四, score=70]]}, 
    	// a={优秀=[Student [id=4, name=赵六, score=90], Student [id=5, name=田七, score=100]], 
    	// 及格=[Student [id=1, name=张三, score=60]]}, 
    	// c={良好=[Student [id=3, name=王五, score=80]]}}
    
    
    	// 分区(按id分)
    	Map<Boolean, List<Student>> map2 = list.stream().collect(Collectors.partitioningBy((s) -> s.getId() < 4));
    	System.out.println(map2);
    	// 输出：{false=[Student [id=4, name=赵六, score=90], Student [id=5, name=田七, score=100]], 
    	// true=[Student [id=1, name=张三, score=60], Student [id=2, name=李四, score=70], Student [id=3, name=王五, score=80]]}
    }