为什么要关心Java8
自1996年JDK（1.0）发布以来，Java已经受到了学生、项目经理和 程序员等一大批活跃的用户的欢迎。这一语言极富活力，不断被用在大大小小的项目里。从Java1.1（1997）年一直到Java7（2011）年，Java通过增加新功能，不断得到良好的升级。Java8则是在2014年3月发布的。那么问题来了：为什么你应该关心Java8？
是的，Java一直被吐槽写起来太啰嗦，没有IDE的快捷键和自动生成，简直就是在用生命写代码，因为太浪费时间。 例如，最简单的HelloWorld：
public class HelloWorld { public static void main (String[] args) { System.out.println("HelloWorld"); } } 复制代码
都要这写么多代码，不使用快捷键或者语法模板去生成，真的很浪费时间。（初学者请忽略）
所以，为了解决这个问题，Java8中推出了核心新特性之一：Lambda（匿名函数） Lambda表达式，是一个很不错很实用的一个新特性，如果你使用了这个新特性，也许会爱不释手。
举个例子，比如我们对苹果进行按照重量进行排序，也许我们会这样写：
private static List<Apple> apples = Arrays.asList(new Apple(100, "red"), new Apple(101, "green"), new Apple(132, "green"), new Apple(90, "green"), new Apple(122, "red") ); 复制代码
Collections.sort(apples, new Comparator<Apple>() { public int compare(Apple o1, Apple o2) { return o1.getWeight() < o2.getWeight() ? -1 : ((o1.getWeight() == o2.getWeight()) ? 0 : 1); } }); 复制代码
在Java8里，你可以这样写，这样写看起来更接近问题的描述：
apples.sort(Comparator.comparing(Apple::getWeight)); 复制代码
是不是有点心动啊，本来需要五六行解决的排序的代码，现在只要一行即可！趁热打铁，继续吧。 Java8里面将代码传递给方法的功能（同时也能够放回代码并将其包含在数据结构中），还让我们能够使用一整套技巧，通常称为函数式编程。
现在你需要筛选一个目录中的所有隐藏文件，你会怎么做? 大部分人立马会想到，File类中不就是有一个isHidden的方法吗？使用这个方法就可以判断哪些是隐藏文件啦。 是的，如下所示：
File[] files = new File("D:\\.").listFiles(new FileFilter() { @Override public boolean accept(File pathname) { return pathname.isHidden(); } }); 复制代码
看起来很简单，很明了嘛！那还可以不可以继续优化简短一下呢？答案是当然可以的。 如下所示：
File[] files = new File("D:\\.").listFiles(File::isHidden); 复制代码
太酷了，有了函数isHidden，因此只需要使用Java8的方法引用语法::（即“把这个方法作为值”）将其传给listFiles方法就可以了。
代码传递：一个例子
来看看一个例子，看看它是如何帮你你写程序的。依旧使用刚刚对苹果排序的代码。现在，要做的是筛选出所有的绿苹果，也许你会这一个这样的方法filterGreenApples：
public static List<Apple> filterGreenApples(List<Apple> apples) { List<Apple> result = new ArrayList<>(); for (Apple apple : apples) { if ("green".equals(apple.getColor())) { result.add(apple); } } return result; } 复制代码
在Java8之前，基本上都是这样写的，看起来也没什么毛病。但是，现在又要筛选一下重量超过120克的苹果。哦，一想很简单嘛，把上面的代码复制、粘贴改一下就好啦：
public static List<Apple> filterHeavyApples(List<Apple> apples) { List<Apple> result = new ArrayList<>(); for (Apple apple : apples) { if (apple.getWeight() > 120) { result.add(apple); } } return result; } 复制代码
虽然简单，但是还是出现了一些重复地方，看起来不太好。这两段代码的差异只是条件不同，那么只需要把接受重量的上下限作为参数传递给filter就可以了，使用Java8来优化一下这些代码：
public static void main (String[] args) { // 筛选出绿色苹果 List<Apple> greenApples = filterApples(apples, FilterApples::isGreenApple); System.out.println(greenApples); // 筛选重量大于120克的苹果 List<Apple> heavyApples = filterApples(apples, FilterApples::isHeavyApple); System.out.println(heavyApples); } public static boolean isGreenApple(Apple apple) { return "green".equals(apple.getColor()); } public static boolean isHeavyApple(Apple apple) { return apple.getWeight() > 120; } public static List<Apple> filterApples(List<Apple> apples, Predicate<Apple> predicate) { List<Apple> result = new ArrayList<>(); for (Apple apple : apples) { if (predicate.test(apple)) { result.add(apple); } } return result; } interface Predicate<T> { /** * 根据给定的参数计算此谓词 * * @param t * @return */ boolean test(T t); } 复制代码
在这段代码中，自定义了一个接口Predicate，中文意思是谓词：
什么是谓词？
前面的代码传递了方法Apple::isGreenApple（它接受参数Apple并返回一个boolean）给filterApples。后者希望接受一个Predicate参数。谓词（predicate）在数学上常常用来代表一个类似函数的东西，它接受一个参数值，并返回true或false。
当然，Java8中已经有了一个Predicate接口，因此，我们也不需要去定义一个这样的接口啦。
使用自定义的Predicate接口中的方法，你创建了一个方法引用，你无须去关注test方法是如何实现的，你只要知道你引用的某个方法即可。
从方法传递到Lambda
接着上次的Predicate，继续来了解一下，如果继续简化代码。
把方法作为值来传递虽然很有用，但是要是有很多类似与isHeavyApple和isGreenApple这种可能只用一两次的方法定义一堆确实有点烦人。为了解决这个问题，Java8它引入了一套新记法（匿名函数或Lambda），然你可以这样写：
List<Apple> isRedApples = filterApples(FilteringApples.apples, apple -> "red".equals(apple.getColor())); 复制代码
或者是:
List<Apple> appleList = filterApples(FilteringApples.apples, apple -> apple.getWeight() < 120 && "red".equals(apple.getColor())); 复制代码
甚至，你都可以不需要使用filterApples这个方法了，直接使用Stream中的filter方法就可以解决了：
List<Apple> isGreenApple = apples.stream().filter(apple -> "green".equals(apple.getColor())) .collect(Collectors.toList()); 复制代码
酷，看起来很不错。所以，你甚至都不需要为只用一次的方法写定义；这样的代码看起来更简洁、更清晰，因为你用不着去找自己到底传递了什么代码。
流
在刚刚筛选苹果的过程中，就有使用到Stream（流）其中的一个方法，这个Stream和InputStream、OutputStream是两个完全不同的东西。Stream它是Java8中的一个核心新特，它是一套新的用来处理集合的API，有很多类似与filter这样的方法而且使用起来非常的简单和简洁，可以简化大部分代码并且在并行的情况下利用多核CPU，能很有效的提升对集合处理的性能。
本章只是简单的介绍了一下流的使用方式，至于流的详细用法后面的章节会提到的。
现在，有一串字符串，需要进行筛选并且转为大写以进行排序，在Java8之前是我们是这么干的：
List<String> stringList = Arrays.asList("a1", "a2", "b1", "c1", "c2", "c4", "c3"); List<String> cList = new ArrayList<>(); for (String s : stringList) { // 筛选出以c开头的字符串 if (s.startsWith("c")) { // 将以c开头的字符串转为大写，添加到集合 cList.add(s.toUpperCase()); } } // 排序 Collections.sort(cList); // 遍历打印 for (String s : cList) { System.out.println(s); } 复制代码
太棒了，只需要短短的一行代码就可以完成！但是，使用Stream它也是有缺点的，它的性能不如foreach的效率高为了解决这个问题，Stream支持并。使用并行能极大的利用多核CPU的优势，例如说：这些代码原本只是用单核进行处理，现在有一台8核的CPU电脑，那么它的处理速度就会是单核的八倍。
我们来进行比较一下，生成一个0-100的数字并写入到文件中，循序流VS并行流谁的效率更高.
循序流:
long startTime = System.currentTimeMillis(); OutputStream out = new FileOutputStream(new File("D:/integer1.txt")); IntStream.rangeClosed(0, 100) .forEach(i -> { try { Thread.sleep(100L); out.write(i); } catch (IOException | InterruptedException e) { e.printStackTrace(); } }); long endTime = System.currentTimeMillis(); System.out.println("循序流：" + (endTime - startTime)); 复制代码
并行流：
long startTime = System.currentTimeMillis(); OutputStream out = new FileOutputStream(new File("D:/integer2.txt")); IntStream.rangeClosed(0, 100) .parallel().forEach(i -> { try { Thread.sleep(100L); out.write(i); } catch (IOException | InterruptedException e) { e.printStackTrace(); } }); long endTime = System.currentTimeMillis(); System.out.println("并行流：" + (endTime - startTime)); 复制代码
执行结果（I5-6200U的笔记本上执行结果）：
循序流：10251 并行流：2620 复制代码
效率明显要比循序流快很多嘛！但是，并行流并不是万能的，如果把sleep去掉后并且数字加到100万，你会发现运行的时间比循序流还要长。
去掉sleep并且生成的数字是0-100万，所消耗的时间：
循序流：2775 并行流：3346 复制代码
至于为什么有时候并行流效率比循序流还低，这个以后的文章会解释。
默认方法
默认方法是Java8中的一个新特性，它的出现使得接口的升级变得平滑了，因为子类不是必须再去显式的实现接口中的方法了。
例如：在Java8中，你可以直接调用List接口中的sort方法、它是用Java8 List接口中如下所示的默认方法实现的:
default void sort(Comparator<? super E> c) { Object[] a = this.toArray(); Arrays.sort(a, (Comparator) c); ListIterator<E> i = this.listIterator(); for (Object e : a) { i.next(); i.set((E) e); } } 复制代码
这意味着List的任何实体类都不需要显式的实现sort，而在以前的Java版本中，除非提供了sort的实现，否则这些实体类都无法编译通过。但是，默认方法也存在着一些问题，一个类可以实现多个接口，那么好几个接口多有同样的默认方法，那么这是否意味着Java中有了某种形式的多继承？如果是多继承，那么会不会出现像C++中菱形继承的问题？这些问题以后的文章中都会有解释和解决方案。
第一章总结：
- 了解了Java8中的一些核心新特性，例如：Lambda表达式、Stream、默认方法。
- 了解了Lambda表达式和Stream为代码带来的简洁性。
- 并行流带来的好处。
- Java8中的默认方法带来的好处。
