Java8 Stream+Lambda 用法，从此告别shi山

Java8新特性 Lambda表达式和流（一般结合起来一起使用）

例如需求：
1）筛选出卡路里小于400的菜肴
2）对筛选出的菜肴进行一个排序
3）获取排序后菜肴的名字

菜肴： Dish.java

@Data
public class Dish {
private String name;
private boolean vegetarian;
peivate int calories;
private Type type;
}

java8以前的实现方式
private List beforeJava7(List dishList) {
List lowCaloricDishes = new ArrayList<>;
//筛选出卡路里小于400的菜肴
for (Dish dish : dishList){
if (dish.getCalories() < 400){
lowCaloricDishes.add(dish);
}
}
//对筛选出的结构进行排序
Collections.sort(lowCaloricDishes, new Compator(){
@Override
public int compare(Dish o1 , Dish o2){
return Integer.compare(o1.getCalories(), o2.getCalories());
}
});

//获取排序后菜肴的名字
List lowCaloricDishesName = new ArrayList<>();
for (Dish d : lowCaloricDishes){
lowCaloricDishewName.add(d.getName());
}

}

java8之后的写法
private List afterJava8(List dishList){
return dishList.stream()
.filter(d -> d.getCalories() <400) //筛选出卡路里小于400的菜肴
.sorted(comparing(Dish::getCalories)) //根据卡路里进行排序
.map(Dish:: getName) //提取菜肴名称
.collect(Collectors.toList()); //转化为list集合

}

加入又有了新的需求：
对数据路查询到的菜肴根据菜肴种类进行分类，返回一个Map<Type,List>的结果

java8之前的实现
private static Map<Type, List> beforeJdk8(List dishList){
return dishList.stream().collect(groupingBy(Dish::getType));
}

总结：
什么是流：
流是支持数据处理操作的源生成的元素序列，源可以是数组，文件，集合，函数。流不是集合元素，他不是数据结构并不保存数据，它的主要目的在于计算。

如何生成流：
1）通过集合生成，应用中最常用的一种
List integerList = Arrays.asList(1,2,3,4,5);
Stream stream = integerList.stream();
通过集合的stream方法生成流

2）通过数组生成
int[] intArr = new innt[]{1,2,3,4,5};
IntStream stream = Arrays.stream(intArr);

3)通过值生成
Stream stream = Stream.of(1,2,3,4)；

。。。。其他的方式不常用

流的操作类型：
流的操作类型主要分为两种
中间操作：一个流可以后面跟随0个或者多个中间操作。其目的主要是打开流，作出某种程度的数据映射或者过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性话的，仅仅调用到这类方法，并没有真正开的流的遍历真正的遍历要到终端操作，常见的中间操作有filter，map等

终端操作：一个流有且仅有一个终端操作，当中这个操作执行后，流就被关闭了，无法再被操作，因此一个流只能被遍历一次，若想再遍历则要重新生成流。常见的有count，collect

流的使用
中间操作：
filter过滤
List integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream stream = integerList.stream().filter(i -> i > 3);

通过filter方法进行筛选，filter方法参数为一条件

distinct去除重复元素
List integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream stream = integerList.stream().distinct();
通过distinct方法快速去掉重复元素

limit返回指定流的个数
List integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
通过limit方法指定返回个数，limit参数必须》=0Stream stream = integerList.stream().limit(3);

map流映射
所谓流映射就是将接受的元素映射成另外元素
List stringList = Arrays.asList(“java8”,“lambdas”,“in”,“xingguof”);
Stream stream = stringList.stream().map(String::length);
通过map方法可以完成映射，该例子中完成String类型到Integer类型

flatMap流转换
将一个流中的每个值都转化为另一个流
List stringList = Arrays.asList(“java8”,“lambdas”,“in”,“xingguof”);
List list = stringList.stream()
.map(w -> w.split(“–”))
.flatMap(Arrays::stream)
.distinct()
.collect(Collectors.toList());
map(w->w.split(" ")的返回值为Stream<String[]>,我们想获取 Stream可以通过flatMap方法来完成Stream<String[] ->Stream的转换。

终端操作
统计流中元素个数
通过count
List integerList = Arrays.asList(1, 2, 3, 4, 5,5);
long count = integerList.stream().count();
通过使用count方法来统计流中元素个数

通过counting
List integerList = Arrays.asList(1, 2, 3, 4, 5,5);
Long result = integerList.stream().collect(counting());
这种方法统计个数在与collect联合使用特别有用，用的特别多。

reduce将流中的元素组合起来
假设我们对于一个集合中的值进行求和
在jdk1.8之前
int sum =0;
for(int i :interList){
sum+=i;
}

jdk8之后通过reduce进行处理
List integerList = Arrays.asList(1, 2, 3, 4, 5,5);
Integer sum = integerList.stream().reduce(0, (a, b) -> (a + b));
System.out.println(sum);
或者可以这样写
List integerList = Arrays.asList(1, 2, 3, 4, 5,5);
Integer sum = integerList.stream().reduce(0, Integer::sum);
通过averagingInt求平均值
double average = menu.stream().collect(averagingInt(Dish::getCalories));
如果数据类型为double、long，则通过averagingDouble、averagingLong方法进行求平均

通过summarizingInt同时求总和、平均值、最大值、最小值
IntSummaryStatistics intSummaryStatistics = menu.stream().collect(summarizingInt(Dish::getCalories));
double average = intSummaryStatistics.getAverage(); //获取平均值
int min = intSummaryStatistics.getMin(); //获取最小值
int max = intSummaryStatistics.getMax(); //获取最大值
long sum = intSummaryStatistics.getSum(); //获取总和
如果数据类型为double、long，则通过summarizingDouble、summarizingLong方法

通过foreach进行元素遍历
List integerList = Arrays.asList(1, 2, 3, 4, 5);
integerList.stream().forEach(System.out::println);

而在jdk8之前实现遍历：

for (int i : integerList) {
System.out.println(i);
}
jdk8之后遍历元素来的更为方便，原来的for-each直接通过foreach方法就能实现了

返回集合
List strings = menu.stream().map(Dish::getName).collect(toList());
Set sets = menu.stream().map(Dish::getName).collect(toSet());
只举例了一部分，还有很多其他方法 jdk8之前

List stringList = new ArrayList<>();
Set stringSet = new HashSet<>();
for (Dish dish : menu) {
stringList.add(dish.getName());
stringSet.add(dish.getName());
}
通过遍历和返回集合的使用发现流只是把原来的外部迭代放到了内部进行，这也是流的主要特点之一。内部迭代可以减少好多代码量

通过joining拼接流中的元素
String result = menu.stream().map(Dish::getName).collect(Collectors.joining(", "));
默认如果不通过map方法进行映射处理拼接的toString方法返回的字符串，joining的方法参数为元素的分界符，如果不指定生成的字符串将是一串的，可读性不强

进阶通过groupingBy进行分组
Map<Type, List> result = dishList.stream().collect(groupingBy(Dish::getType));
在collect方法中传入groupingBy进行分组，其中groupingBy的方法参数为分类函数。还可以通过嵌套使用groupingBy进行多级分类

Map<Type, List> result = menu.stream().collect(groupingBy(Dish::getType,
groupingBy(dish -> {
if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
})));
进阶通过partitioningBy进行分区
分区是特殊的分组，它分类依据是true和false，所以返回的结果最多可以分为两组

Map<Boolean, List> result = menu.stream().collect(partitioningBy(Dish :: isVegetarian))
等同于

Map<Boolean, List> result = menu.stream().collect(groupingBy(Dish :: isVegetarian))
这个例子可能并不能看出分区和分类的区别，甚至觉得分区根本没有必要，换个明显一点的例子：

List integerList = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List> result = integerList.stream().collect(partitioningBy(i -> i < 3));
返回值的键仍然是布尔类型，但是它的分类是根据范围进行分类的，分区比较适合处理根据范围进行分类