Java8实战，

summary

1,方法相当于一个变量，为一等公民，主要实现是1，方法引用。2，lambda

2，Java8 帮我们写了一些函数接口来传递这个行为, what' s behaviors?

3,有相同的可以直接用方法引用代替，沒有还需自己写, how is behavior working?

4，lamda表达式相当于匿名函数的简单写法，通常用在比较器，gui的注册事件，线程注册

5，interface添加default方法

6，stream， how to use these behaviors?

7，怎么写好lambda，注意：要提前准备好对象（资源）通过形参传个lambda

remember behavior parameterization
use a function interface to pass behavior
using a method to Execute a behavior and maybe using a functional interface as a parameter
write your own lambda code in an actual statement when calling the related method

8，box and unbox functional Interface, such IntFunction, IntToDoubleFunction.

9，binary，BinaryOperator<T> (T, T)->, BiPredicate, BiConsumer, BiFunction

10, Java8提供的行为函数沒有抛出异常，如果需要抛出受检异常，1，自己封装。2，在lambda里面写

11,lambda 有返回void的兼容，不如consumer的accept的返回一个void，但Consumer<String> a = s -> list.add(s);

12,改成方法引用有三种：(同时也要注意静态和对象问题

调用静态方法
调用参数的方法
调用外部变量的方法(代表不需要传入资源（对象）

13，静态辅助类的一些功能，可以转移到接口的静态方法，如Arrays的sort, arrays的sort就是调用她

14，default方法的优先级

explicit win
sub-interface win
不能判断，还是explicit override

UnaryOperator

Supplier

1，

@FunctionalInterface
public interface Supplier<T> {

2， T get();

Supplier<Apple> c1 = Apple::new
Apple a1 = c1.get();

consumer接口

@FunctionalInterface
public interface Consumer<T> {

2,void accept(T t);

3,主要用来消费的

function 接口

1，public interface Function<T, R> {

2，T apply(F input);

3，主要是用来转换东西的

4，函数复合，

andThen f.andThen(g) 数学上会写作g(f(x))
compose f.compose(g); 数学上会写作f(g(x))

Predicate接口

1，充当一个参数化的返回Boolean比较方法

2，public interface Predicate<T> {

3，boolean test(T t);

4，能动态替换返回boolean的函数

4.5, a.or(b).and(c) = (a || b) && c ,而且只能是同个参数类型

5，基本类型装箱问题，

DoublePredicate
boolean test(double value);//有对应的原始类型特化接口

lambda用法

1，

2，这里注意一下list是实例

camparing 方法传入一个function函数，传换后的数据要实现campareTo方法（Integer，String）

3，

4，基本lambda语法

5，基本用法

6，在面向资源编程的lambda，不需要重复打开资源和关闭资源

7，lambda也有匿名函数的问题

8，方法引用

静态方法引用，（例如Integer的parseInt方法，写作Integer::parseInt）。
实例方法引用，（例如String的length，String：：length
方法体里面的方法引用，进一步的方法引用
方法里面有沒有实现的方法引用，记得要补上

9，比较器复合

comparetor的comparing方法相当于帮我实现了compare方法，只需要我们传递lambda或者方法引用进去
翻转：list.sort(comparing(Object::getXXX).reveserd());
同样的时候添加第二个比较器，第二个是comparator类型， list.sort(Comparator.comparing(Integer::intValue).reversed().thenComparing(Integer::compareTo));
这些操作在上一条的基础上改

stream

1, iterator, 你需要explicitly 写出循环的细节，external; Stream focus on what we want to do

2,iterator需要一整块内存，stream按照所需的量, The element on stream are computed on demand

3, 短路 noneMatch, allMatch, Nonematch,limit, first, firstAny

4，合并循环 loop fusion，

5,intermediate operations return stream, you can pass the filtering behavior as argument by lambda expression

6, terminal operations return non-stream value and process a stream pipeline to return a result

7，stateless（map, filter) vs statefull(sort, distinct, sum, reduce, sum, max)，无状态好像可以合并，有状态就是有数据存储功能，线程不安全，无状态就是一次操作，不能保存数据。线程安全

8，从List<String> -> Stream<String> - > List<String>

9,方法参数化后，我们不用传递资源，stream中的elements就是我们的资源，我们只要传递lambda或者方法引用

10，stream也有primitive data type Stream，还能返回boxing的流，String<Integer> stream = intStream.boxed(), 反转mapToInt

11,IntStream的max可以返回一个OptionalInt

12,IntStream.range()操作，rangeClose包含最后, range不包含

13,Stream.of(可变参数) ,实际上调用：return Arrays.stream(values); 原始类型数组不能直接调用stream.of,调用Arrays.stream

14，置空Stream.empty()

15,flatMap用来解开Stream<String[]>或者Stream<Stream<>>, stream<string> -> stream<String[]> ->stream<stream<string>>, 使第二部stream<String[]> -> Stream<String>

16, 文件一行当作一个流，Stream<String> fileStream = Files.lines(Paths.get("abc.txt")

17,生成无限流，迭代器public static<T> Stream<T> generate(Supplier<T> s) ， public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)，所以要用limit限制

18,原始，reduce和collect，count,max,min(primitive use,sum) -> sum -> * averagin，maxby，summing, counting

19，在grouping操作map<Type, Option<Type>>，maxby不会返回option空值在map里面，而且在有相关值的时候，才把相关的键加入进去（具体实现应该是先看值，在设置key，value

20,collector是个接口，collectors是实现类

21,

22,使用parallel的准则

测量measure
留意装箱box
limit，findFirst不适合，findAny适合
对应流上面操作多的适合，数据量小的不合适
arrayList和IntStream合适，linkedList和stream.iterate不合适

23，设计模式

24，debug，stack不方便看，peek不消费整个stream，可以用来调试

25,不适合在lambda写很多，encapsulated在一个方法中

26，default方法

和static不能并存，static只能由Interface.method这这样调用

1，更加简单的利用多cpu

2，基本概念

 流是“从支持数据处理操作的源生成的一系列元素”。

 流利用内部迭代：迭代通过filter、map、sorted等操作被抽象掉了。

 流操作有两类：中间操作和终端操作。

 filter和map等中间操作会返回一个流，并可以链接在一起。可以用它们来设置一条流水线，但并不会生成任何结果。

 forEach和count等终端操作会返回一个非流的值，并处理流水线以返回结果。  流中的元素是按需计算的。

3，filter，筛选和切片

4，limit，skip

5，map，映射

flatMap

6，查找和匹配

anyMatch方法返回一个boolean，因此是一个终端操作。

　　　　if(menu.stream().anyMatch(Dish::isVegetarian)){

　　　　System.out.println("The menu is (somewhat) vegetarian friendly!!"); }

allMatch方法的工作原理和anyMatch类似，但它会看看流中的元素是否都能匹配给定的谓

　　boolean isHealthy = menu.stream().allMatch(d -> d.getCalories() < 1000);

和allMatch相对的是noneMatch。

　　boolean isHealthy = menu.stream()

　　.noneMatch(d -> d.getCalories() >= 1000);

findFirst和findAny

7，归约

reduce ，
累加：int sum = numbers.stream().reduce(0, Integer::sum);

　　　最大最小值：Optional min = numbers.stream().reduce(Integer::min);

8，并发的有状态和无状态

9，优化自动装箱，

int calories = menu.stream() .mapToInt(Dish::getCalories) .sum();
自动装箱
IntStream intStream = menu.stream().mapToInt(Dish::getCalories)
Stream<Integer> stream = intStream.boxed();

10,小结