你要知道的Java8 匿名内部类、函数式接口、lambda表达式与Stream API都在这里

矫情吗；* 2022-05-25 12:48 92阅读 0赞

转载自：

https://blog.csdn.net/u014205968/article/details/71484312

https://blog.csdn.net/u014205968/article/details/71484374

转载请注明出处 [http://blog.csdn.net/u014205968/article/details/71484312][http_blog.csdn.net_u014205968_article_details_71484312]

本文主要讲解`Java8 Stream API`，但是要讲解这一部分需要匿名内部类、lambda表达式以及函数式接口的相关知识，本文将分为两篇文章来讲解上述内容，读者可以按需查阅。

*  [Java 匿名内部类、lambda表达式与函数式接口][http_blog.csdn.net_u014205968_article_details_71484312]
 *  [Java Stream API][]

本文是该系列博文的第一篇[Java 匿名内部类、lambda表达式与函数式接口][http_blog.csdn.net_u014205968_article_details_71484312]，主要讲解`Java`的`匿名内部类`、`lambda表达式`以及`函数式接口`，第二篇文章[Java Stream API][]主要讲解`Java Stream API`。

### 匿名内部类 ###

`匿名内部类`适用于那些只需要使用一次的类，比如设计模式下的命令模式，往往通过定义一系列接口进行调用，有时有的命令只会执行一次就不再执行，这个时候如果单独定义一个类就显得过于复杂并且编译会生成这个类的`.class`文件，不利于管理，这种情况下使用`匿名内部类`就能够很好的简化编程并且不会编译生成单独的`.class`文件。

接下来看一个例子：

interface Programmer { 
        void listLanguages();
        void introduceMyself();
    }
    
    class MyProgrammer implements Programmer { 
        public void listLanguages() {
            System.out.println("Objective-C Swift Python Go Java");
        }
    
        public void introduceMyself() {
            System.out.println("My Name is Jiaming Chen");
        }
    }
    
    public class HelloWorld {    
        static void info(Programmer programmer)
        {
            programmer.listLanguages();
            programmer.introduceMyself();
        }
    
        public static void main(String[] args)
        {   
            info(new MyProgrammer());
        }
    }

上面这个例子为了执行`info`函数定义了一个实现了`Programmer`接口的类`MyProgrammer`，如果它只执行一次这样就显得过于复杂，如果采用`匿名内部类`就会在很大程度上简化编程，首先介绍一下`匿名内部类`的基础语法：

new 需要实现的接口() | 父类构造器()
    {
        //需要实现的方法或重载父类的方法
    }

`匿名内部类`的语法很简单，必须要实现一个接口或者继承一个类，可以看到使用了`new`关键词，因此在创建`匿名内部类`的同时会创建一个该类的实例，并且只能创建一个实例，创建完成后这个`匿名内部类`就不能再使用，因此，`匿名内部类`不能是抽象类，由于`匿名内部类`没有类名所以也不能定义构造函数，但是可以在定义`匿名内部类`的时候调用父类的有参构造器也可以定义初始化块用于初始化父类的成员变量。下面这个栗子是将上述代码修改为`匿名内部类`的实现方式：

class MyProgrammer implements Programmer
    {
        public void listLanguages() {
            System.out.println("Objective-C Swift Python Go Java");
        }
    
        public void introduceMyself() {
            System.out.println("My Name is Jiaming Chen");
        }
    }
    
    public class HelloWorld
    {   
        static void info(Programmer programmer)
        {
            programmer.listLanguages();
            programmer.introduceMyself();
        }
    
        public static void main(String[] args)
        {   
            info(new Programmer(){
                public void listLanguages() {
                    System.out.println("Objective-C Swift Python Go Java");
                }
    
                public void introduceMyself() {
                    System.out.println("My Name is Jiaming Chen");
                }
            });
        }
    }

通过对比发现，使用`匿名内部类`比重新定义一个新类更加简洁，在创建`匿名内部类`的时候可以调用父类的有参构造函数，栗子如下：

abstract class Programmer
    {
        protected String name;
    
        public Programmer(String name)
        {
            this.name = name;
        }
    
        public abstract void listLanguages();
        public abstract void introduceMyself();
    }
    
    public class HelloWorld
    {   
        static void info(Programmer programmer)
        {
            programmer.listLanguages();
            programmer.introduceMyself();
        }
    
        public static void main(String[] args)
        {   
            int age = 22;
            Programmer p = new Programmer("Jiaming Chen"){
                public void listLanguages()
                {
                    System.out.println("Objective-C Swift Python Go Java");
                }
                public void introduceMyself()
                {
                    System.out.println("My Name is " + this.name + " and I'm " + age + " years old.");
                    //age = 2;
                }
            };
            info(p);
            //age = 23;
        }
    }

上述栗子首先定义了一个抽象父类，并且该抽象父类只有一个构造函数，因此在创建`匿名内部类`的时候需要显示调用该构造函数，这样就可以在`匿名内部类`内部使用父类定义的成员变量了，`匿名内部类`也可以使用外部变量，在`Java8`中上述栗子中的`age`会自动声明为`final`类型，这称为`effectively final`，只要`匿名内部类`访问了一个局部变量，这个局部变量无论是否被`final`修饰它都会自动被声明为`final`类型，不允许任何地方进行修改，`Java`与其他语言相比在闭包内访问外部变量的局限更大，因为只能是`final`类型，比如`OC`在`block`内部也可以捕获外部变量，`swift`也有一套闭包值捕获机制，都可以对捕获的值进行修改或权限的设置，`Java`的局限性太大。

### lambda表达式 ###

`Java8`引入了`lambda表达式`，在其他语言中，比如`python`、`swift`都支持`lambda表达式`，这个特性用起来也非常方便和简洁。接下来举一个常见的对一个列表进行排序的例子：

class MyComparator implements Comparator<String> { 
        public int compare(String o1, String o2)
        {
            return o1.compareTo(o2);
        }
    }
    
    public class HelloWorld {    
        public static void main(String[] args)
        {   
            ArrayList<String> list = new ArrayList<>();
            list.add("Objective-C");
            list.add("Swift");
            list.add("Python");
            list.add("Golang");
            list.add("Java");
            list.sort(new MyComparator());
            list.forEach(System.out::println);
            /* 输出:(下面的代码的输出结果是一致的，不再赘述) Golang Java Objective-C Python Swift */
        }
    }

在开发中经常会对一个集合类型进行排序操作，调用集合的`sort`方法时需要传入一个实现了`Comparator`接口的参数，因此上述栗子就定义了一个类`MyComparator`并且这个类实现了`Comparator`接口，因此可以创建一个`MyComparator`的对象用于排序操作，不难发现这样做非常复杂需要重新定义一个全新的类，经过前文的介绍这里完全可以用`匿名内部类`来代替，关于最后一行代码`list.forEach(System.out::println);`在后文会介绍，这里先卖个关子，它的作用就是遍历整个集合并输出。接下来看一下使用`匿名内部类`实现的方式：

public class HelloWorld
    {   
        public static void main(String[] args)
        {   
            ArrayList<String> list = new ArrayList<>();
            list.add("Objective-C");
            list.add("Swift");
            list.add("Python");
            list.add("Golang");
            list.add("Java");
            list.sort(new Comparator<String>(){
                public int compare(String o1, String o2) {
                    return o1.compareTo(o2);
                }           
            });
            list.forEach(System.out::println);
        }
    }

结果同上，显而易见，采用了`匿名内部类`更加的方便了，代码简洁明了，那有没有再简介一点的办法呢？答案当然是肯定的，那就是使用`lambda`表达式，栗子如下：

public class HelloWorld {    
        public static void main(String[] args)
        {   
            ArrayList<String> list = new ArrayList<>();
            list.add("Objective-C");
            list.add("Swift");
            list.add("Python");
            list.add("Golang");
            list.add("Java");
            list.sort((String o1, String o2)->{
                return o1.compareTo(o2);
            });
            list.forEach(System.out::println);
        }
    }

通过上述代码发现，`sort`函数传入的参数是一个`lambda`表达式，整个代码非常类似前文中我们实现的`compare`函数，但是我们不需要再写`new Comparator<String()`这样繁琐的代码，也不需要写函数名，因此`lambda表达式`可以很好的替代`匿名内部类`，不难发现`lambda表达式`由三部分组成：

*  首先是参数列表，这个参数列表与要实现的方法的参数列表一致，因为系统已经知道了你需要实现哪一个方法因此可以省略形参类型，当只有一个参数时也可以省略圆括号，但是当没有形参时圆括号不可以省略
 *  接下来是一个`->`符号，该符号用于分隔形参列表与函数体，该符号不允许省略。
 *  最后就是代码体了，如果代码体只有一行代码就可以省略掉花括号，并且如果方法需要有返回值连`return`关键词都可以省略，系统会自动将这一行代码的结果返回。

通过上面的讲解，我们就可以写一个更加简洁`lambda表达式`了，栗子如下：

public class HelloWorld {    
        public static void main(String[] args)
        {   
            ArrayList<String> list = new ArrayList<>();
            list.add("Objective-C");
            list.add("Swift");
            list.add("Python");
            list.add("Golang");
            list.add("Java");
            list.sort((s1, s2)->s1.compareTo(s2));
            list.forEach(System.out::println);
        }
    }

上面的代码我们省略了形参的类型，由于只有一行我们同时省略了花括号和`return`语句，整个代码相比使用`匿名内部类`更加简洁了。到这里有同学可能会问了，`lambda表达式`是怎么知道我们实现的是接口的哪一个方法？

`lambda表达式`的类型也被称为`目标类型 target type`，该类型必须是`函数式接口 Functional Interface`，`函数式接口`代表有且只有一个抽象方法，但是可以包含多个默认方法或类方法的接口，因此使用`lambda表达式`系统一定知道我们实现的接口的哪一个方法，因为实现的接口有且只有一个抽象方法供我们实现。

`函数式接口`可以使用注释`@FunctionalInterface`来要求编译器在编译时进行检查，是否只包含一个抽象方法。`Java`提供了大量的`函数式接口`这样就能使用`lambda表达式`简化编程。`lambda表达式`的目标类型必须是`函数式接口`，`lambda表达式`也只能为`函数式接口`创建对象因为`lambda表达式`只能实现一个抽象方法。

前文介绍了在使用`lambda表达式`时，如果代码体只有一行代码可以省略花括号，如果有返回值也可以省略`return`关键词，不仅如此，`lambda表达式`在只有一条代码时还可以引用其他方法或构造器并自动调用，可以省略参数传递，代码更加简洁，引用方法的语法需要使用`::`符号。`lambda表达式`提供了四种引用方法和构造器的方式：

*  引用对象的方法 `类::实例方法`
 *  引用类方法 `类::类方法`
 *  引用特定对象的方法 `特定对象::实例方法`
 *  引用类的构造器 `类::new`

举个栗子：

public class HelloWorld {    
        public static void main(String[] args)
        {   
            ArrayList<String> list = new ArrayList<>();
            list.add("Objective-C");
            list.add("Swift");
            list.add("Python");
            list.add("Golang");
            list.add("Java");
            //list.sort((s1, s2)->s1.compareTo(s2));
            list.sort(String::compareTo);
            list.forEach(System.out::println);
        }
    }

对比上述两行代码，第一个`sort`函数传入了一个`lambda表达式`用于实现`Comparator`接口的`compare`函数，由于该实现只有一条代码，因此可以省略花括号以及`return`关键字。第二个`sort`方法则直接引用了对象的实例方法，语法规则为`类::实例方法`，系统会自动将`函数式接口`实现的方法的所有参数中的第一个参数作为调用者，接下来的参数依次传入引用的方法中即自动进行`s1.compareTo(s2)`的方法调用，明显第二个`sort`函数调用更加简洁明了。

最后一行代码`list.forEach(System.out::println);`则引用了类方法，集合类的实例方法`forEach`接收一个`Consumer`接口对象，该接口是一个`函数式接口`，只有一个抽象方法`void accept(T t);`，因此可以使用`lambda表达式`进行调用，这里引用`System.out`的类方法`println`，引用语法`类::类方法`，系统会自动将实现的`函数式接口`方法中的所有参数都传入该类方法并进行自动调用。

再举一个栗子：

@FunctionalInterface
    interface Index
    {
        int index(String subString);
    }
    
    @FunctionalInterface
    interface Generator
    {
        String generate();
    }
    
    public class HelloWorld
    {   
        static int getIndex(Index t, String subString)
        {
            return t.index(subString);
        }
    
        static String generateString(Generator g)
        {
            return g.generate();
        }
    
        public static void main(String[] args)
        {   
            String str = "Hello World";
            System.out.println(getIndex(str::indexOf, "e"));
            System.out.println(generateString(String::new).length());
        }
    }

这个栗子似乎没有任何实际意义，就是为了演示引用特定对象的实例方法和引用类的构造器。接口`Index`和`Generator`都是`函数式接口`，因此可以使用`lambda表达式`。对于`getIndex`方法需要传入一个实现`Index`接口的对象和一个子串，在调用时首先定义了一个字符串`Hello World`，然后引用了这个对象的实例方法`indexOf`，这个时候系统会自动将这个特定对象作为调用者然后将所有的参数因此传入该实力方法。   
引用构造器的方法也很简单`类::new`，不再赘述。

## 总结 ##

本文主要讲解`匿名内部类`、`lambda表达式`、`函数式接口`以及`lambda表达式`的`方法引用`和`构造器引用`，通过几个例子逐步深入，逐步简化代码的编写，可以发现`Java8`提供的`lambda表达式`是如此的强大。接下来的一篇文章会对`Java8`新增的`Stream API`进行讲解，`Stream`的流式API支持并行，对传统编程方式进行了改进，可以编写出更简洁明了的高性能代码。有兴趣的读者可以阅读[Java Stream API][]。

# 你要知道的Java8 匿名内部类、函数式接口、lambda表达式与Stream API都在这里 #

转载请注明出处 [http://blog.csdn.net/u014205968/article/details/71484374][Java Stream API]

*  [Java 匿名内部类、lambda表达式与函数式接口][http_blog.csdn.net_u014205968_article_details_71484312]
 *  [Java Stream API][]

本文是本系列文章的第二篇，主要讲解`Stream API`，在学习`Stream API`之前要求读者有一定的`lambda表达式`基础，如果相关知识不了解可以参考本系列文章的第一篇[Java 匿名内部类、lambda表达式与函数式接口][http_blog.csdn.net_u014205968_article_details_71484312]。

## Stream API ##

`Java8`新增的`stream`功能非常强大，这里的`stream`和`Java IO`中的`stream`是完全不同概念的两个东西。本文要讲解的`stream`是能够对集合对象进行各种串行或并发聚集操作，`Stream API`依赖于前一篇文讲解的`  lambda表达式`，只有当两者结合时才能极大的提高编程效率并且代码更易理解和维护。`Stream API`支持串行和并发的集合操作，这也是响应了现在多核处理器的需求，`Stream API`的并发采用的是我们熟悉的`fork/join`模式，手动编写并行代码很复杂也很容易出错，但是采用`Stream API`来进行集合对象上的并发操作你不需要编写任何多线程代码就能够轻而易举的实现并发操作，从而提高代码的运行效率，也极大的简化了编程难度。

### 聚集操作 ###

在实际开发中，我们经常对一个集合内的对象进行一系列的操作，比如排序、查找、过滤、重组、数据统计等操作，通常情况下我们可能会采用`for循环`遍历的方式来逐一进行操作，这样的代码即复杂又难以维护，如果对性能有要求再进行多线程代码的编写就更加的复杂了，同时也更容易出错。

下面举一个栗子：

class User
    {
        private String userID;
        private boolean isVip;
        private int balance;
    
        public User(String userID, boolean isVip, int balance)
        {
            this.userID = userID;
            this.isVip = isVip;
            this.balance = balance;
        }
    
        public boolean isVip()
        {
            return this.isVip;
        }
    
        public String getUserID()
        {
            return this.userID;
        }
    
        public int getBalance()
        {
            return this.balance;
        }
    }
    
    public class HelloWorld
    {   
        public static void main(String[] args)
        {
            ArrayList<User> users = new ArrayList<>();
            users.add(new User("2017001", false, 0));
            users.add(new User("2017002", true, 36));
            users.add(new User("2017003", false, 98));
            users.add(new User("2017004", false, 233));
            users.add(new User("2017005", true, 68));
            users.add(new User("2017006", true, 599));
            users.add(new User("2017007", true, 1023));
            users.add(new User("2017008", false, 9));
            users.add(new User("2017009", false, 66));
            users.add(new User("2017010", false, 88));
    
            //普通实现方式
            ArrayList<User> tempArray = new ArrayList<>();
            ArrayList<String> idArray = new ArrayList<>(3);
            for (User user: users)
            {
                if (user.isVip())
                {
                    tempArray.add(user);
                }
            }
            tempArray.sort(new Comparator<User>(){
                public int compare(User o1, User o2) {
                    return o2.getBalance() - o1.getBalance();
                }
            });
            for (int i = 0; i < 3; i++)
            {
                idArray.add(tempArray.get(i).getUserID());
            }
            for (int i = 0; i < idArray.size(); i++)
            {
                System.out.println(idArray.get(i));
            }
    
            //Stream API实现方式
            //也可以使用parallelStream方法获取一个并发的stream，提高计算效率
            Stream<User> stream = users.stream();
            List<String> array = stream.filter(User::isVip).sorted((t1, t2) -> t2.getBalance() - t1.getBalance()).limit(3).map(User::getUserID).collect(Collectors.toList());
            array.forEach(System.out::println);
        }
    }

上述代码首先定义了一个用户类，这个类保存用户是否是VIP、用户ID以及用户的余额，假如现在有一个需求，将VIP中余额最高的三个用户的ID找出来，传统的思路一般就是创建一个临时的`list`，然后逐一判断，将所有的VIP用户加入到这个临时的`list`中，然后调用集合类的`sort`方法根据余额排序，最后再遍历三次获取余额最高的三个用户的ID等信息。这样的方法看似简单，但代码写出来即混乱也不好看，如果用户量非常大，有几千万甚至几个亿，这样遍历的方式效率就会特别低，如果手工加上多线程的并发操作，代码就更加复杂了。

上述代码的第二部分使用`Stream API`的方式来计算，首先通过集合类获取了一个普通的`stream`，如果数据量大可以使用`parallelStream`方法获取一个并发的`stream`，这样接下来的计算程序员不需要编写任何多线程代码系统会自动进行多线程计算。获取了`stream`以后首先调用`filter`方法找到是否为VIP用户然后对VIP用户进行排序操作，接下来限制只获取三个用户的信息，然后将用户映射为用户ID，最后将该`stream`转换为集合类，两种实现方式的结果完全一样，但是明显的采用`Stream API`的代码更加简洁易懂。

`Stream API`的编写大量依赖`lambda表达式`以及`lambda表达式`的`引用方法`和`引用构造器`，如果您对这一块不理解可以查阅文章[Java 匿名内部类、lambda表达式与函数式接口][http_blog.csdn.net_u014205968_article_details_71484312]。

### 如何使用Stream ###

A sequence of elements supporting sequential and parallel aggregate operations

*  1

上面是`Java`文档中定义的`Stream`，可以看出，`Stream`就是元素的集合，并且可以采用串行或并行的方式进行聚集操作。在使用时我们可以将`Stream`理解为一个迭代器，只不过这个迭代器更加高级，能够对其中的每一个元素进行我们规定的计算。

当我们要使用`Stream API`时，首先需要创建一个`Stream`对象，可以通过集合类的实例方法`stream`或`parallelStream`来获取一个普通的串行`stream`或是并行`stream`。也可以使用`Stream`、`IntStream`、`LongStream`或`DoubleStream`创建一个`Stream`对象，`Stream`是一个比较通用的流，可以代表任何引用数据类型，其他的则是指特定类型的流。最常用的就是通过一个集合类型来获取相应类型的`Stream`。

流的操作分为`中间操作 Intermediate`和`结束操作 Terminal`：

*  中间操作（Intermediate）：一个流可以采用链式调用的方式进行数个中间操作，主要目的就是打开流然后对这个流进行各种过滤、映射、聚集、统计操作等，如上述代码中的`filter`、`map`操作等。每一个操作结束后都会返回一个新的流，并且这些操作都是lazy的，也就是在进行结束操作时才会真正的进行计算，一次遍历就计算出所有结果。
 *  结束操作（Terminal）：一个流只能执行一个结束操作，当执行了结束操作以后这个流就不能再被执行，也就是说不能再次进行中间操作或结束操作，所以结束操作一定是流的最后一个操作，如上述代码中的`collect`方法。当开始执行结束操作的时候才会对流进行遍历并且只一次遍历就计算出所有结果。

### Stream的创建 ###

*  通过集合类创建

通过集合创建`Stream`的方法是我们最常用的，集合类的实例方法`stream`和`parallelStream`可以获取相应的流。

ArrayList<User> users = new ArrayList<>();
    users.add(new User("2017001", false, 0));
    users.add(new User("2017002", true, 36));
    users.add(new User("2017003", false, 98));
    Stream<User> stream = users.stream();

*  通过数组构造

String[] str = {
       "Hello World", "Jiaming Chen", "Zhouhang Cheng"};
    Stream<String> stream = Stream.of(str);

*  通过单个元素构造

Stream<Integer> stream = Stream.of(1, 2, 3, 4);

*  Stream与Array和Collection的转换

一般我们都会对`Stream`进行结束操作，用于获取一个数组或是集合类，通过数组和集合类创建`Stream`前文已经介绍了，这里介绍通过`Stream`获取数组或集合类。

String[] str = {
       "Hello World", "Jiaming Chen", "Zhouhang Cheng"};
    Stream<String> stream = Stream.of(str);
    
    String[] strArray = stream.toArray(String[]::new);
    List<String> strList = stream.collect(Collectors.toList());
    ArrayList<String> strArrayList = stream.collect(Collectors.toCollection(ArrayList::new));
    Set<String> strSet = stream.collect(Collectors.toSet());

上面的代码分别将流转换为数组、List、ArrayList和Set类型，具体的参数可以查看官方API文档。

### Stream 常用方法 ###

*  filter

`filter`的栗子前面已经举过了，`filter`函数需要传入一个实现`Predicate`函数式接口的对象，该接口的抽象方法`test`接收一个参数并返回一个`boolean`值，为`true`则保留，`false`则剔除，前文举的栗子就是判断是否为VIP用户，如果是就保留，不是就剔除。   
原理如图所示：

![filter][]

*  map、flatMap

`map`的栗子前面已经举过了，`map`函数需要传入一个实现`Function`函数式接口的对象，该接口的抽象方法`apply`接收一个参数并返回一个值，可以理解为映射关系，前文举的栗子就是将每一个用户映射为一个`userID`。   
原理如图所示：

![map][]

`map`方法是一个一对一的映射，每输入一个数据也只会输出一个值。   
`flatMap`方法是一对多的映射，对每一个元素映射出来的仍旧是一个`Stream`，然后会将这个`子Stream`的元素映射到父集合中，栗子如下：

Stream<List<Integer>> inputStream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
    List<Integer> integerList = inputStream.flatMap((childList) -> childList.stream()).collect(Collectors.toList());
    //将一个“二维数组”flat为“一维数组”
    integerList.forEach(System.out::println);

*  limit、skip

`limit`用于限制获取多少个结果，与数据库中的`limit`作用类似，`skip`用于排除前多少个结果。

*  sorted

`sorted`的栗子前面也举过了，`sorted`函数需要传入一个实现`Comparator`函数式接口的对象，该接口的抽象方法`compare`接收两个参数并返回一个整型值，作用就是排序，与其他常见排序方法一致。

*  distinct

`distinct`用于剔除重复，与数据库中的`distinct`用法一致。

*  findFirst

`findFirst`方法总是返回第一个元素，如果没有则返回空，它的返回值类型是`Optional<T>`类型，接触过`swift`的同学应该知道，这是一个可选类型，如果有第一个元素则`Optional`类型中保存的有值，如果没有第一个元素则该类型为空。

Stream<User> stream = users.stream();
    Optional<String> userID = stream.filter(User::isVip).sorted((t1, t2) -> t2.getBalance() - t1.getBalance()).limit(3).map(User::getUserID).findFirst(); userID.ifPresent(uid -> System.out.println("Exists"));

*  min、max

`min`可以对整型流求最小值，返回`OptionalInt`。   
`max`可以对整型流求最大值，返回`OptionalInt`。   
这两个方法是结束操作，只能调用一次。

*  allMatch、anyMatch、noneMatch

`allMatch`：`Stream`中全部元素符合传入的`predicate`返回 true

`anyMatch`：`Stream`中只要有一个元素符合传入的`predicate`返回 true

`noneMatch`：`Stream`中没有一个元素符合传入的`predicate`返回 true

*  reduce

`reduce`方法用于组合`Stream`元素，它可以提供一个初始值然后按照传入的计算规则依次和`Stream`中的元素进行计算，因此上文介绍的`min`、`max`都可以看做是`reduce`的一种实现。

举个栗子：

IntStream is = IntStream.range(0, 10);
    System.out.println(is.reduce(0, Integer::sum));
    
    IntStream intStream = IntStream.range(0, 10);
    System.out.println(intStream.reduce((o1, o2) -> o1 + o2));
    
    Stream<String> stream = Stream.of("Hello", "World", "Jiaming", "Chen");
    System.out.println(stream.reduce("", String::concat));

第一个`IntStream`调用的`reduce`方法设置了一个初始值，因此最终`reduce`计算的结果一定有值，该方法调用`Integer`的类方法`sum`用于计算`Stream`的总和。   
第二个`IntStream`调用`reduce`方法时没有设置初始值，因此最终`reduce`计算的结果不一定有值，所以返回值类型是`Optional`类型，没有提供初始值时会自动将第一个和第二个元素先进行计算，但有可能不存在第一个或第二个元素，因此返回值是`Optional`类型。

### Stream API的性能 ###

这篇文章详细测试了`Stream API`的性能[Java Stream API性能测试][Java Stream API 1]。   
总的来说，对于复杂计算并且拥有多核CPU来说，使用`Stream API`进行并发计算速度最快，也推荐使用。对于计算比较简单，手工外部迭代性能更加。单核CPU尽量不要使用并发的`Stream API`计算。如果没有太高的性能要求，想要编写出简洁的代码还是推荐使用`Stream API`。

[http_blog.csdn.net_u014205968_article_details_71484312]: http://blog.csdn.net/u014205968/article/details/71484312
[Java Stream API]: http://blog.csdn.net/u014205968/article/details/71484374
[filter]: /images/20220525/db99a53062304f77b203ef6f13f522d7.png
[map]: /images/20220525/5d9e79c496a84103a88cfc7018f834b1.png
[Java Stream API 1]: http://www.importnew.com/24250.html