java8概述：有哪些核心新特性？为什么会有这些特性？

绝地灬酷狼 2022-05-12 11:08 175阅读 0赞

java8可以说是自java诞生以来，发生最大变化的一个版本，关键是这一变化对于我们程序员来说是一个很大的福音：java8提供的新功能能够帮助我们写出更清晰、更简洁的代码（这貌似是程序员一生都在追求的东西吧，而java8让java开发者的这一追求瞬间向前跨了一大步）。

那么java8究竟提供了哪些核心新特性来让程序员轻易就可以写出更清晰、更简洁的代码呢？

先来看一个小需求"对库存中的苹果按重量升序排列"在java8中及java8之前的实现，感受一下java8在编码上给我们带来的简化。

java8以前的做法：

1.  `Collections.sort(inventory, new Comparator<Apple>() {`
2.  `public int compare(Apple a1, Apple a2){`
3.  `return a1.getWeight().compareTo(a2.getWeight());`
4.  `}`
5.  `});`

在java8里面，上面这5行代码可以简化为一行：

1.  `inventory.sort(comparing(Apple::getWeight));`

不对比就不知道一种技术的先进性，这样对比一下，java8的魅力尽显。

下面将逐一介绍java8里的一些核心新特性或概念，但尽限于概述，本系列文章的后续篇章中会逐一展开对java8的解析。

*  函数式编程
 *  Lambda表达式
 *  流（stream）
 *  接口（interface）默认方法

> **函数式编程**

函数式编程是一种编程风格，它的核心是把函数作为值。而java8把函数式编程的精华融入到了java语法中，你可以将代码传递给方法，也能够返回代码并将其包含在数据结构中，同时这种被函数式编程界称为函数的代码，在java8中可以被来回传递并加以组合，以产生强大的编程语汇，使我们可以用更少的时间，编写更清楚、更简洁的代码。

下面来看一个**传递代码**的例子：

下面代码的两个方法分别过滤出库存中绿色的苹果与重量大于150g的苹果：

1.  `/**`
2.  `*过滤出绿色苹果`
3.  `*/`
4.  `public static List<Apple> filterGreenApples(List<Apple> inventory){`
5.  `List<Apple> result = new ArrayList<>();`
6.  `for (Apple apple: inventory){`
7.  `//颜色等于green则加入筛选结果中`
8.  `if ("green".equals(apple.getColor())) {`
9.  `result.add(apple);`
10. `}`
11. `}`
12. `return result;`
13. `}`
14.  
15. `/**`
16. `*过滤出重量大于150g的苹果`
17. `*/`
18. `public static List<Apple> filterHeavyApples(List<Apple> inventory){`
19. `List<Apple> result = new ArrayList<>();`
20. `for (Apple apple: inventory){`
21. `//重量是否大于150g则加入筛选结果中`
22. `if (apple.getWeight() > 150) {`
23. `result.add(apple);`
24. `}`
25. `}`
26. `return result;`
27. `}`

可以看到这两个方法唯一的不同是if条件不一样，复制粘贴虽然也方便，但当类似的筛选需求增多，如过滤出红色的苹果、过滤出甜的苹果等，重复的代码也会非常多，且非常容易出错。

下面看怎么通过传递代码，一个过滤方法实现上面两个过滤需求：

1.  `public static boolean isGreenApple(Apple apple) {`
2.  `return "green".equals(apple.getColor());`
3.  `}`
4.  `public static boolean isHeavyApple(Apple apple) {`
5.  `return apple.getWeight() > 150;`
6.  `}`
7.  `/**`
8.  `*java8里的谓词，在此列出是为了看得更清晰，可能从java.util.function包中直接导入`
9.  `*/`
10. `public interface Predicate<T>{`
11. `boolean test(T t);`
12. `}`
13. `/**`
14. `*通用的过滤方法`
15. `*@param inventory`
16. `*@param p 方法作为Predicate参数p传递进去`
17. `*/`
18. `static List<Apple> filterApples(List<Apple> inventory,`
19. `Predicate<Apple> p) {`
20. `List<Apple> result = new ArrayList<>();`
21. `for (Apple apple: inventory){`
22. `//苹果符合p的条件即加入筛选结果中`
23. `if (p.test(apple)) {`
24. `result.add(apple);`
25. `}`
26. `}`
27. `return result;`
28. `}`

上面代码中的过滤方法filterApples有两个参数：第一个参数`List<Apple> inventory`是需要过的数据集合；第二个参数`Predicate<Apple> p` 接收过滤方法或代码的参数，它实际上是java8里的谓词（Predicate）。

于是使用filterApples筛选苹果的代码变成了下面这样：

1.  `//筛选绿色苹果`
2.  `filterApples(inventory, Apple::isGreenApple);`
3.  `//筛选较重的苹果`
4.  `filterApples(inventory, Apple::isHeavyApple);`

这就是java8方法的传递，在该系列后续的文章中介绍它是怎样工作的。

如果你要增加筛选红色的苹果，只需在Apple model中增加一个返回boolean值的方法isRedApple方法就可以了。

> **Lambda表达式**

前文中把方法作为值来传递显然很有用，但要是为类似于isHeavyApple和isGreenApple这种可能只用一两次的短方法写一堆定义有点儿烦人。于是java8引入了一套新  
写法（匿名函数或Lambda），因此，过滤绿苹果与较重苹果的代码可以写成：

1.  `//筛选绿苹果`
2.  `filterApples(inventory, (Apple a) -> "green".equals(a.getColor()) );`
3.  `//筛选较重的苹果`
4.  `filterApples(inventory, (Apple a) -> a.getWeight() > 150 );`
5.  `//更复杂的，同时过滤重量与颜色`
6.  `filterApples(inventory, (Apple a) -> a.getWeight() < 80 && "brown".equals(a.getColor()) );`

上述3个filterApples方法调用，传递给其的第二个参数，都使用了**匿名的Lambda表达式**。

**那么Lambda表达式是什么？**

我们暂时可以把Lambda表达式理解为没有声明名称的方法或匿名类，它可以作为参数传递给一个方法。在本系列后续的文章中会详细介绍Lambda的语法及用途。

> **流（stream）**

先来感受一下java8中流API的魅力。

*需求：*  
从交易列表中筛选出金额较高的交易，然后按货币种类分组。

*java8以前Collection API实现：*

1.  `//新建一个hashmap，用于存放筛选结果`
2.  `Map<Currency, List<Transaction>> transactionsByCurrencies=new HashMap<>();`
3.  `//遍历交易列表`
4.  `for (Transaction transaction : transactions) {`
5.  `//筛选出金额较高的交易`
6.  `if(transaction.getPrice() > 1000){`
7.  `//获取交易的货币`
8.  `Currency currency = transaction.getCurrency();`
9.  `//获取该货币的交易分组`
10. `List<Transaction> transactionsForCurrency=transactionsByCurrencies.get(currency);`
11. `//若该货币的交易分组为空，则新建一个`
12. `if (transactionsForCurrency == null) {`
13. `transactionsForCurrency = new ArrayList<>();`
14. `transactionsByCurrencies.put(currency,transactionsForCurrency);`
15. `}`
16. `//将交易加入对应分组List`
17. `transactionsForCurrency.add(transaction);`
18. `}`
19. `}`

*java8中Stream Api的实现：*

1.  `import static java.util.stream.Collectors.toList;`
2.  `Map<Currency, List<Transaction>> transactionsByCurrencies =`
3.  `transactions.stream()//从交易列表中生成流`
4.  `.filter((Transaction t) -> t.getPrice() > 1000)//过滤出金额较高的交易`
5.  `.collect(groupingBy(Transaction::getCurrency));//将交易按货币分组`

从上面Collection API与Stream Api实现同一个需求的例子，可以知道它们两者有如下差异：

*  ">**Stream Api使用起来比Collection API更直观，更简洁**  
    对于上面的Collection API实现方式，我们很难一眼看出来这些代码是做什么的，但流api却可以，它看起来就像数据库查询式编程，只是使用java语法。
    
     
 *  ">**它们两者处理数据的方式不同**  
    使用集合api需要我们自己去实现迭代的过程，在这个过程中，我们需要使用for-each去一个个遍历列表中的所有元素并根据条件if判断作出不同的处理，这种迭代方式称为***外部迭代***，因为整个迭代的过程是暴露在我们程序员眼前的；与之相对应是stream api的***内部迭代***，我们不用理会迭代的过程，迭代在stream api的内部进行。  
    注：以上两点是通过代码对比就能很容易看出的差异，下面列出的差异是更深层次的
    
     
 *  ">**Collection API在并行编程中需要自己处理多线程带来的所有问题，而Stream Api却在库内部实现了并行化的处理，我们只需简单调用一个方法即可**  
    关于多线程编程，java1.0里线程和锁，java5里添加线程池与并发集合等，java7里添加了分支/合并（fork/join）框架，使得并行变得很实用，但使用起来仍然很困难且容易出错，而java8中的流Api支持许多处理数据的并行操作，且使用相当简单，如：
    
     
    
    1.  `import static java.util.stream.Collectors.toList;`
    2.  `List<Apple> heavyApples = inventory.parallelStream().filter((Apple a) -> a.getWeight() > 150).collect(toList());`
    
    ">我们只需将stream()方法改成parallelStream()即可。
    
     
 *  ">**Stream Api在处理大数据时更有优势**  
    一方面是因为在处理大数据时，流Api能够轻易实现并行处理，速度更快；另一方面，流api无需像集合api一样，一次性将数据全部加载进内存后才能处理。
    
     
 *  ">虽然流api与现在集合api的行为差不多：都能访问数据序列，但它们使用的侧重却有***本质的不同***：**Collection主要是为了存储和访问数据，而Stream则主要用于描述对数据的计算**  
    使用集合时要对集合中数据进行一些统计计算需要我们自己去实现，而流却帮我们实现了通用的计算方法，我们只需调用相应的方法即可。

> **接口（interface）默认方法**

默认方法是接口为定义在接口中的方法提供的默认实现，使用default关键词声明，有了默认方法，接口就可以包含实现类没有提供实现的方法签名。

在前文中，多次在集合中上使用stream()方法，如inventory.stream()，但在Java 8之前， List并没有stream或parallelStream方法，它实现的Collection接口也没有，但编译器却不报错，这就是新规则“默认方法”在起作用了。

一个**默认方法的示例**：

在Java 8里，可以直接对List调用sort方法。它是用Java 8 List接口中如下所示的默认方法实现的。

1.  `default void sort(Comparator<? super E> c) {`
2.  `Collections.sort(this, c);`
3.  `}`

有了这个默认方法，List的任何实体类都不需要显式实现sort，而在以前的Java版本中，除非提供了sort的实现，否则这些实体类在重新编译时都会失败。

以上就介绍完了java8中的核心新特性，那为什么java8的设计者会加入这些新特性呢？

一句话概括就是：新的语言会出现，旧语言则会被取代，除非它们不断演变，以顺应时代的发展。

展开来看，有如下两点：

*  日新月异的计算应用场景：多核和处理大型数据集（大数据）
 *  改进的压力：函数式比命令式更适应新的体系架构

所以有了stream api，它使java开发者更简便地进行并行编程，与这个硬件多核心的时代相匹配，同时满足了如今大数据时代的需要，流比集合处理大数据时更占优势。