上面对几个罕用的个性做下重点阐明。
一、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函数式编程》