共计 7797 个字符，预计需要花费 20 分钟才能阅读完成。
上面对几个罕用的个性做下重点阐明。
一、Lambda 表达式
百科介绍
函数编程十分要害的几个个性如下：
（1）闭包与高阶函数
函数编程反对函数作为第一类对象，有时称为 闭包 或者 仿函数（functor）对象。本质上，闭包是起函数的作用并能够像对象一样操作的对象。
与此相似，FP 语言反对 高阶函数。高阶函数能够用另一个函数（间接地，用一个 表达式）作为其输出参数，在某些状况下，它甚至返回一个函数作为其输入参数。这两种构造联合在一起使得能够用优雅的形式进行模块化编程，这是应用 FP 的最大益处。
（2）惰性计算
在惰性计算中，表达式 不是在绑定到变量时立刻计算，而是在求值程序须要产生表达式的值时进行计算。提早的计算使您能够编写可能潜在地生成无穷输入的函数。因为不会计算多于程序的其余部分所须要的值，所以不须要放心由无穷计算所导致的 out-of-memory 谬误。
（3）没有“副作用”
所谓 ” 副作用 ”（side effect），指的是函数外部与内部互动（最典型的状况，就是批改全局变量的值），产生运算以外的其余后果。函数式编程强调没有 ” 副作用 ”，意味着函数要放弃独立，所有性能就是返回一个新的值，没有其余行为，尤其是不得批改内部变量的值。
综上所述，函数式编程能够简言之是：应用不可变值和函数，函数对一个值进行解决，映射成另一个值。这个值在面向对象语言中能够了解为对象，另外这个值还能够作为函数的输出。
1.2 Lambda 表达式
官网教程地址
1.2.1 语法
残缺的 Lambda 表达式由三局部组成：参数列表、箭头、申明语句；
(Type1 param1, Type2 param2, ..., TypeN paramN) -> {statment1; statment2; //............. return statmentM;}1\. 绝大多数状况，编译器都能够从上下文环境中推断出 lambda 表达式的参数类型，所以参数能够省略：
(param1,param2, ..., paramN) -> {statment1; statment2; //............. return statmentM;}2、当 lambda 表达式的参数个数只有一个，能够省略小括号：
param1 -> {statment1; statment2; //............. return statmentM;}3、当 lambda 表达式只蕴含一条语句时，能够省略大括号、return 和语句结尾的分号：
param1 -> statment这个时候 JVM 会主动计算表达式值并返回，另外这种模式还有一种更简写法，办法援用写法，具体能够看上面的办法援用的局部。
1.2.2 函数接口
函数接口是只有一个形象办法的接口，用作 Lambda 表达式的返回类型。
接口包门路为 java.lang.function，而后接口类下面都有 @FunctionalInterface 这个注解。上面列举几个较常见的接口类。
这些函数接口在应用 Lambda 表达式时做为返回类型，JDK 定义了很多当初的函数接口，理论本人也能够定义接口去做为表达式的返回，只是大多数状况下 JDK 定义的间接拿来就能够用了。而且这些接口在 JDK8 汇合类应用流操作时大量被应用。
1.2.3 类型查看、类型推断
Java 编译器依据 Lambda 表达式上下文信息就能推断出参数的正确类型。程序仍然要通过类型查看来保障运行的安全性，但不必再显式申明类型罢了。这就是所谓的类型推断。Lambda 表达式中的类型推断，实际上是 Java 7 就引入的指标类型推断的扩大。
有时候显式写出类型更易读，有时候去掉它们更易读。没有什么法令说哪种更好；对于如何让代码更易读，程序员必须做出本人的抉择。
1.2.4 局部变量限度
Lambda 表达式也容许应用自在变量（不是参数，而是在外层作用域中定义的变量），就像匿名类一样。它们被称作捕捉 Lambda。Lambda 能够没有限度地捕捉（也就是在其主体中援用）实例变量和动态变量。但局部变量必须显式申明为 final，或事实上是 final。
为什么局部变量有这些限度？
（1）实例变量和局部变量背地的实现有一个要害不同。实例变量都存储在堆中，而局部变量则保留在栈上。如果 Lambda 能够间接拜访局部变量，而且 Lambda 是在一个线程中应用的，则应用 Lambda 的线程，可能会在调配该变量的线程将这个变量发出之后，去拜访该变量。因而，Java 在拜访自在局部变量时，实际上是在拜访它的正本，而不是拜访原始变量。如果局部变量仅仅赋值一次那就没有什么区别了——因而就有了这个限度。
（2）这一限度不激励你应用扭转内部变量的典型命令式编程模式。
1.2.5 应用示例
<pre style=”box-sizing: border-box; outline: 0px; margin: 0px 0px 20px; padding: 15px; font-weight: 400; position: relative; white-space: pre-wrap; overflow-wrap: normal; overflow: auto; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 13px; line-height: 1.42857; color: rgb(101, 123, 131); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial; word-break: break-word; border: 1px solid rgb(204, 204, 204); background: rgb(246, 246, 246);”>List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
long num = list.stream().filter( a -> a > 4).count();
System.out.println(num);</pre>
下面这段是统计 list 中大于 4 的值的个数，应用的 lambda 表达式为 a-> a> 4，这里参数 a 没有定义类型，会主动判断为 Integer 类型，而这个表达式的值会主动转化成函数接口 Predicate 对应的对象（filter 办法定义的输出参数类型），至于 stream 及相干的操作则是上面要说的流操作。它们常常一起配合进行一起数据处理。
二、流
2.1 流介绍
流是 Java API 的新成员，它容许你以申明性形式解决数据汇合（通过查问语句来表白，而不是长期编写一个实现）。就当初来说，你能够把它们看成遍历数据集的高级迭代器。此外，流还能够通明地并行处理，你无需写任何多线程代码了！
2.2 应用流
| 类别 | 办法名 | 办法签名 | 作用 |
|---|---|---|---|
| 筛选切片 | filter | Stream<T> filter(Predicate<? super T> predicate) | 过滤操作，依据 Predicate 判断后果保留为真的数据，返回后果依然是流 |
| distinct | Stream<T> distinct() | 去重操作，筛选出不反复的后果，返回后果依然是流 | |
| limit | Stream<T> limit(long maxSize) | 截取限度操作，只取前 maxSize 条数据，返回后果依然是流 | |
| skip | Stream<T> skip(long n) | 跳过操作，跳过 n 条数据，取前面的数据，返回后果依然是流 | |
| 映射 | map | <R> Stream<R> map(Function<? super T, ? extends R> mapper) | 转化操作，依据参数 T，转化成 R 类型，返回后果依然是流 |
| flatMap | <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) | 转化操作，依据参数 T，转化成 R 类型流，这里会生成多个 R 类型流，返回后果依然是流 | |
| 匹配 | anyMatch | boolean anyMatch(Predicate<? super T> predicate) | 判断是否有一条匹配，依据 Predicate 判断后果中是否有一条匹配胜利 |
| allMatch | boolean allMatch(Predicate<? super T> predicate) | 判断是否全都匹配，依据 Predicate 判断后果中是否全副匹配胜利 | |
| noneMatch | boolean noneMatch(Predicate<? super T> predicate) | 判断是否一条都不匹配，依据 Predicate 判断后果中是否所有的都不匹配 | |
| 查找 | findAny | Optional<T> findAny() | 查找操作，查问以后流中的任意元素并返回 Optional |
| findFirst | Optional<T> findFirst() | 查找操作，查问以后流中的第一个元素并返回 Optional | |
| 归约 | reduce | T reduce(T identity, BinaryOperator<T> accumulator); | 归约操作，同样两个类型的数据进行操作后返回雷同类型的后果。比方两个整数相加、相乘等。 |
| max | Optional<T> max(Comparator<? super T> comparator) | 求最大值，依据 Comparator 计算的比拟后果失去最大值 | |
| min | Optional<T> min(Comparator<? super T> comparator) | 求最小值，依据 Comparator 计算的比拟后果失去最小值 | |
| 汇总统计 | collect | <R, A> R collect(Collector<? super T, A, R> collector) | 汇总操作，汇总对应的处理结果。这里常常与 |
| count | long count() | 统计流中数据数量 | |
| 遍历 | foreach | void forEach(Consumer<? super T> action) | 遍历操作，遍历执行 Consumer 对应的操作 |
下面是 Stream API 的一些罕用操作，按场景联合 lambda 表达式调用对应办法即可。至于 Stream 的生成形式，Stream 的 of 办法或者 Collection 接口实现类的 stream 办法都能够取得对应的流对象，再进一步依据须要做对应解决。
另外上述办法如果返回是 Stream 对象时是能够链式调用的，这个时候这个操作只是申明或者配方，不产生新的汇合，这种类型的办法是惰性求值办法；有些办法返回后果非 Stream 类型，则是及早求值办法。
“为什么要辨别惰性求值和及早求值？只有在对须要什么样的后果和操 作有了更多理解之后，能力更有效率地进行计算。例如，如果要找出大于 10 的第一个数字，那么并不需要和所有元素去做比拟，只有找出第一个匹配的元素就够了。这也意味着能够在汇合类下级联多种操作，但迭代只需一次。这也是函数编程中惰性计算的个性，即只在须要产生表达式的值时进行计算。这样代码更加清晰，而且省掉了多余的操作。
这里还对上述列表操作中相干的 Optional 与 Collectors 类做下阐明。
Optional 类是为了解决常常遇到的 NullPointerException 呈现的，这个类是一个可能蕴含空值的容器类。用 Optional 代替 null 能够显示阐明后果可能为空或不为空，再应用时应用 isPresent 办法判断就能够防止间接调用的空指针异样。
Collectors 类是一个十分有用的是归约操作工具类，工具类中的办法常与流的 collect 办法联合应用。比方
groupingBy 办法能够用来分组，在转化 Map 时十分实用；partitioningBy 办法能够用来分区（分区能够当做一种非凡的分组，虚实值分组），joining 办法能够用来连贯，这个利用在比方字符串拼接的场景。
2.3 并行流
Collection 接口的实现类调用 parallelStream 办法就能够实现并行流，相应地也取得了并行计算的能力。或者 Stream 接口的实现调用 parallel 办法也能够失去并行流。并行流实现机制是基于 fork/join 框架，将问题合成再合并解决。
不过并行计算是否肯定比串行快呢？这也不肯定。理论影响性能的点包含：
（1）数据大小输出数据的大小会影响并行化解决对性能的晋升。将问题合成之后并行化解决，再将后果合并会带来额定的开销。因而只有数据足够大、每个数据处理管道破费的工夫足够多
时，并行化解决才有意义。
（2）源数据结构
每个管道的操作都基于一些初始数据源，通常是汇合。将不同的数据源宰割绝对容易，这里的开销影响了在管道中并行处理数据时到底能带来多少性能上的晋升。
（3）装箱
解决根本类型比解决装箱类型要快。
（4）核的数量
极其状况下，只有一个核，因而齐全没必要并行化。显然，领有的核越多，取得潜在性能晋升的幅度就越大。在实践中，核的数量不单指你的机器上有多少核，更是指运行时你的机器能应用多少核。这也就是说同时运行的其余过程，或者线程关联性（强制线程在某些核或 CPU 上运行）会影响性能。
（5）单元解决开销
比方数据大小，这是一场并行执行破费工夫和合成合并操作开销之间的和平。花在流中
每个元素身上的工夫越长，并行操作带来的性能晋升越显著
理论在思考是否应用并行时须要思考下面的因素。在探讨流中独自操作每一块的品种时，能够分成两种不同的操作：无状态的和有状态的。无状态操作整个过程中不用保护状态，有状态操作则有保护状态所需的开销和限度。如果能避开有状态，选用无状态操作，就能取得更好的并行性能。无状态操作包含 map、filter 和 flatMap，有状态操作包含 sorted、distinct 和 limit。这种了解在实践上是更好的，当然理论应用还是以测试后果最为牢靠。
三、办法援用
办法援用的根本思维是，如果一个 Lambda 代表的只是“间接调用这个办法”，那最好还是用名称来调用它，而不是去形容如何调用它。事实上，办法援用就是让你依据已有的办法实现来创立 Lambda 表达式。然而，显式地指明办法的名称，你的代码的可读性会更好。所以办法援用只是在内容中只有一个表达式的简写。
当 你 需 要应用 方 法 援用时，目 标援用 放 在 分隔符:: 前，办法 的 名 称放在 后 面，即 ClassName :: methodName。例如，Apple::getWeight 就是援用了 Apple 类中定义的办法 getWeight。请记住，不须要括号，因为你没有理论调用这个办法。办法援用就是 Lambda 表达式 (Apple a) -> a.getWeight() 的快捷写法。
这里有种状况须要非凡阐明，就是类的构造函数状况，这个时候是通过 ClassName::new 这种模式创立 Class 构造函数对应的援用，例如：
四、默认办法
4.1 介绍
为了以兼容形式改良 API，Java 8 中退出了默认办法。次要是为了反对库设计师，让他们可能写出更容易改良的接口。具体写法是在接口中加 default 关键字润饰。
4.2 应用阐明
默认办法因为是为了防止兼容形式改良 API 才引入，所以个别失常开发中不会应用，除非你也想改良 API，而不影响老的接口实现。当然在 JDK8 有大量的中央用到了默认办法，所以对这种写法有肯定的理解还是有帮忙的。
采纳默认办法之后，你能够为这个办法提供一个默认的实现，这样实体类就无需在本人的实现中显式地提供一个空办法，而是默认就有了实现。
4.3 注意事项
因为类能够实现多个接口，也能够继承类，当接口或类中有雷同函数签名的办法时，这个时候到底应用哪个类或接口的实现呢？
这里有三个规定能够进行判断：
(1) 类中的办法优先级最高。类或父类中申明的办法的优先级高于任何申明为默认办法的优先级。
(2) 如果无奈根据第一条进行判断，那么子接口的优先级更高：函数签名雷同时，优先选择领有最具体实现的默认办法的接口，即如果 B 继承了 A，那么 B 就比 A 更加具体。
(3) 最初，如果还是无奈判断，继承了多个接口的类必须通过显式笼罩和调用冀望的办法，显式地抉择应用哪一个默认办法的实现。不然编译都会报错。
五、办法参数反射
官网教程地址
JDK8 新增了 Method.getParameters 办法，能够获取参数信息，包含参数名称。不过为了防止.class 文件因为保留参数名而导致.class 文件过大或者占用更多的内存，另外也防止有些参数（secret/password）泄露平安信息，JVM 默认编译出的 class 文件是不会保留参数名这个信息的。
这一选项需由编译开关 javac -parameters 关上，默认是敞开的。在 Eclipse（或者基于 Eclipse 的 IDE）中能够如下图勾选保留：
六、日期 / 工夫改良
1.8 之前 JDK 自带的日期解决类十分不不便，咱们解决的时候常常是应用的第三方工具包，比方 commons-lang 包等。不过 1.8 呈现之后这个改观了很多，比方日期工夫的创立、比拟、调整、格式化、工夫距离等。
这些类都在 java.time 包下。比原来实用了很多。
6.1 LocalDate/LocalTime/LocalDateTime
LocalDate 为日期解决类、LocalTime 为工夫解决类、LocalDateTime 为日期工夫解决类，办法都相似，具体能够看 API 文档或源码，选取几个代表性的办法做下介绍。
now 相干的办法能够获取以后日期或工夫，of 办法能够创立对应的日期或工夫，parse 办法能够解析日期或工夫，get 办法能够获取日期或工夫信息，with 办法能够设置日期或工夫信息，plus 或 minus 办法能够增减日期或工夫信息；
6.2 TemporalAdjusters
这个类在日期调整时十分有用，比方失去当月的第一天、最初一天，当年的第一天、最初一天，下一周或前一周的某天等。
6.3 DateTimeFormatter
以前日期格式化个别用 SimpleDateFormat 类，然而不怎么好用，当初 1.8 引入了 DateTimeFormatter 类，默认定义了很多常量格局（ISO 打头的），在应用的时候个别配合 LocalDate/LocalTime/LocalDateTime 应用，比方想把以后日期格式化成 yyyy-MM-dd hh:mm:ss 的模式:
LocalDateTime dt = LocalDateTime.now();DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"); System.out.println(dtf.format(dt));七、参考资料
官网教程：http://docs.oracle.com/javase/tutorial/
《Java 8 实战》
《Java 8 函数式编程》