前面也有写一篇jdk8 + guava的博文，都是一些零碎的记录，感觉不是很好。
都说java8运行速度比之前的其他版本要快很多，这都要归功于Stream的概念，既然能那么快就从它与多线程的关系说起吧。
1、java 8 和多线程
在java8之前通过多线程来达到并行效果需要使用Thread API，syncharonized关键字，同时当线程访问并更新共享变量时，要是没有协调好线程之间的关系，可能就会出错。
而在java8中，会更多关注的是数据分块，而不是协调问题，所以基本上很少使用syncharonized，而是使用Stream的并行化方式来处理的。
如在两个CPU上刷选列表，可以先让一个CPU处理列表的前一半，另一个CPU处理后一半，即将大的数据流分块成小的数据流来处理，接着CPU会各自对自己的半个列表进行筛选，最后将两个结果合并到一个CPU上，在此基础上，当CPU越多，处理能力当然就会越强，既可以横向扩展。所以在处理时，基本上都会先将其转换成stream(parallelStream)：
asList.stream().filter((String s) -> s.contains(“v")).collect(Collectors.toSet());
2、行为参数化
依旧使用上一个例子吧，行为参数化简单的来说就是把一个行为（即一段逻辑代码）封装起来，通过传递的方式将方法的行为参数化，即：上例中的(String s) -> s.contains(“v”)就表示一段行为，将其通过lambda方式作为参数传递至filter函数中，可以很大程度上简洁代码，且逻辑也很清晰。当lambda主体（即 -> 之后的内容）很多时，需要使用{}花括号将其包裹。
3、在java8中lambda当然是重点之一了
先看一下例子吧：
(Integer i) -> return “Study” + i;
(Strings) -> {“Study”;}
上面这两个其实都不是正确的lambda，第一个中必须使用花括号将这个控制流语句给包起来才可以，即(Integer i) ->{return “Study” + i};
至于第二个后面的部分是一个表达式，而不是语句，可以直接去掉花括号，或采用显式返回语句，即(Strings) -> {return “Study”;}
4、函数式接口
即只定义了一个抽象方法的接口（并不是之后一个方法，还可以有其他默认方法，或静态方法，仅仅是抽象方法只有一个而已）。java8中会大量的用到此接口，并且你可以看到一般像这种接口都会使用@FunctionalInterface来注解，简单的介绍几个最常用的吧：
1）java.util.function.Predicate<T>
它包含一个boolean test(T t);抽象方法，所以一般是在需要处理boolean问题时使用它:
stream.filter(vo -> vo.getAge()>25).distinct().skip(3).limit(6).collect(Collectors.toList());
2）java.util.function.Consumer<T>
void accept(T t); 即对给定的参数T执行操作，最常用的莫过于forEach了：
asList.forEach(System.out::print);
3）java.util.function.Function<T, R>
R apply(T t); 接受一个参数T，还需要返回一个类型R，所以一般为将某一个对象的信息映射输出。
str.chars().mapToObj(ch -> Character.valueOf((char)ch)).forEach(System.out::print);
| 函数式接口 | 函数描述符 | 原始类型特化 |
| Predicate<T> | T -> boolean | IntPredicate, LongPredicate, DoublePredicate |
| Consumer<T> | T -> void | IntConsumer, LongConsumer, DoubleConsumer |
| Fuction<T,R> | T -> R | IntFunction<R>, IntToDoubleFunction, IntToLongDouble LongFunction<R>, LongToDoubleFunction, LongToIntFunction, DoubleFunction<R> ToIntFunction<T>, ToDoubleFunction<T>, ToLongFunction<T> |
| Suppliter<T> | () -> T | BooleanSupplier, IntSupplier, LongSuppliter, DoubleSuppliter |
| UnaryOperator<T> | T -> T | IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator |
| BinaryOperator<T> | (T, T) -> T | IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator |
| BiPredicate<L, R> | (L, R) -> boolean | |
| BiConsumer<T, U> | (T, U) -> void | ObjIntConsumer<T>, ObjLongConsumer<T>, ObjDoubleConsumer<T> |
| BiFunction<T, U, R> | (T, U) -> R | ToIntBiFunction<T, U>, ToLongBiFunction<T, U>, ToDoubleBiFunction<T, U> |
5、在java8中，因为泛型只能绑定到引用类型，所以就会存在一个装箱 和 拆箱的问题：
装箱：将原始类型转换为引用类型（int -> Integer）。
拆箱：将引用类型转换为原始类型（Integer -> int）。
虽然有提供自动装箱过程，但由于装箱之后的存储值会需要更多的内存，且在搜索时也需要更多的内存来获取被包裹的原始值，在性能方面会消耗，所以提供了原始类型前缀的接口DoublePredicate、IntConsumer、LongBinaryOperator、IntFunction、ToIntFunction、IntToFunction等。
6、lambda与局部变量
要在lambda中使用局部变量，需要为变量添加final修饰符，guava中也存在。
对于局部变量的限制是因为：实例变量存储在队中，而局部变量存在在栈中，如果lambda可以直接访问局部变量，而lambda又在线程中使用，则会使用到lambda的线程，可能会在分配该变量的线程将这个变量收回之后才去访问该变量。因此当java访问自由局部变量时，实际上访问的是它的副本，而不是原始值。
7、lambda匿名类与闭包
所谓闭包，也就是一个函数的实例，只是可以将这个实例作为参数传递给另一个函数，并可以无限制的访问和修改其作用域之外的变量。而lambda虽然也可以作为参数传递给另一个函数，但它不能修改定义lambda的方法的局部变量，它和闭包还是有区别的。
8、lambda与方法引用，即使用::方式直接调用对应的方法
lambda中的方法引用也用的蛮多的，如下Math::random即Math.random()函数的引用：
Stream.generate(Math::random).limit(5);
构造函数的引用：
//无参构造函数
Supplier<UserVO> su = UserVO::new;
UserVO vo01 = su.get();
//一个参数的构造函数
Function<String, UserVO> fun = UserVO::new;
UserVO vo02 = fun.apply("xiaomi");
//两个参数的构造函数
BiFunction<String, Integer, UserVO> bifun = UserVO::new;
UserVO vo03 = bifun.apply("xiaomi", 4);
//多个参数的构造函数需要自己去自定义了
DataFunction<String, String, String, String, Record> data = Record::new;
Record record = data.apply("title", "content.....", "https://www.xiaomi.com", "search");