作为一个对java8不是特别理解的人，花了两个星期全面的读了下《java8实战》做了个流水的笔记。
现在线上的java都是基于java8的，以后尽量使用java8的特性编程。
一下的内容都是基于markdown的。。。
# java8 实战
## 2 通过行为参数传递代码
行为的参数化
1 值参数化
2 类，匿名类，lambda
## 3 lambda表达式
lambda表达式
Comparator<Apple> byWeight =(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
函数式接口
仅仅定义了一个抽象方法
函数描述符
函数式接口的抽象方法的签名基本上就是Lambda表达式的签名。我们将这种抽象方法叫作 函数描述符。
(Apple, Apple) -> int
只有在需要函数式接口的时候才可以传递Lambda
环绕式执行
try{}{
}
java的函数式接口之predicate
test(T t)
函数式接口Consumer
accept(T t)
函数式接口Function
R apply(T t)
抽象方法Supplier
T get()
装箱和非装箱
IntPredicate
IntConsume
int
函数类型检查：符合函数特征即可用
函数变量不推荐使用局部变量，使用时加上final
闭包
闭包就是一个函数的实例，且它可以无限 制地访问那个函数的非本地变量
方法引用
闭包就是一个函数的实例，且它可以无限 制地访问那个函数的非本地变量
三类方法引用
1 静态方法
A::XX
2 指向任意类型实例方法的方法引用
B:xx
3 现有对象的实例方法的方法引用
c:xx
构造函数引用
A::new
List<Integer> weights = Arrays.asList(7, 3, 4, 10);
List<Apple> apples = map(weights, Apple::new);
数组构造函数和父类调用
自动生成比较器
Comparator.comparing((Apple a) -> a.getWeight());
inventory.sort(comparing(Apple::getWeight).reversed());
inventory.sort(comparing(Apple::getWeight)
.reversed()
.thenComparing(Apple::getCountry));
Predicate谓词复合
Predicate<Apple> redAndHeavyAppleOrGreen =
readApple.and(a->a.getWeight() > b.getWeight())
.or(a -> "green".equals(a.getColor()));
function函数复合
andThen,先执行，再执行另外一个函数
先把给定的函数用作compose的参数里面给的那个函 数，然后再把函数本身用于结果。
## 4 流
流的定义
1 java的api
2 声明处理数据集合
3 高级的数据迭代器
流的基本定义
1 元素序列 filter sorted map
2 源。数据源：
3 数据处理操作
filter map reduce find match sort
limit
4 流水线
5 内部迭代
流与集合
1 流只能遍历一次
2 集合的外部迭代，流的内部迭代
流的操作
1 中间操作
filter map limit sorted distinct
2 终止操作
collect
foreach
count
## 5 使用流
谓词筛选
filter
distinct
limit
skip
映射
map
flatmap
查找和匹配
allMatch anyMatch noneMatch
findFirst findAny
optional操作
isPresent
ifPresent
T get()
T orElse(T other)
规约
reduce(init, func)
reduce(min/max)
count
所有的操作
filter
distinct
skip
limit
map
flatMap
sorted
anyMatch
noneMatch
allMatch
findAny
findFirst
forEach
collect
reduce
count
数值流
mapToInt
boxed
IntStream.rangeClosed
构建流
stream.of();
stream.empty();
Arrays.stream(numes);
File.lines(
xxx).distinct().count
函数创建流
stream.iterate
Stream.generate
## 6 使用流收集数据
### 6.1 收集器 & 规约 汇总
总数
Collectors.counting()
最大的 Collectors.maxBy(Comparator.comparingInt(Transaction::getValue))
Collectors.sumInt()
averagingInt
joining
reducie
redcing()
menu.stream().mapToInt(Dish::getCalories).sum();
### 6.2分组
groupingBy 分组，多级分组
按子组收集数据
将收集到的结果转换为另外一种类型collectAndThen
### 6.3 分区
boolean分词作为分区：partitioningBy
collection的静态方法
toList
toSet
toCollection
counting
summingint
averagingInt
joning
maxBy
minBy
reducing
collectionAndThen
groupingBy
partitioningBy
收集器接口
自己实现java的stream
```
public interface Collector<T, A, R> {
Supplier<A> supplier();
BiConsumer<A, T> accumulator();
Function<A, R> finisher();
BinaryOperator<A> combiner();
Set<Characteristics> characteristics();
}
```
## 7 并行数据处理与性能
并行流
parallel
并行流性能影响
1 减少数字的装箱和开箱
2 共享可变状态会影响并行流以及并行计算。
3 如果有疑问需要测量
4 有些操作并行比线性差
5 流水线总成本
6 较小数据量时不适应
7 背后的数据结构是否易于分解
8 中间合并步骤的代价
流的源，可分解性
ArrayList 极佳
LinkedList 差
IntStream.range 极佳
Stream.iterate 差
HashSet 好
TreeSet 好
分支/合并框架
它实现ExecutorService接口，把任务分配给ForkJoinPool
任务实现返回结果：RecursiveTask<R>
不返回结果 RecursiveAction
forkjoin的业务逻辑
```
if (任务足够小或不可分) {
顺序计算该任务
} else {
将任务分成两个子任务
递归调用本方法，拆分每个子任务，等待所有子任务完成
合并每个子任务的结果
}
```
使用分支/合并框架的最佳做法
1 对一个任务调用join方法会阻塞调用方，直到该任务做出结果。两任务均开始后再调用
2 不应该在RecursiveTask内部使用ForkJoinPool的invoke方法。你应该始终直接调用compute或fork方法，只有顺序代码才应该用invoke来启动并行计算。
3 对子任务调用fork方法可以把它排进ForkJoinPool。
4 调试使用分支/合并框架的并行计算可能有点棘手。
5 和并行流一样，你不应理所当然地认为在多核处理器上使用分支/合并框架就比顺序计算快。
原理工作窃取
spliterator 可分迭代器
```
public interface Spliterator<T> {
boolean tryAdvance(Consumer<? super T> action);
Spliterator<T> trySplit();
long estimateSize();
int characteristics();
}
```
## 8 重构，测试和调试
改善可读写和灵活性
1 使用匿名类代替lambda
2 stream的方法引用
3 切换到stream
增加代码的灵活性
1 使用函数式接口
2 延迟执行
3 环绕执行
使用lambda重构设计模式
1 策略模式，函数式接口
2
lambda表达式使用
peek日志调试流
## 9 默认方法
接口可以使用默认反复
默认接口方法冲突的问题
1 类最优
2 子接口最优
3 显示覆盖
## 10 Optional取代null
创建
提取
map 获取Optional里面的数据
flatMap 从其他部分获取Optional
get
orElse
orElseGet
orElseThroww
ifPresent
filer过滤
详细操作
empty
filter
flatMAP
get
ifPresent
isPresent
map
of ofNullable orElse orElseGet orElseThrow
OptionalUtility工具
## 11 CompletableFuture
future工具
```
ExecutorService executor = Executors.newCachedThreadPool(); Future<Double> future = executor.submit(new Callable<Double>() {
public Double call() {
})
try {
Double result = future.get(1, TimeUnit.SECONDS);
} catch (ExecutionException ee) { // 计算抛出一个异常
} catch (InterruptedException ie) { // 当前线程在等待过程中被中断
} catch (TimeoutException te) { // 在Future对象完成之前超过已过期
}
```
future的局限性
1 Future很难直接表述多个Future 结果之间的依赖性，开发中，我们经常需要达成以下目的：
2 将两个异步计算合并为一个（这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果）
3 等待 Future 集合中的所有任务都完成。
4 仅等待 Future 集合中最快结束的任务完成，并返回它的结果。
CompletableFuture
只有当每个操作很复杂需要花费相对很长的时间
基本用法
```
Async结尾的方法都是可以异步执行的，如果指定了线程池，会在指定的线程池中执行，如果没有指定，默认会在ForkJoinPool.commonPool()中执行。下面很多方法都是类似的，不再做特别说明。
四个静态方法用来为一段异步执行的代码创建CompletableFuture对象，方法的参数类型都是函数式接口，所以可以使用lambda表达式实现异步任务
runAsync方法：它以Runnabel函数式接口类型为参数，所以CompletableFuture的计算结果为空。
supplyAsync方法以Supplier<U>函数式接口类型为参数，CompletableFuture的计算结果类型为U。
```
```
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor);
```
## 12 新的日期和时间API
新的日期库出现的原因
新日期类
LocationDate LocationTime instant Duration period
时间范围 Period Duration
操作和解析
不同时区和历法
## 13 函数式的思考
实现和维护系统
1 类的结构合理
2 提供指标
3 耦合性，内聚性
难题
1 共享的可变数据
命令式编程
声明式编程
称述问题
函数式编程：用函数进行编程的方式
1 修改本地变量
2 只引用不可修改的对象
3 函数或者方法不能抛出异常 使用Option<T>
引用的透明性：同一值，输出不变
面向对象和函数式的对比
1 万物是对象
2 引用透明，不应该有修改对象
考虑编程问题时，采用函数式的方法，关注函数的输入参数以及输出结果
递归和迭代
函数编程不会包含while和for的迭代器
## 14 函数式编程的技巧
### 无处不在的函数
高阶函数：至少一个函数为参数，返回一个函数，注意函数式的副作用
科里化：返回函数
### 持久化数据结构
函数式方法不能修改传入参数或者全局参数
### stream的延迟计算？
stream只允许使用一次
stream不允许递归定义
延迟列表
### 模式匹配
### 杂项
缓存或记忆表
stream的特定
1.stream不存储数据
2.stream不改变源数据
3.stream的延迟执行特性
## 15 面向对象和函数式编程的混合
jvm平台函数式语言 scala
scala 更好的流式编程，更好的函数式编程
## 16 结论以及java的未来
尽量使用新特性