1.1、Stream介绍

Stream是JDK1.8新增的一个特性，它是一个位于【java.util.stream】包下面的接口，接口中定义了用于操作数据的公共方法，Stream被称作：【流】，它的意图就是可以按照流的方式对数据进行一些加工处理，实际开发里面最常见的就是操作集合数据，通过Stream API可以编写很少的代码就完成某一个功能，相比于传统的集合处理方式，Stream API显示更加的优雅、高效。

Java中可以将Stream API方法大致分为两类，分别是：【中间方法】和【终端方法】。

• 中间方法：在Stream流被消费之前，对Stream流中的数据进行一些加工处理，然后返回加工处理之后的新的Stream流。
• 终端方法：Stream流经过中间方法的加工处理之后，最终是需要被消费的，调用终端方法之后，这个Stream流就结束了，之后就不能够在使用这个Stream流对象。

Stream流处理大致流程图：

下面详细介绍一下Stream API的常见方法。

1.2、Stream创建对象

Java中主要有下面四种方法创建一个Stream对象，分别如下所示：

• 第一种：使用Stream提供的empty()方法。
• 第二种：使用Stream提供的of()方法。
• 第三种：使用Arrays.stream()数组工具类提供的方法。
• 第四种：使用集合对象的stream()方法（这种方式在实际开发里面最常用）。

（1）empty()方法

Stream接口中提供了一个empty()方法，该方法用于创建一个空的Stream对象，基本上不会用这个方法吧，反正我是没用过^-。

public class StreamDemo {public static void main(String[] args) {// 创建空的 Stream 对象Stream<Object> empty = Stream.empty();}
}

（2）of()方法

Stream接口中提供了两个of()方法，of()方法可以将传入的数据转换为一个Stream对象返回。

public class StreamDemo {public static void main(String[] args) {// 创建 Stream 对象Stream<String> stream = Stream.of("123");// 可变参数Stream<Integer> stream1 = Stream.of(1, 2, 3, 4);}
}

（3）Arrays.stream()方法

Arrays数组工具类中提供了一个stream()方法，该方法可以将数组转换为Stream流对象。

public class StreamDemo {public static void main(String[] args) {// 创建 Stream 对象int[] arr = new int[] {1, 2, 3, 4, 5};IntStream stream = Arrays.stream(arr);}
}

（4）list.stream()方法

Java集合类中提供了一个stream()方法，作用也是将Collection集合数据转换为Stream流对象。

public class StreamDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("111");list.add("222");list.add("333");// 创建 Stream 对象Stream<String> stream = list.stream();}
}

注意：只要是Collection集合类，它都具有stream()方法。并且这个也是最常用的方法，因为实际开发里面，集合是最常见的操作对象。

1.3、Stream中间方法

Stream中间方法是对Stream流中数据进行一些加工处理的，中间方法的返回值都是一个新的Stream流对象，这个Stream流对象就是加工处理之后的新对象。

（1）filter()方法

filter()方法用于过滤Stream流中的数据，该方法需要传递一个【Predicate】对象（一个函数式接口），可以采用lambada表达式编写过滤条件。

public class StreamDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("111");list.add("222");list.add("333");// 创建 Stream 对象Stream<String> stream = list.stream();// 过滤方法: 过滤出集合中不等于 222 的数据Stream<String> stream1 = stream.filter(item -> !item.equals("222"));}
}

（2）map()方法

map()方法主要作用就是将一个Stream流映射成一个新的Stream流，map方法使用最为频繁，比如：从集合中提取某个对象的某个属性，将其组成新的一个集合，下面看下两种实现方式。

• 没有使用Stream.map()方法的代码。

public static void main(String[] args) {List<User> userList = getUserList();// 从集合中提取 姓名List<String> nameList = new ArrayList<>();for (int i = 0; i < userList.size(); i++) {nameList.add(userList.get(i).getName());}
}

• 采用Stream.map()方法的代码。

public static void main(String[] args) {List<User> userList = getUserList();// 从集合中提取 姓名List<String> nameList = userList.stream().map(item -> item.getName()).collect(Collectors.toList());
}

对比上面两种方式，可以看到，采用Stream API编写的代码是多么的优雅，并且代码也简化了很多。

（3）flatMap()方法

flatMap()方法和map()方法的作用是类似的，都是用于映射Stream流的，只不过flatMap()方法可以将多个不同的Stream流映射为一个Stream流对象，flat表示【扁平化】的意思，就好比将多行数据合并成一行数据，这个就是扁平化。

public class StreamDemo {public static List<List<User>> getUserList() {List<List<User>> ans = new ArrayList<>();List<User> list = new ArrayList<>();list.add(new User(333, "name_003", "pass_003"));list.add(new User(111, "name_001", "pass_001"));list.add(new User(444, "name_004", "pass_004"));ans.add(list);List<User> list2 = new ArrayList<>();list2.add(new User(222, "name_002", "pass_002"));ans.add(list2);return ans;}public static void main(String[] args) {List<List<User>> userList = getUserList();System.out.println(userList);// 将集合中的集合，转换为一个集合List<User> ansList = userList.stream().flatMap(item -> item.stream()).collect(Collectors.toList());System.out.println(ansList);}
}

上面案例中，由于集合里面的元素又是集合，为了将整个集合变成一个集合，通过Stream中的flatMap()方法，将多个Stream流映射成一个Stream对象。

（4）limit()方法

limit()方法作用是限定数据的条数，比如：集合中有100条数据，通过limit()方法可以只获取10条数据。

public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("111");list.add("222");list.add("333");list.add("444");list.add("555");// 限定5条数据Stream<String> stream = list.stream().limit(5);
}

（5）skip()方法

skip()方法作用是：跳过多少条数据，然后在开始处理数据。比如：现在有100条数据，前10条数据是不需要的，从第11条数据开始进行处理，这个时候就可以通过skip()方法跳过前10条数据进行处理。

public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("111");list.add("222");list.add("333");list.add("444");list.add("555");// 跳过前 2 条数据Stream<String> skip = list.stream().skip(2);// 打印结果skip.forEach(System.out::println);
}

打印结果如下所示：

（6）sorted()方法

sorted()方法作用是将数据进行排序，sorted()有两个方法，一个是无参的sorted()方法，另一个是有参数的sorted(Comparator)方法。

• sorted()无参方法，默认按照自然排序规则，升序排序所有数据，即：数值类按照从小到大排序，字符串按照字典序排序。

public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("333");list.add("111");list.add("444");list.add("222");list.add("555");System.out.println("排序前: ");list.forEach(item -> System.out.print(item + " "));System.out.println();// 排序Stream<String> sorted = list.stream().sorted();System.out.println("排序后: ");sorted.forEach(item -> System.out.print(item + " "));
}

运行结果如下所示：

• sorted()有参方法，自定义排序比较器，自定义排序规则。

public class StreamDemo {public static List<User> getUserList() {List<User> list = new ArrayList<>();list.add(new User(333, "name_003", "pass_003"));list.add(new User(111, "name_001", "pass_001"));list.add(new User(444, "name_004", "pass_004"));list.add(new User(222, "name_002", "pass_002"));return list;}public static void main(String[] args) {List<User> userList = getUserList();System.out.println("排序前: ");userList.forEach(System.out::println);// 自定义排序Stream<User> sorted = userList.stream().sorted(new Comparator<User>() {@Overridepublic int compare(User o1, User o2) {return o1.getId() - o2.getId();}});System.out.println("排序后: ");sorted.forEach(System.out::println);}
}

运行结果如下所示：

（7）distinct()方法

distinct()方法作用是将数据中的重复数据去重操作，只保留一条数据。

public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("111");list.add("222");list.add("333");list.add("444");// 重复数据list.add("555");list.add("555");// 去重Stream<String> distinct = list.stream().distinct();// 打印结果distinct.forEach(System.out::println);
}

打印结果如下所示：

（8）peek()方法

peek()方法接收一个Consumer消费者对象，消费者可以对流中的数据进行修改操作或者访问操作。

public class StreamDemo {public static List<User> getUserList() {List<User> list = new ArrayList<>();list.add(new User(333, "name_003", "pass_003"));list.add(new User(111, "name_001", "pass_001"));list.add(new User(444, "name_004", "pass_004"));list.add(new User(222, "name_002", "pass_002"));return list;}public static void main(String[] args) {List<User> userList = getUserList();// peek 修改数据Stream<User> peek = userList.stream().peek(item -> item.setName("demo_peek"));peek.forEach(System.out::println);}
}

注意：Stream中间方法的执行操作并不会立即生效，只有调用终端方法之后，中间方法的执行效果才会生效。

1.4、Stream终端方法

终端方法是将Stream流消费之后，并且最终会得到一个结果，常见的终端方法下面这些。

（1）min()方法

min()方法主要作用：从数据流中计算出最小值元素。min()方法需要提供一个Comparator比较器对象，通过比较器器对象的比较规则，找出最小值元素。

注意：min()方法不是说找出最小的元素，它是根据你指定的比较器规则找出最小元素。

比如下面这个例子，集合元素是【1，2，3，4，5】，但是比较器规则是后一个元素减去前一个元素。

public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);Optional<Integer> min = list.stream().min(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});Integer ans = min.get();System.out.println(ans);
}

上面输出结果是：【5】。

（2）max()方法

max()方法作用：从数据流中计算出最小值元素。参数和min()方法是相同的。

public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);Optional<Integer> max = list.stream().max(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});Integer ans = max.get();System.out.println(ans);
}

上面输出结果是：【1】。

（3）count()方法

count()方法作用：统计Stream流中数据元素个数，返回值是long类型。

public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 1, 5, 4, 3);// 计算个数long count = list.stream().count();System.out.println(count);
}

（4）reduce()方法

reduce()方法作用：将stream流中数据进行规约操作，最终得到一个结果。这里的规约就类似于迭代，比如：要计算stream流中所有数据的和，那就可以使用reduce()方法进行规约计算。

public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 1, 5, 4, 3);// 规约操作Optional<Integer> ans = list.stream().reduce((a, b) -> a + b);System.out.println(ans.get());// 指定初始值:// 这里指定第一个参数值是10，也就是reduce的规约操作的初始值是10int ans1 = list.stream().reduce(10, (a, b) -> a + b);System.out.println(ans1);// 这里结果等于：1200int ans2 = list.stream().reduce(10, (a, b) -> a * b);System.out.println(ans2);
}

运行结果如下所示：

reduce()规约操作分析：

（5）anyMatch()方法

anyMatch()方法作用：只要stream数据流中 【存在一个满足匹配】 条件的数据，那么方法就会返回true，否则返回false。

（6）allMatch()方法

allMatch()方法作用：只有当stream数据流中的所有数据，【都满足匹配】 条件的数据，那么方法才会返回true，否则返回false。

（7）noneMatch()方法

allMatch()方法作用：只有当stream数据流中的所有数据，【都不满足匹配】 条件的数据，那么方法才会返回true，否则返回false。

public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 1, 5, 4, 3);// 满足一个: 集合中有一个元素是大于4的boolean match = list.stream().anyMatch(item -> item > 4);System.out.println(match);// 都满足: 集合中所有元素都小于6boolean match1 = list.stream().allMatch(item -> item < 6);System.out.println(match1);// 都不满足: 集合中不存在大于 6 的元素boolean match2 = list.stream().noneMatch(item -> item > 6);System.out.println(match2);
}

（8）findFirst()方法

findFirst()方法作用：从stream流中获取第一条数据。

public class StreamDemo {public static List<User> getUserList() {List<User> list = new ArrayList<>();list.add(new User(333, "name_003", "pass_003"));list.add(new User(111, "name_001", "pass_001"));list.add(new User(444, "name_004", "pass_004"));list.add(new User(222, "name_002", "pass_002"));return list;}public static void main(String[] args) {List<User> userList = getUserList();// 获取第一条数据Optional<User> first = userList.stream().findFirst();if (first.isPresent()) {System.out.println(first.get());}}
}

（9）findAny()方法

findAny()方法作用：从stream数据流中随机返回一条数据。

（10）forEach()方法

forEach()方法作用：遍历stream流中的数据元素。

public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("333");list.add("111");list.add("444");list.add("222");list.add("555");list.stream().forEach(item -> {System.out.println(item);});
}

（11）collect()方法

collect()方法作用：用于将中间方法处理的stream流收集为一个结果，常见的如：List、Set、Map等等。

public class StreamDemo {public static List<User> getUserList() {List<User> list = new ArrayList<>();list.add(new User(333, "name_003", "pass_003"));list.add(new User(111, "name_001", "pass_001"));list.add(new User(444, "name_004", "pass_004"));list.add(new User(222, "name_002", "pass_002"));return list;}public static void main(String[] args) {List<User> userList = getUserList();List<String> ansList = userList.stream().map(User::getName).collect(Collectors.toList());System.out.println(ansList);}
}

这个collect()方法更多的用法上一篇文章Java8新特性有介绍。