Java8之Stream API

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

一、Stream的3个步骤

1）创建Stream
2）中间操作
3）终止操作

二、创建Stream

#########创建Stream ##########
//第一种
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();

//第二种
Employee[] employees = new Employee[10];
Stream<Employee> stream2 = Arrays.stream(employees);

//第三种 通过of接受不定长参数
Stream<String> stream3 = Stream.of("a","b","c");

//第四种1:无限流，迭代
Stream<Integer> iterate = Stream.iterate(0, (x) -> x+2);

//第四种2:无限流，生成
Stream<Double> generate = Stream.generate(() -> Math.random());

三、中间操作-筛选与切片

###################中间操作#####################

----->使用distinct需要重写实体的hashCode()和equals（）方法

四、中间操作-映射

举例如下图：

五、中间操作-排序

举例如下图：

六、中间操作-查找和匹配

注意：filter时候，字符串比较必须用equals，否则不能过滤。

	List<Employee> emps = Arrays.asList(
			new Employee(102, "李四", 59, 6666.66, Status.BUSY),
			new Employee(101, "张三", 18, 9999.99, Status.FREE),
			new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
			new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(105, "田七", 38, 5555.55, Status.BUSY)
	);
	/*
		allMatch——检查是否匹配所有元素
		anyMatch——检查是否至少匹配一个元素
		noneMatch——检查是否没有匹配的元素
		findFirst——返回第一个元素
		findAny——返回当前流中的任意元素
		count——返回流中元素的总个数
		max——返回流中最大值
		min——返回流中最小值
	 */
	@Test
	public void test1(){
		boolean bl = emps.stream()
			.allMatch((e) -> e.getStatus().equals(Status.BUSY));
		
		System.out.println(bl);
		
		boolean bl1 = emps.stream()
			.anyMatch((e) -> e.getStatus().equals(Status.BUSY));
		
		System.out.println(bl1);
		
		boolean bl2 = emps.stream()
			.noneMatch((e) -> e.getStatus().equals(Status.BUSY));
		
		System.out.println(bl2);
	}
	
	@Test
	public void test2(){
		Optional<Employee> op = emps.stream()
			.sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
			.findFirst();
		
		System.out.println(op.get());
		
		System.out.println("--------------------------------");
		
		Optional<Employee> op2 = emps.parallelStream()
			.filter((e) -> e.getStatus().equals(Status.FREE))
			.findAny();
		
		System.out.println(op2.get());
	}
	
	@Test
	public void test3(){
		long count = emps.stream()
						 .filter((e) -> e.getStatus().equals(Status.FREE))
						 .count();
		
		System.out.println(count);
		
		Optional<Double> op = emps.stream()
			.map(Employee::getSalary)
			.max(Double::compare);
		
		System.out.println(op.get());
		
		Optional<Employee> op2 = emps.stream()
			.min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
		
		System.out.println(op2.get());
	}
	
	//注意：流进行了终止操作后，不能再次使用
	@Test
	public void test4(){
		Stream<Employee> stream = emps.stream()
		 	.filter((e) -> e.getStatus().equals(Status.FREE));
		
		long count = stream.count();
		stream.map(Employee::getSalary)
			.max(Double::compare);
	}

七、终止操作-归约和搜集

/*
	归约
	reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。
 */

@Test
public void test1(){
   List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
   
   Integer sum = list.stream()
   	.reduce(0, (x, y) -> x + y);
   
   System.out.println(sum);
   
   System.out.println("----------------------------------------");
   
//使用optional可以避免空指针
//map-reduce的配合使用很经典，map提取，reduce归约
   Optional<Double> op = emps.stream()
   	.map(Employee::getSalary)
   	.reduce(Double::sum);
   
   System.out.println(op.get());
}

//需求：搜索名字中 “六” 出现的次数
@Test
public void test2(){
   Optional<Integer> sum = emps.stream()
   	.map(Employee::getName)
   	.flatMap(TestStreamAPI1::filterCharacter)
   	.map((ch) -> {
   		if(ch.equals('六'))
   			return 1;
   		else 
   			return 0;
   	}).reduce(Integer::sum);
   
   System.out.println(sum.get());
}

//collect——将流转换为其他形式。接收一个 Collectors接口的实现，用于给Stream中元素做汇总的方法
@Test
public void test3(){
   List<String> list = emps.stream()
   	.map(Employee::getName)
   	.collect(Collectors.toList());
   
   list.forEach(System.out::println);
   
   System.out.println("----------------------------------");
   
   // 将所有人的姓名取出，并将其放到set集合中
   Set<String> set = emps.stream()
   	.map(Employee::getName)
   	.collect(Collectors.toSet());
   //  集合遍历
   set.forEach(System.out::println);

   System.out.println("----------------------------------");
   
   HashSet<String> hs = emps.stream()
   	.map(Employee::getName)
   	.collect(Collectors.toCollection(HashSet::new));
   
   hs.forEach(System.out::println);
}

@Test
public void test4(){
   // 获取最高薪水的值
   Optional<Double> max = emps.stream()
   		.map(Employee::getSalary)
   		.collect(Collectors.maxBy(Double::compare));
   
   System.out.println(max.get());
   
   // 获取最小薪水的值
   Optional<Employee> op = emps.stream()
   		.collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
   
   System.out.println(op.get());
   
   // 求所有人薪水的和
   Double sum = emps.stream()
   		.collect(Collectors.summingDouble(Employee::getSalary));
   
   System.out.println(sum);
   
   // 求所有人薪水的平均值
   Double avg = emps.stream()
   		.collect(Collectors.averagingDouble(Employee::getSalary));
   
   System.out.println(avg);
   
   // 求个数
   Long count = emps.stream()
   		.collect(Collectors.counting());
   
   System.out.println(count);
   
   System.out.println("--------------------------------------------");
   
   DoubleSummaryStatistics dss = emps.stream()
   		.collect(Collectors.summarizingDouble(Employee::getSalary));
   
   System.out.println(dss.getMax());
}

//分组
@Test
public void test5(){
   Map<Status, List<Employee>> map = emps.stream()
   	.collect(Collectors.groupingBy(Employee::getStatus));
   
   System.out.println(map);
}

//多级分组
@Test
public void test6(){

   // 按照不同年龄区间和状态分组
   Map<Status, Map<String, List<Employee>>> map = emps.stream()
   	.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
   		if(e.getAge() >= 60)
   			return "老年";
   		else if(e.getAge() >= 35)
   			return "中年";
   		else
   			return "成年";
   	})));
   
   System.out.println(map);
}

//分区
@Test
public void test7(){
    // 以5000为基准分组，大于5000的一组，小于的一组
   Map<Boolean, List<Employee>> map = emps.stream()
   		.collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));
   
   System.out.println(map);
}

//
@Test
public void test8(){
   // 将所有人的姓名name用逗号分隔，转化成字符串
   String str = emps.stream()
   		.map(Employee::getName)
   		.collect(Collectors.joining("," , "----", "----"));
   
   System.out.println(str);
}

@Test
public void test9(){
   // 求所有人薪水的和
   Optional<Double> sum = emps.stream()
   		.map(Employee::getSalary)
   		.collect(Collectors.reducing(Double::sum));
   System.out.println(sum.get());
}

ok，常用的stream操作基本就是这些了。其他的可以点击源码进行查看研究。