java8新特性总结——StreamaAPI【二】

Stream的终止操作：终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void 。

一：查找与匹配

allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	内部迭代(使用Collection 接口需要用户去做迭代，称为外部迭代。 相反，Stream API 使用内部迭代——它帮你把迭代做了)

二：归约与收集

reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回Optional<T>
collect(Collector c)	将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

package com.atguigu.test;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collector;
import java.util.stream.Collectors;

import org.junit.Test;

import com.atguigu.test.Employee.Status;
import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils.Collections;

public class TestStream2 {
	//3终止操作
	/*
		allMatch——检查是否匹配所有元素
		anyMatch——检查是否至少匹配一个元素
		noneMatch——检查是否没有匹配的元素
		findFirst——返回第一个元素
		findAny——返回当前流中的任意元素
		count——返回流中元素的总个数
		max——返回流中最大值
		min——返回流中最小值
	 */
	
	List<Employee> list = Arrays.asList(new Employee(102, "李四", 59, 6666.66,Status.BUSY),
			new Employee(101, "张三", 18, 9999.99, Status.FREE),
			new Employee(102, "李四", 28, 3333.33, Status.VOCATION),
			new Employee(103, "王五", 25, 7777.77, Status.BUSY),
			new Employee(104, "赵六", 25, 7777.77, Status.FREE),
			new Employee(105, "赵六", 25, 7777.77, Status.FREE),
			new Employee(106, "田七", 38, 5555.55, Status.BUSY)
	);
	
	@Test
	public void test1() {
		boolean b1=list.stream().allMatch((e)->e.getStatus().equals(Status.BUSY));//
		System.out.println(b1);//false
		boolean b2=list.stream().anyMatch((e)->e.getStatus().equals(Status.BUSY));
		System.out.println(b2);//true
		boolean b3=list.stream().noneMatch((e)->e.getStatus().equals(Status.BUSY));
		System.out.println(b3);//false
	}
	@Test
	public void test2() {
		Optional<Employee> op=list.stream()
			.sorted((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()))
			.findFirst();//由于第一个可能不存在所以防止空指针异常返回为optional
		System.out.println(op.get());
		System.out.println("----------------------------------");
		Optional<Employee> op2=list.stream().filter((e)->e.getId()>103).findAny();
		System.out.println(op2);
	}
	
	@Test
	public void test3() {
		long count=list.stream().filter((e)->e.getSalary()>7000).count();
		System.out.println(count);
		
		Optional<Double> op=list.stream().map(Employee::getSalary).max(Double::compare);
		System.out.println(op);
		
		Optional<Double> op1=list.stream().map(Employee::getSalary).max((d1,d2)->Double.compare(d1, d2));
		System.out.println(op1);
	}
	
	//reduce 可以将流中元素反复结合起来，得到一个值。
	@Test
	public void test4() {
		List<Integer> mylist=Arrays.asList(1,2,3,4,5,6,7);
		Integer sum=mylist.stream().reduce(0,(x,y)->x+y);
		System.out.println(sum);
		System.out.println("-------------");
		Optional<Double> salsum=list.stream().map(Employee::getSalary).reduce(Double::sum);
		System.out.println(salsum.get());
	}
	
	// collect
	@Test
	public void test5() {
		//Collectors有很多方法
		list.stream().map(Employee::getName).collect(Collectors.toList()).forEach(System.out::println);
		System.out.println(list.stream().collect(Collectors.groupingBy(Employee::getStatus)));
		
		Map<Boolean,List<Employee>> map=list.stream().collect(Collectors.partitioningBy((e)->e.getSalary()>5000.0));
		System.out.println(map);
		
		System.out.println(list.stream().map(Employee::getName).collect(Collectors.joining(",")));
	}
}