Java8-Lambda&StreamAPI

本文章参考CSDN等相关资料整理，用于巩固相关知识，侵删。

1. 概述

Java8中（较之前版本）添加了一定的特性，代码中推出了Lambda表达式，提供了强大的StreamAPI
。。。

2.Lambda

2.1 Lambda表达式简介

Lambda表达式通过->作为符号，同其他语言的Lambda表达式类似，采用(param) -> {func;}的格式
Lambda表达式所依赖的是Java8中提供的函数式接口，位于java.util.function包下，同时提供一个@FunctionalInterface检测一个接口是否是函数式接口。
e.g:

@FunctionalInterface
public interface Comsumer<T>{
	void accpet(T t);
	default Consumer<T> andThen(Consumer<? super T> after){
		Objects.requireNonNull(after);
		return (T t) -> {accept(t);after.accept(t);};
	}
}

Test
public class Test{
	public static void main(String[] args){
		Consumer consumer = x -> System.out.println(x);
		consumer.accept(1);
	}
}

2.2 四大函数式接口

消费型接口：Consumer 只有一个抽象方法accept(T)，参数只有一个泛型T，无返回值。
//多个参数的话可以参考java.util.function.ObjLongConsumer
供给型接口：Supplier 只有一个抽象方法get()，无参数，返回值为泛型T
函数型接口：Function<T,R>只有一个抽象方法apply(T) 参数为T类型，返回值为R类型
断言型接口：Predicate,只有一个抽象方法Test(T),参数为T类型，返回值为boolean类型

3.StreamAPI

StreamAPI是Java8的一大亮点。它与java.io包中的xxxStream完全不同。Stream中间操作：多个中间操作可以连接起来形成流水线，除非流水线上某一个地方触发了终止操作，否则中间不会执行任何处理！而终止操作时会一次性全部处理（惰性处理）。

3.3 获取Stream

1.通过集合系列的Stream()或parallelStream()方法获取流

List<Integer> list = new ArrayList<>();
Stream<Integer> stream = list.stream();

2.通过Arrays.Stream()把数据转换成流

int[] a = new int[]{1,2,3};
IntStream stream = Arrays.Stream(a);

3.通过Stream.of()方法创建流

Stream<Integer> stream = Stream.of(1,2,3);

4.创建无限流

Stream<Integer> stream = Stream.iterate(0,x->x+2);

3.2 Stream操作（筛选与分片、映射、排序、终结（规约、收集））

3.2.1 筛选和分片

filter()//参数：断言型接口，过滤操作
distinct()//参数：无，去重操作
limit()//参数：long,获取前几条数据
skip()//参数：long,跳过前几条数据，获取后面几条的

3.2.2 映射

map()//参数：函数型接口，对原数据处理返回处理后的数据
flatMap()//参数：函数型接口，把流A的数据一个一个整合到流B中。
eg:
List<String> l1 = Arrays.asList("a","b","c");
List<String> l2 = Arrays.asList("d","e");
l1.stream().flatMap(x->l2.map(y->x+y)).forEach(System.out::println);

3.3.3 排序

自然排序sorted
含参数sorted的自定义排序
//
Stream<Integer> stream = Stream.of(1,2,3);
stream.sorted().forEach(System.out.println);
//
Stream<Integer> stream = Stream.of(1,2,3);
stream.sorted((x,y)->Integer.compare(x,y) ).forEach(Sysrem.out.println);
/

3.3.4 终止操作

allMatch()//参数：断言型接口，检查是否匹配所有元素
anyMatch()//参数：断言型接口，检查是否有匹配元素
noneMatch()//参数：断言型接口，检查是否没有匹配所有元素

findFirst()//参数：无，返回第一个元素
findAny()//参数：无，返回当前流的任意元素

count()//参数：无，返回流的元素个数
max()//参数：无，返回流中最大值
min()//参数：无，返回流中的最小值

//归约
reduce(),将流中元素反复结合起来得到一个值
eg:
List<Integer> l = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer reduce = l.stream().reduce(11,(x,y) -> x + y);//66

//收集
collect(Collector )
将流转换成其他形式
参数：Collector接口
返回值：对应转化的类型
Collectors.toList()，把List转换成List
Collectors.toMap(Function<? super T,? extends K> KeyMapper,Function<? super T,? extends  U> value Mapper)//转换成Map
toSet()//返回到Set中

eg:
List<User> users = Arrays.asList(new User("张三", 19, 1000),
                new User("张三", 58, 2000),
                new User("李四", 38, 3000),
                new User("赵五", 48, 4000)
        );
List<String> collect = users.stream().map(x -> x.getName()).collect(Collectors.toList());
Set<String> collect1 = users.stream().map(x -> x.getName()).collect(Collectors.toSet());
Map<Integer, String> collect2 = users.stream().collect(
	Collectors.toMap(
		x -> x.getAge(),
		x -> x.getName()
	)
);
       

//分组
使用Collectors.groupingBy(Function<? super T,? extends K> classfiler);
collect(Collector ) 分组到 Map(classkey,streamitem)
eg:
List<User> users = Arrays.asList(new User("张三", 19, 1000),
                new User("张三", 58, 2000),
                new User("李四", 38, 3000),
                new User("赵五", 48, 4000)
        );
Map<String, List<User>> collect3 = users.stream().collect(
	Collectors.groupingBy(x -> x.getName())
);
/*
{李四=[User{name='李四', age=38, salary=3000}], 张三=[User{name='张三', age=19, salary=1000}, User{name='张三', age=58, salary=2000}], 赵五=[User{name='赵五', age=48, salary=4000}]}
*/