一 内部类
二 匿名内部类
给匿名内部类传递参数的时候，若该形参需要被内部类使用，则该形参必须是final类型的。
参考：http://www.cnblogs.com/chenssy/p/3390871.html
三 函数式编程
相对于命令式编程关注解决问题的步骤，函数式编程式面向数学的抽象，关心数据（代数结构）之间的映射关系。
函数式编程中的函数，不是指命令式编程中的函数（C++中的函数本质上是一段子程序），而是指数学中的函数，即自变量的映射（一种东西与另一种东西的映射关系）。也就是说，一个函数的值仅取决于函数参数的值，而不依赖于其他状态。
在函数式语言中，函数被称为一等函数，与其他数据类型一样，处于平等地位。可以在任何地方定义，函数内或函数外；可以赋值给其他变量；可以作为参数，传入另一个函数，或者作为别的函数的返回值。
四 java Lambda表达式
引用： https://www.cnblogs.com/snowInPluto/p/5981400.html
4.1简介
Java8的最大变化是引入了Lambda表达式，一种紧凑，传递行为的方式。
先看一个示例：
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("button clicked");
}
});使用 Lambda 表达式，我们就可以简写为
button.addActionListener(event -> System.out.println("button clicked"));4.2 Lambda 表达式
示例：
ActionListener oneArgument = event -> System.out.println("button clicked");
BinaryOperator<Long> add = (x, y) -> x + y;
BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y;4.3 函数接口
上面的例子中提到了ActionListener接口，我们看一下它的代码：
public interface ActionListener extends EventListener {
/**
* Invoked when an action occurs.
*/
public void actionPerformed(ActionEvent e);
}ActionListener 只有一个抽象方法，该接口也继承自一个没有任何方法的父接口：eventListener.
写为匿名内部类的形式。
jdk8里面提供了一些常用的函数接口，
| 接口 | 参数 | 返回类型 | 描述 |
|---|---|---|---|
| Predicate | T | boolean | 用于判别一个对象。比如求一个人是否为男性 |
| Consumer | T | void | 用于接收一个对象进行处理但没有返回，比如接收一个人并打印他的名字 |
| Function | T | R | 转换一个对象为不同类型的对象 |
| Supplier | None | T | 提供一个对象 |
| UnaryOperator | T | T | 接收对象并返回同类型的对象 |
| BinaryOperator | (T, T) | T | 接收两个同类型的对象，并返回一个原类型对象 |
其中 Cosumer 与 Supplier 对应，一个是消费者，一个是提供者。
Predicate 用于判断对象是否符合某个条件，经常被用来过滤对象。
Function 是将一个对象转换为另一个对象，比如说要装箱或者拆箱某个对象。
UnaryOperator 接收和返回同类型对象，一般用于对对象修改属性。BinaryOperator 则可以理解为合并对象
五 主要应用场景
5.1 stream 简介
在程序中，集合的处理是很普遍从操作。JDK8 中，引入了流的概念，这与IO中的流并不相同。所以继承自Collection的接口都可以转变为Stream.
举例示意：
假设我们有一个 List 包含一系列的 Person，Person 有姓名 name 和年龄 age 连个字段。现要求这个列表中年龄大于 20 的人数。
以往写法：
long count = 0;
for (Person p : persons) {
if (p.getAge() > 20) {
count ++;
}
}现在的写法：
long count = persons.stream()
.filter(person -> person.getAge() > 20)
.count();5.2 Stream 常用操作
Stream 的方法分为两类。一类叫惰性求值，一类叫及早求值。
判断一个操作是惰性求值还是及早求值很简单：只需看它的返回值。如果返回值是 Stream，那么是惰性求值。其实可以这么理解，如果调用惰性求值方法，Stream 只是记录下了这个惰性求值方法的过程，并没有去计算，等到调用及早求值方法后，就连同前面的一系列惰性求值方法顺序进行计算，返回结果。
通用形式为：
Stream.惰性求值.惰性求值. ... .惰性求值.及早求值5.2.1 collect(toList())
collect(toList()) 方法由 Stream 里的值生成一个列表，是一个及早求值操作。可以理解为 Stream 向 Collection 的转换。
注意这边的 toList() 其实是 Collectors.toList()，因为采用了静态倒入，看起来显得简洁。
List<String> collected = Stream.of("a", "b", "c")
.collect(Collectors.toList());
assertEquals(Arrays.asList("a", "b", "c"), collected);5.2.2 map
如果有一个函数可以将一种类型的值转换成另外一种类型，map 操作就可以使用该函数，将一个流中的值转换成一个新的流。
List<String> collected = Stream.of("a", "b", "hello")
.map(string -> string.toUpperCase())
.collect(toList());
assertEquals(asList("A", "B", "HELLO"), collected);5.2.3 filter
List<String> beginningWithNumbers =
Stream.of("a", "1abc", "abc1")
.filter(value -> isDigit(value.charAt(0)))
.collect(toList());
assertEquals(asList("1abc"), beginningWithNumbers);5.2.4 flatMap
flatMap 方法可用 Stream 替换值，然后将多个 Stream 连接成一个 Stream。
List<Integer> together = Stream.of(asList(1, 2), asList(3, 4))
.flatMap(numbers -> numbers.stream())
.collect(toList());
assertEquals(asList(1, 2, 3, 4), together);5.2.5 max和min
Stream 上常用的操作之一是求最大值和最小值。Stream API 中的 max 和 min 操作足以解决这一问题。
List<Integer> list = Lists.newArrayList(3, 5, 2, 9, 1);
int maxInt = list.stream()
.max(Integer::compareTo)
.get();
int minInt = list.stream()
.min(Integer::compareTo)
.get();
assertEquals(maxInt, 9);
assertEquals(minInt, 1);这里有 2 个要点需要注意：
1 max 和 min 方法返回的是一个 Optional 对象（对了，和 Google Guava 里的 Optional 对象是一样的）。Optional 对象封装的就是实际的值，可能为空，所以保险起见，可以先用 isPresent() 方法判断一下。Optional 的引入就是为了解决方法返回 null 的问题。
2 Integer::compareTo 也是属于 Java 8 引入的新特性，叫做 方法引用（Method References）。在这边，其实就是 (int1, int2) -> int1.compareTo(int2) 的简写。
5.2.6 reduce
reduce 操作可以实现从一组值中生成一个值。在上述例子中用到的 count、min 和 max 方法,因为常用而被纳入标准库中。事实上，这些方法都是 reduce 操作
int result = Stream.of(1, 2, 3, 4)
.reduce(0, (acc, element) -> acc + element);
assertEquals(10, result);
int result = Stream.of(1, 2, 3, 4)
.reduce(1, (acc, element) -> acc * element);
assertEquals(24, result);六 数据并行化操作
Stream 的并行化也是 Java 8 的一大亮点。数据并行化是指将数据分成块，为每块数据分配单独的处理单元。这样可以充分利用多核 CPU 的优势。
nt sumSize = Stream.of("Apple", "Banana", "Orange", "Pear")
.parallel()
.map(s -> s.length())
.reduce(Integer::sum)
.get();
assertEquals(sumSize, 21);七 其他
Stream 转换为 List 是很常用的操作，其他 Collectors 还有很多方法，可以将 Stream 转换为 Set, 或者将数据分组并转换为 Map，并对数据进行处理。也可以指定转换为具体类型，如 ArrayList, LinkedList 或者 HashMap。甚至可以自定义 Collectors，编写自己的收集器。
7.2 元素排序
List<Integer> list = Lists.newArrayList(3, 5, 1, 10, 8);
List<Integer> sortedList = list.stream()
.sorted(Integer::compareTo)
.collect(Collectors.toList());
assertEquals(sortedList, Lists.newArrayList(1, 3, 5, 8, 10));http://zh.lucida.me/blog/java-8-lambdas-insideout-language-features/ ?????????????????????????????????