Java8

@FunctionalInterface
public interface Predicate<T> {
 boolean test(T t);
}
@FunctionalInterface
public interface Consumer<T> {
 void accept(T t);
}
@FunctionalInterface
public interface Function<T, R> {
 R apply(T t);
}
 public static void main(String[] args) throws IOException {
 String oneLine = processFile((BufferedReader br)->br.readLine()+br.readLine());
 List<Integer> l = map(Arrays.asList("lambdas","in","action"),
 (String s)->s.length());
 }
 public static <T,R> List<R> map(List<T> list, Function<T,R> f){
 List<R> result = new ArrayList<>();
 for (T t : list) {
 //这里是某个行为,可以将每个key的字符长度统计出来
 result.add(f.apply(t));
 }
 return result;
 }

流简介

ist<String> title = Arrays.asList("java8","in","action");
 Stream<String> s = title.stream();
 s.forEach(System.out::println);
 s.forEach(System.out::println);//会打印错误

使用流

Optional

收集器例子的整体回顾

自定义流的使用流程

并行流

stream.parallel().filter(...).sequential().map(...).parallel() .reduce(); 

使用分支/合并框架的最佳做法

修改代码可阅读性

位于第九章的默认方法

当拥有相同方法前面的default方法的借口被实现的时候,子类调用会使用哪一个方法

Optional 的意义

基础类型的Optional对象,以及为什么应该避免使用它们

Future

快速查询的流程简介

寻找更好的方案

将两个不相干的CompletableFuture合并

更加丰富的时间工具

函数式编程的说明

高阶函数与一等函数

副作用和高阶函数
第7章中我们了解到传递给流操作的函数应该是无副作用的,否则会发生各种各样的问题
(比如错误的结果,有时由于竞争条件甚至会产生我们无法预期的结果)。这一原则在你使用高
阶函数时也同样适用。编写高阶函数或者方法时,你无法预知会接收什么样的参数——一旦传
入的参数有某些副作用,我们将会一筹莫展!如果作为参数传入的函数可能对你程序的状态产
生某些无法预期的改变,一旦发生问题,你将很难理解程序中发生了什么;它们甚至会用某种
难于调试的方式调用你的代码。因此,将所有你愿意接收的作为参数的函数可能带来的副作用
以文档的方式记录下来是一个不错的设计原则,最理想的情况下你接收的函数参数应该没有任
何副作用!
现在我们转向讨论科里化:它是一种可以帮助你模块化函数、提高代码重用性的技术。

科里化的理论定义
科里化1是一种将具备2个参数(比如,x和y)的函数f转化为使用一个参数的函数g,并
且这个函数的返回值也是一个函数,它会作为新函数的一个参数。后者的返回值和初始函数的
返回值相同,即f(x,y) = (g(x))(y)。
当然,我们可以由此推出:你可以将一个使用了6个参数的函数科里化成一个接受第2、4、
6号参数,并返回一个接受5号参数的函数,这个函数又返回一个接受剩下的第1号和第3号参数
的函数。
一个函数使用所有参数仅有部分被传递时,通常我们说这个函数是部分应用的(partially
applied)。

这一节中,我们会探讨函数式编程中如何使用数据结构。这一主题有各种名称,比如函数式
数据结构、不可变数据结构,不过最常见的可能还要算持久化数据结构(不幸的是,这一术语和
数据库中的持久化概念有一定的冲突,数据库中它代表的是"生命周期比程序的执行周期更长的
数据")。
我们应该注意的第一件事是,函数式方法不允许修改任何全局数据结构或者任何作为参数
传入的参数。为什么呢?因为一旦对这些数据进行修改,两次相同的调用就很可能产生不同的
结构——这违背了引用透明性原则,我们也就无法将方法简单地看作由参数到结果的映射。

Stream 的延迟计算

public static Stream<Integer> primes(int n) {
 return Stream.iterate(2, i -> i + 1)
 .filter(MyMathUtils::isPrime)
 .limit(n);
}
public static boolean isPrime(int candidate) {
 int candidateRoot = (int) Math.sqrt((double) candidate);
 return IntStream.rangeClosed(2, candidateRoot)
 .noneMatch(i -> candidate % i == 0);
} 

不过这一方案看起来有些笨拙:你每次都需要遍历每个数字,查看它能否被候选数字整除(实
际上,你只需要测试那些已经被判定为质数的数字)。
理想情况下,Stream应该实时地筛选掉那些能被质数整除的数字。这听起来有些异想天开,
不过我们一起看看怎样才能达到这样的效果。
(1) 你需要一个由数字构成的Stream,你会在其中选择质数。
(2) 你会从该Stream中取出第一个数字(即Stream的首元素),它是一个质数(初始时,这个
值是2)。
(3) 紧接着你会从Stream的尾部开始,筛选掉所有能被该数字整除的元素。
(4) 最后剩下的结果就是新的Stream,你会继续用它进行质数的查找。本质上,你还会回到
第一步,继续进行后续的操作,所以这个算法是递归的。
注意,这个算法不是很好,原因是多方面的1。不过,就说明如何使用Stream展开工作这个
目的而言,它还是非常合适的,因为算法简单,容易说明。让我们试着用Stream API对这个算法
进行实现。

如果以并发的方式在同一个流上执行多种操作。