Java8 Stream流 常用方法

需要先掌握

1.Lambda 表达式

菜鸟教程
Lambda 表达式，也可称为闭包，它是 Java 8 的重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

以下是lambda表达式的重要特征:

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

注意:
lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

int num = 1;  
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;  
//报错信息：Local variable num defined in an enclosing scope must be final or effectively 
 final

2.方法引用

菜鸟教程
方法引用通过方法的名字来指向一个方法。
方法引用使用一对冒号 :: 。

3.函数式接口

菜鸟教程
四种常用的函数式接口
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。

Stream流常用方法

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
reduce
Collectors详解

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class People {
	private Long id;
	private String name;
	private Integer age;
	private String grade;

	public static void main(String[] args) {
		System.out.print("");
		People people1 = new People(1L, "1", 1, "1");
		People people2 = new People(2L, "2", 2, "2");
		List<People> peopleList = Arrays.asList(people1,people2);

		//forEach, map和peek的区别
		peopleList.forEach(c -> c.setAge(c.getAge() + 1));
		peopleList.stream().forEach(c -> c.setAge(c.getAge() + 1));

		//去重
		List<Integer> list = peopleList.stream().map(new Function<People, Integer>() {
			@Override
			public Integer apply(People t){
				return t.getAge();
			}
		}).distinct().collect(Collectors.toList());
		//List<People> list6 = peopleList.stream().map(c -> new People()).collect(Collectors.toList());
		List<Integer> list1 = peopleList.stream().map(People::getAge).collect(Collectors.toList());
		List<Integer> list5 = peopleList.stream().map(people -> {
			people.setAge(Optional.ofNullable(people.getAge()).orElse(0) + 1);
			return people.getAge();
		}).collect(Collectors.toList());

		List<People> list2 = peopleList.stream().peek(c -> c.setAge(c.getAge() + 1)).collect(Collectors.toList());

		//筛选
		//统计数量
		long count = peopleList.stream().filter(c -> c.getAge() > 1).count();

		//获取指定数量的流, 从前往后
		List<People> list3 = peopleList.stream().limit(1).collect(Collectors.toList());
		//获取指定数量的流, 从后往前
		List<People> list4 = peopleList.stream().skip(1).collect(Collectors.toList());

		//排序, 默认正序, reversed倒序
		peopleList.stream().sorted(Comparator.comparing(People::getAge).thenComparing(People::getName).reversed());

		//分组
		//key:grade, value:people list
		Map<String, List<People>> peopleMap = peopleList.stream().collect(Collectors.groupingBy(People::getGrade));
		//统计各个年级人数
		Map<String, Long> peopleMap4 = peopleList.stream().collect(Collectors.groupingBy(People::getGrade,
			Collectors.counting()));
		//统计各个年级的学生姓名
		Map<String, List<String>> peopleMap5 = peopleList.stream().collect(Collectors.groupingBy(People::getGrade,
			Collectors.mapping(People::getName, Collectors.toList())));


		//转map, value字段不能为null, 否则会报错
		//key:id, value:people
		Map<Long, People> peopleMap2 = peopleList.stream().collect(Collectors.toMap(People::getId, c -> c));
		//统计各个年级的学生姓名
		Map<String, String> peopleMap3 = peopleList.stream().collect(Collectors.toMap(People::getGrade, People::getName,
			(a, b) -> {return a + "_" +b;}));

		//统计所有学生的年龄和
		List<Integer> integerList = Arrays.asList(1,2,3,4);
		Integer i = integerList.stream().reduce((a, b) ->  a+b).get();
		Integer i2 = integerList.stream().reduce(0, (a, b) ->  a+b);
		Integer i3 = peopleList.stream().reduce(0, (a, b) -> {return a+b.getAge();}, (a, b) -> null);
		
	}
}