1. lambda表达式
1.1 什么是lambda
以java为例，能够对一个java变量赋一个值，比方int a = 1，而对于一个办法，一块代码也是赋予给一个变量的，对于这块代码，或者说被赋给变量的函数，就是一个lambda表达式
//为变量赋值int a = 1;//将代码块赋值给变量var = public void fun(int x){ x+1;}//能够简化var = (x)->x+1;1.2 java为什么要引入lambda
lambda是为函数式编程服务的
编程语言共性之------什么是函数式编程？
函数式编程是一种编程范式，也就是如何编写程序的方法论，次要思维是把运算过程尽量编写成一系列嵌套的函数调用，FP强调“everything is lambda"，并且强调在逻辑解决中不变性的重要性
OOP强调“everything is object”，以及object之间的消息传递。通过消息传递扭转每个Object的外部状态，然而很多状况代码的编写实际上是用不到对象的，比方，对一组数据做加工，先查问，而后聚合，聚合后排序，再join，再排序，再聚合，再转换（map）失去最终的后果。这个过程，用FP的函数就很天然
result = func1(func2(func3...funcN(x))))java为了在原先oop的思维上减少函数式编程的应用，在java8上减少了lambda函数的新个性
除此之外，lambda表达式的引入还使得代码更为简洁，能够防止生成过多的污染环境的无用实现类（上面说）
1.3 如何应用lambda表达式
lambda表达式的引入能够防止生成过多的污染环境的实现类；
lambda表达式能够被赋值给一个变量，那么这个变量的类型是什么？
在java中，所有的Lambda的类型都是一个接口，而Lambda表达式自身，须要是这个接口的实现，这个接口须要具备三个特色，具备这些特色的接口叫做函数式接口
函数式接口只有一个形象办法
default办法为默认实现，不计入形象办法
如果接口申明了一个笼罩java.lang.Object的全局办法之一的形象办法，那么它不会计入接口的形象办法数量中，因为接口的任何实现都将具备java.lang.Object或其余中央的实现
如何应用lambda表达式
比方Comparator接口就是一个函数式接口，所以他能够应用lambda表达式，在之前应用comparator对一个list排序是上面这样的
List<Integer> list = new ArrayList<>();Collections.sort(list, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1-o2; }});能够看到下面理论真正有用的是return o1 - o2，下面的代码应用lambda表达式写如下
Collections.sort(list, ((o1, o2) -> o1-o2));Lambda 表达式的根底语法：Lambda 操作符->将 Lambda 表达式拆分成两局部：
左侧：Lambda 表达式的参数列表；
右侧：Lambda 表达式中所需执行的性能， 即 Lambda 体；
语法格局一：无参数，无返回值() -> System.out.println("Hello Lambda!");语法格局二：有一个参数，并且无返回值(x) -> System.out.println(x)语法格局三：若只有一个参数，小括号能够省略不写x -> System.out.println(x)语法格局四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句Comparator<Integer> com = (x, y) -> {System.out.println("函数式接口");return Integer.compare(x, y);};语法格局五：若 Lambda 体中只有一条语句， return 和 大括号都能够省略不写Comparator<Integer> com = (x, y) -> Integer.compare(x, y);1.4 lambda表达式办法援用，结构器援用和数组援用
办法援用
若 Lambda 体中的性能，曾经有办法提供了实现，能够应用办法援用
对象的援用 :: 实例办法名类名 :: 静态方法名类名 :: 实例办法名①办法援用所援用的办法的参数列表与返回值类型，须要与函数式接口中形象办法的参数列表和返回值类型保持一致！
②若Lambda 的参数列表的第一个参数，是实例办法的调用者，第二个参数(或无参)是实例办法的参数时，格局： ClassName::MethodName
//对象的援用 :: 实例办法名@Testpublic void test1(){ // 之前咱们是这样写的 Employee emp = new Employee(101, "张三", 18, 9999); Supplier<String> sup = () -> emp.getName(); System.out.println(sup.get()); System.out.println("----------------------------------"); // 当初咱们是这样写的 Supplier<String> sup2 = emp::getName; System.out.println(sup2.get());}//类名 :: 静态方法名@Testpublic void test2(){ Comparator<Integer> com = (x, y) -> Integer.compare(x, y); System.out.println("-------------------------------------"); Comparator<Integer> com2 = Integer::compare;}//类名 :: 实例办法名@Testpublic void test3(){ BiPredicate<String, String> bp = (x, y) -> x.equals(y); System.out.println(bp.test("abcde", "abcde")); System.out.println("-----------------------------------------"); BiPredicate<String, String> bp2 = String::equals; System.out.println(bp2.test("abc", "abc"));}结构器援用
对于person类，有两个结构器
class Person { String firstName; String lastName; Person() {} Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; }}当初有一个工厂接口用来生成person类
// Person 工厂interface PersonFactory<P extends Person> { P create(String firstName, String lastName);}咱们能够通过 :: 关键字来援用 Person 类的结构器，来代替手动去实现这个工厂接口：
// 间接援用 Person 结构器PersonFactory<Person> personFactory = Person::new;Person person = personFactory.create("Peter", "Parker");Person::new 这段代码，可能间接援用 Person 类的结构器。而后 Java 编译器可能依据上下文选中正确的结构器去实现 PersonFactory.create 办法
2.1 什么是Stream
Java 8引入了全新的Stream API，这里的Stream和I/O流不同，Java 8 中的 Stream 是对汇合（Collection）对象性能的加强，它专一于对汇合对象进行各种十分便当、高效的聚合操作，或者大批量数据操作，Stream API 借助于同样新呈现的 Lambda 表达式，极大的进步编程效率和程序可读性
Stream 就如同一个迭代器（Iterator），单向，不可往返，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从背后流过，一去不复返
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");myList .stream() // 创立流 .filter(s -> s.startsWith("c")) // 执行过滤，过滤出以 c 为前缀的字符串 .map(String::toUpperCase) // 转换成大写 .sorted() // 排序 .forEach(System.out::println); // for 循环打印①：两头操作会再次返回一个流，所以，咱们能够链接多个两头操作，留神这里是不必加分号的。上图中的filter 过滤，map 对象转换，sorted 排序，就属于两头操作。②：终端操作是对流操作的一个完结动作，个别返回 void 或者一个非流的后果。上图中的 forEach循环 就是一个终止操作下面是Stream的简略实用，能够看出它也是函数式编程，更多的表白了业务逻辑
2.2 罕用api
创立Stream
1. Arrays.stream()
当在日常编程中面对的是一个数组，能够应用Arrays.stream()办法来应用Stream
Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96};long count = Arrays.stream(array).filter(i->i>20).count();2. Stream.of()
当面对数组时除了能够应用Arrays.stream()办法外，还能够应用Stream将须要的数组转成Stream。这个办法岂但反对传入数组，将数组转成Stream，也反对传入多个参数，将参数最终转成Stream
Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96};long count = Stream.of(array).filter(i->i>20).count();long sum = Stream.of(12,77,59,3,654).filter(i->i>20).mapToInt(Integer::intValue).sum();System.out.println("count："+count+",sum:"+sum);3. Collection.stream()
这个就是最常见的Stream了。因为Collection是Java中汇合接口的父接口，Java中的汇合都继承或实现了此接口。所以Java中的汇合都能够应用此办法来创立一个Stream
List<Integer> numbers = new ArrayList<>();numbers.add(3);numbers.add(4);numbers.add(8);numbers.add(16); numbers.stream().forEach(number->{ System.out.println(number);});4.filter
这是一个Stream的过滤转换，此办法会生成一个新的流，其中蕴含合乎某个特定条件的所有元素，filter承受一个函数作为参数，该函数用Lambda表达式示意
List<Integer> integerList = Lists.newArrayList();integerList.add(15);integerList.add(32);integerList.add(5);integerList.add(232);integerList.add(56);List<Integer> after = integerList.stream() .filter(i->i>50) .collect(Collectors.toList());System.out.println(after);//232，565.map
map办法指对一个流中的值进行某种模式的转换。须要传递给它一个转换的函数作为参数
List<Integer> integerList = Lists.newArrayList();integerList.add(15);integerList.add(32);integerList.add(5);integerList.add(232);integerList.add(56);//将Integer类型转换成String类型List<String> afterString = integerList.stream() .map(i->String.valueOf(i)).collect(Collectors.toList());6.flatMap
将多个Stream连接成一个Stream，这时候不是用新值取代Stream的值，与map有所区别，这是从新生成一个Stream对象取而代之
List<String> words = new ArrayList<String>();words.add("your");words.add("name");public static Stream<Character> characterStream(String s){ List<Character> result = new ArrayList<>(); for (char c : s.toCharArray()) result.add(c); return result.stream(); } Stream<Stream<Character>> result = words.map(w -> characterStream(w)); //[['y', 'o', 'u', 'r'], ['n', 'a', 'm', 'e']]Stream<Character> letters = words.flatMap(w -> characterStream(w));//['y', 'o', 'u', 'r', 'n', 'a', 'm', 'e'] 7.limit办法和skip办法
limit(n)办法会返回一个蕴含n个元素的新的流（若总长小于n则返回原始流）
skip(n)办法正好相同，它会抛弃掉后面的n个元素
用limit和skip办法一起应用就能够实现日常的分页性能：
List<Integer> pageList = myList.stream() .skip(pageNumber*pageSize) .limit(pageSize).collect(Collectors.toList());8.distinct办法和sorted办法
distinct办法会依据原始流中的元素返回一个具备雷同程序、去除了反复元素的流，这个操作显然是须要记住之前读取的元素。
List<Integer> myTestList = Lists.newArrayList();myTestList.add(10);myTestList.add(39);myTestList.add(10);myTestList.add(78);myTestList.add(10);List<Integer> distinctList = myTestList.stream() .distinct().collect(Collectors.toList());System.out.println("distinctList："+distinctList);运行后果：distinctList：[10, 39, 78]sorted办法是须要遍历整个流的，并在产生任何元素之前对它进行排序。因为有可能排序后汇合的第一个元素会在未排序汇合的最初一位。
List<Integer> myTestList = Lists.newArrayList();myTestList.add(39);myTestList.add(78);myTestList.add(10);myTestList.add(22);myTestList.add(56);List<Integer> sortList = myTestList.stream() .sorted(Integer::compareTo).collect(Collectors.toList());System.out.println("sortList："+sortList);运行后果：sortList：[10, 22, 39, 56, 78]9.Collect
collect在流中生成列表，map，等罕用的数据结构
将一个流收集到一个List中，只须要这样写就能够。List<Integer> thereList = hereList.stream().collect(Collectors.toList());收集到Set中能够这样用Set<Integer> thereSet = hereList.stream().collect(Collectors.toSet());收集到Set时，管制Set的类型，能够这样。TreeSet<Integer> treeSet = hereList.stream() .collect(Collectors.toCollection(TreeSet::new));10.聚合操作
聚合是指将流汇聚为一个值，以便在程序中应用。聚合办法都是终止操作，聚合办法包含sum，count，max，min
long sum = Stream.of(12,77,59,3,654).filter(i->i>20).mapToInt(Integer::intValue).sum();findFirst办法返回非空集合中的第一个值，它通常与filter办法联合起来应用Integer first = hearList.stream().filter(i->i>100).findFirst().get();findAny办法能够在汇合中只有找到任何一个所匹配的元素，就返回，此办法在对流并行执行时非常无效Integer anyItem = hearList.parallelStream().filter(i->i>100).findAny().get();11.分组
对具备雷同个性的值进行分组是一个很常见的性能
将一个Room对象汇合依照高度分组。List<Room> roomList = Lists.newArrayList(new Room(11,23,56),new Room(11,84,48),new Room(22,46,112),new Room(22,75,62),new Room(22,56,75),new Room(33,92,224));Map<Integer,List<Room>> groupMap = roomList.stream().collect(Collectors.groupingBy(Room::getHigh));System.out.println("groupMap："+groupMap);2.3 Stream流的解决程序
Stream流的两头操作具备提早性，当且仅当存在终端操作时，两头操作才会被执行
Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> { System.out.println("filter: " + s); return true; });执行此代码段时，不会打印任何内容，对下面的代码增加 forEach终端操作，就有打印内容了
Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> { System.out.println("filter: " + s); return true; }) .forEach(s -> System.out.println("forEach: " + s));filter: d2forEach: d2filter: a2forEach: a2filter: b1forEach: b1filter: b3forEach: b3filter: cforEach: c然而能够看到输入后果并不是先将所有filter操作的打印语句打印进去；事实上，输入的后果却是随着链条垂直挪动的，比如说，当 Stream 开始解决 d2 元素时，它实际上会在执行完 filter 操作后，再执行 forEach 操作，接着才会解决第二个元素
起因是出于性能的思考。这样设计能够缩小对每个元素的理论操作数，比方上面操作
Stream.of("d2", "a2", "b1", "b3", "c") .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); // 转大写 }) .anyMatch(s -> { System.out.println("anyMatch: " + s); return s.startsWith("A"); // 过滤出以 A 为前缀的元素 });// map: d2// anyMatch: D2// map: a2// anyMatch: A2终端操作 anyMatch()示意任何一个元素以 A 为前缀，返回为 true，就进行循环。所以它会从 d2 开始匹配，接着循环到 a2 的时候，返回为 true ，于是进行循环。
因为数据流的链式调用是垂直执行的，map这里只须要执行两次。绝对于程度执行来说，map会执行尽可能少的次数，而不是把所有元素都 map 转换一遍
stream --> filter --> map --> sorted --> collect2.4 并行流
和迭代器不同的是，Stream 能够并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当应用串行形式去遍历时，每个 item 读完后再读下一个 item；
Stream具备平行解决能力，解决的过程会分而治之，也就是将一个大工作切分成多个小工作，这示意每个工作都是一个操作
//parallel办法能够将任意的串行流转换为一个并行流Stream.of(roomList).parallel();List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);numbers.parallelStream() .forEach(out::println); //展现程序不肯定会是1、2、3、4、5、6、7、8、9，而可能是任意的程序最初
大家看完有什么不懂的欢送在下方留言探讨