当前软件行业的气候正在不断地变化。数据量的爆炸式增长，导致程序员在开发时不得不去面对存在的各种效率问题，并希望利用多核计算机或计算集群来有效地处理。这意味着需要使用并行处理，而曾经的java对于并行的支持并不好，这使得其不得不进行进化，以适应当前的行业气候。

Java 8中开发出并行和编写更简洁通用代码的功能，下面我们一起学习。

一、java8有哪些变化

1.1 流处理

Java 8在 java.util.stream 中添加了一个Stream API。通过这个流处理有两个较为直观的好处：

1）把这样的流变成那样的流。

什么意思？简单举个小例子，在Stream提供了很多方法，此处以mapToInt举例:

IntStream mapToInt(ToIntFunction<? super T> mapper);

用法：

    public static void main(String[] args) {
        // 有如下的字符串列表
        List<String> list = Arrays.asList("adas", "ada", "gfg", "asdasd", "adsasd");
        // 打印出每个字符串的长度
        list.stream().mapToInt(s->s.length()).forEach(l-> System.out.println(l));
        // 经过Lambda替换方法后,尽量的简化代码
        list.stream().mapToInt(String::length).forEach(System.out::println);
    }

结果：

4
3
3
6
6

在上面的代码我们看到只通过一行代码就可以完成操作，最大化的简化了代码。比传统的for循环更容易查看。

2）集合处理。
几乎每个Java应用都会制造和处理集合。但集合用起来并不总是那么理想。比方说，你需要从一个列表中筛选金额较高的交易，然后按货币分组。你需要写一大堆套路化的代码来实现这个数据处理命令。

通过Stream API 可以简单的完成上面的步骤，这里举个例子：

    Map<Currency, List<Transaction>> transactionsByCurrencies =
            transactions.stream()
                    .filter((Transaction t) -> t.getPrice() > 1000)//筛选金额较高的
                    .collect(groupingBy(Transaction::getCurrency));//按照金额分组

相比于使用集合Collection，使用Stream API我们能获得两点直观的优点：
1）不需要自己去通过Collection API去迭代处理复杂的过程（外部迭代），使用流式处理的内部迭代，不需要操心循环的事情。
2）如果数据量非常庞大，那么使用集合的方式，处理将会非常慢；引入多线程将会是原本就复杂的集合迭代变得更加困难，使用Steam API可以较好的解决这一问题，看3）中的介绍。

3）在不同cpu上执行Stream操作，不需要Thread。
Stream提供了并行操作，通过下面的例子简单看下：

    public static void main(String[] args) {
        // 有如下的字符串列表
        List<String> list = Arrays.asList("adas", "ada", "gfg", "asdasd", "adsasd");
        // 打印出每个字符串的长度
        //list.stream().mapToInt(s->s.length()).forEach(l-> System.out.println(l));
        // 经过Lambda替换方法后,尽量的简化代码
        long startTime = System.currentTimeMillis();
        list.stream().mapToInt(String::length).forEach(l -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(l);
        });
        System.out.println("耗时：" + (System.currentTimeMillis() - startTime));
    }

结果：

4
3
3
6
6
耗时：5104

这时我们添加上并行操作parallel，代码如下：

    public static void main(String[] args) {
        // 有如下的字符串列表
        List<String> list = Arrays.asList("adas", "ada", "gfg", "asdasd", "adsasd");
        // 打印出每个字符串的长度
        //list.stream().mapToInt(s->s.length()).forEach(l-> System.out.println(l));
        // 经过Lambda替换方法后,尽量的简化代码
        long startTime = System.currentTimeMillis();
        list.stream().mapToInt(String::length).parallel().forEach(l -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(l);
        });
        System.out.println("耗时：" + (System.currentTimeMillis() - startTime));
    }

结果：

3
6
4
3
6
耗时：1096

总体耗时基本是五分之一，或者可以使用parallelStream()：

list.parallelStream().mapToInt(String::length).forEach....

关于具体的内容后面会详细讲解。

1.2 用行为参数化把代码（方法）传递给方法

Java 8增加了把方法（你的代码）作为参数传递给另一个方法的能力。我们把这一概念称为行为参数化。

下面会简单讲解时什么意思。

1.2.1 函数

编程语言中的函数一词通常是指方法，尤其是静态方法。

Java 8中新增了函数：值的一种新形式。

编程语言的本质就是操作值。按照传统的编程语言历史，我们以java举例：例如int，long，double这些可以直接被作为参数传递的值，都是一等值（一等公民）；而还有很多涉及到结构的内容，例如方法和类等，不能作为参数传递，这些被称为二等公民。

java8中增加了新的功能，将二等公民添加到运行时传递，则二等公民就成为了一等公民。

1.2.1.1 方法和 Lambda 作为一等公民

Java 8的设计者决定允许方法作为值，让编程更轻松。此外，让方法作为值也构成了其他若干Java 8功能（如 Stream ）的基础。

我们介绍的Java 8的第一个新功能是方法引用。

举个例子，你想要筛选一个目录中的所有隐藏文件。 File类里面有一个叫作 isHidden 的方法。我们可以把它看作一个函数，接受一个 File ，返回一个布尔值。但要用它做筛选，你需要把它包在一个 FileFilter 对象里，然后传递给 File.listFiles方法，如下所示：

    public void test(){
        File[] hiddenFiles = new File(".").listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.isHidden();
            }
        });
    }

在java8当中我们可以使用如下的方式：

    public void test(){
        File[] hiddenFiles = new File(".").listFiles(File::isHidden);
    }

你已经有了函数 isHidden ，因此只需用Java 8的方法引用 :: 语法（即“把这个方法作为值”）将其传给 listFiles 方法，我们也开始用函数代表方法了。

当使用File::isHidden时，其实创建了一个方法引用，与对象引用类似，我们就可以将其作为一等公民传递。

除了允许（命名）函数成为一等值外，Java 8还体现了更广义的将函数作为值的思想，包括Lambda（匿名函数）。直白说，将匿名函数作为一等值。

将匿名函数传递有什么好处呢？写代码的时候相信都会遇到一种情况，当你只需要一个简单的运算的时候，还需要去重新定义一个类或者方法吗？如果没有方便的类或者方法可用的话，lambda就能帮助你使语法更简洁。

1.2.1.2 使用案例

假设有一个手机仓库，里面放了很多品牌的手机，包括苹果、华为等。现在我们需要筛选出华为手机有多少。那么需要些如下的代码：

    public List<Phone> brandFilter(){
        List<Phone> phones = new ArrayList<>();
        List<Phone> results = new ArrayList<>();
        for (Phone phone : phones) {
            if ("华为".equals(phone.getBrand())){
                results.add(phone);
            }
        }
        return results;
    }

如果又需要筛选黑色的手机，那么还需要写下面的方法：

    public List<Phone> colorFilter(){
        List<Phone> phones = new ArrayList<>();
        List<Phone> results = new ArrayList<>();
        for (Phone phone : phones) {
            if ("黑色".equals(phone.getColor())){
                results.add(phone);
            }
        }
        return results;
    }

这样一来重复代码就会很多了，如果我们使用java8，可以像下面这样写：

package com.cloud.bssp.java8.stream;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 * @description： 挑选手机
 * @author：weirx
 * @date：2021/10/15 16:02
 * @version：3.0
 */
public class ChoicePhone {

    public static void main(String[] args) {
        List<Phone> list = new ArrayList<>();
        list.add(new Phone("苹果", "黑色"));
        list.add(new Phone("华为", "黑色"));
        List<Phone> blackPhones = phoneFilter(list, ChoicePhone::isBlack);
        System.out.println(blackPhones.toString());
        List<Phone> huaweiPhones = phoneFilter(list, ChoicePhone::isHuawei);
        System.out.println(huaweiPhones.toString());
    }

    @Data
    static class Phone {
        private String brand;

        public Phone(String brand, String color) {
            this.brand = brand;
            this.color = color;
        }

        private String color;
    }

    /**
     * 筛选华为方法
     */
    public static boolean isHuawei(Phone phone) {
        return "华为".equals(phone.getBrand());
    }

    /**
     * 筛选黑色方法
     */
    public static boolean isBlack(Phone phone) {
        return "黑色".equals(phone.getColor());
    }

    /**
     * 手机过滤方法，参数是手机list和Predicate<T>函数
     */
    public static List<Phone> phoneFilter(List<Phone> phones, Predicate<Phone> p) {
        List<Phone> results = new ArrayList<>();
        for (Phone phone : phones) {
            if (p.test(phone)) {
                results.add(phone);
            }
        }
        return results;
    }
}

前面的代码传递了方法 Apple::isGreenApple （它接受参数 Apple 并返回一个boolean ）给 filterApples ，后者则希望接受一个 Predicate<Apple> 参数。

Java 8也会允许你写 Function<Apple,Boolean>。

关于上面的代码请同学们细细体会啊，一遍看不懂就多看几遍。

前面就简单介绍了lambda的作用，像我们前面的例子中，只是一个判断的方法实在没有必要单独提供一个方法去维护，所以我们可以使用lambda的方式进行优化，就不需要单独定义判断方法isBlack和isHuawei了,使代码更简洁，如下所示：

List<Phone> blackPhones = phoneFilter(list, (Phone p) -> p.getColor().equals("黑色"));
List<Phone> huaweiPhones = phoneFilter(list, (Phone p) -> p.getBrand().equals("华为"));

List<Phone> blackPhones = phoneFilter(list, (Phone p) -> 
  p.getColor().equals("黑色") || p.getBrand().equals("华为")
);

1.3 默认方法

在java8之前的版本当中，接口被一个类实现，必须要求这个类实现该接口的全部方法，如果一个接口增加一个方法,那么所有的实现类都需要增加这个方法的实现。那么如何解决这个问题呢？

既然不想让实现类自己实现这个方法，那么只能由接口自己来实现了。这就给开发者提供了一个扩充接口的方式，而不会破坏现有的代码。在java8中使用关键字default来表示这个关键点。

比如在java8当中，我们可以直接调用List接口中的sort方法：

    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的变化有个简单的认识，后续文章会逐渐深入到细节。

如果对您有帮助，给点个赞吧，感谢！！