集合Stream API学习简单总结

Stream API是JDK1.8之后引入的特性，这是一个和集合有关的一系列API，下面通过一个简单的例子来介绍一下它。

假设有一个List集合，该集合中的元素是几个正整数，写一个方法来找出该集合中的偶数
这是比较简单的问题，代码如下：

package 优快云;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
 * @author F3ver1
 * @date 2018/12/5 13:22
 */
public class ListDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        List<Integer> list1 = find(list);
        System.out.println(list1);
    }
    private static List<Integer> find(List<Integer> list){
        List<Integer> list1 = new ArrayList<>();
        for (Integer i:list){
            if (i%2==0){
                list1.add(i);
            }
        }
        return list1;
    }
}

 
再引入Stream API来完成上述操作
 
 

package 优快云;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/*
 * @author F3ver1
 * @date 2018/12/5 13:28
 */
public class Demo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        List<Integer> list1 = list.stream().filter(i -> i % 2 == 0).collect(Collectors.toList());
        System.out.println(list);
        System.out.println(list1);
    }
}

结果：
[1, 2, 3, 4, 5, 6]
[2, 4, 6]

第一个方法stream()可以将集合list转换为stream流，之后就可以用Stream API里一些好用的方法，比如filter，这是一个 过滤方法 ，接收一个Predicate接口的子类对象，由于这是一个FunctionInterface函数式接口，因此可以利用lambda表达式进行代码的简化。在这个接口中对应的lambda，有一个参数，一个返回值类型为boolean。
正如这个方法名一样，它会过滤掉布尔值结果为假的元素，留下布尔值为真的元素，因此这个方法会改变集合的元素个数。这个改变并不是改变原集合，所有关于Stream流的操作，原集合都不会发生改变。

一些关于Stream的常用重要接口

1. Predicate 断言接口
   对应的lambda 一个参数，返回结果是boolean
   (a) -> { return true|false; }
2. Function 函数接口
   对应的lambda 一个参数，一个返回结果，参数和返回结果的类型可以不一样
3. BiPredicate 双参数断言
   对应的lambda 两个参数，返回结果是boolean
   (a,b) -> { return true|false; }
4. BiFunction 双参数函数接口
   对应的lambda 两个参数，一个结果
   (a,b) -> { 根据ab返回一个结果}
5. Consumer 消费接口
   对应的lambda 一个参数，没有结果
   (a) -> { 不需要return }
6. BiConsumer 双参数消费接口
   对应的lambda 两个参数，没有结果
   (a,b) -> { 不需要return }
7. Supplier 生产者接口
   对应的lambda 没有参数，返回一个结果
   () -> {return 结果}

Stream其中map这个方法，对应Function接口，映射方法, lambda把原有的元素转换为另一个元素， 不会改变个数
举个例子：

package 优快云;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/*
 * @author F3ver1
 * @date 2018/12/5 13:28
 */
public class Demo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        List<Integer> list1 = list.stream().map( i -> i*2).collect(Collectors.toList());
        System.out.println(list1);
        System.out.println(list);
    }
}

结果：
[2, 4, 6, 8, 10, 12]
[1, 2, 3, 4, 5, 6]

下面再说一个问题，观察以下代码：

package 优快云;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/*
 * @author F3ver1
 * @date 2018/12/5 13:28
 */
public class Demo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        list.stream().filter(x -> {
            System.out.println("filter被执行！");
            return x % 2 == 0;
        }).map(x -> {
            System.out.println("map被执行！");
            return x * 2;
        });
    }
}

结果什么都不会打印，意思就是这段代码并没有执行，实际上，这是lambda表达式的特点，“懒惰特性”，在没有遇到上一段代码中出现的Collect语句时，并不会执行这些lambda表达式的内容，在这里Collect是一个终结方法，倘若附上Collect收集后，有如下流程图：

在这里整个代码的执行过程（Stream流的过程）

如上图所示，在执行上述代码时，整个Stream操作就像流水线一般，而整个list集合也仅仅只被遍历一次。