Stream API有哪些中间操作？看完你也可以吊打面试官！！

 作者个人研发的有也在高并发场景下，提供的中间简单、稳定、操作可扩展的看完延迟消息队列框架，具有精准的吊打定时任务和延迟队列处理功能。自开源半年多以来，面试已成功为十几家中小型企业提供了精准定时调度方案，有也经受住了生产环境的中间考验。为使更多童鞋受益，操作现给出开源框架地址：

https://github.com/sunshinelyz/mykit-delay

Stream的看完中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，吊打否则中间操作不会执行任何的面试处理!而在终止操作时一次性全部处理，称为“惰性求值” 。有也Stream的中间中间操作是不会有任何结果数据输出的。

Stream的操作中间操作在整体上可以分为：筛选与切片、映射、排序。接下来，我们就分别对这些中间操作进行简要的说明。

筛选与切片

这里，我将与筛选和切片有关的操作整理成如下表格。云服务器

接下来，我们列举几个简单的示例，以便加深理解。

为了更好的测试程序，我先构造了一个对象数组，如下所示。

protected List<Employee> list = Arrays.asList(     new Employee("张三", 18, 9999.99),     new Employee("李四", 38, 5555.55),     new Employee("王五", 60, 6666.66),     new Employee("赵六", 8, 7777.77),     new Employee("田七", 58, 3333.33) ); 

其中，Employee类的定义如下所示。

@Data @Builder @ToString @NoArgsConstructor @AllArgsConstructor public class Employee implements Serializable {      private static final long serialVersionUID = -9079722457749166858L;     private String name;     private Integer age;     private Double salary; } 

Employee类的定义比较简单，这里，我就不赘述了。之后的示例中，我们都是使用的Employee对象的集合进行操作。好了，我们开始具体的操作案例。

1.filter()方法

filter()方法主要是用于接收Lambda表达式，从流中排除某些元素，其在Stream接口中的源码如下所示。

Stream<T> filter(Predicate<? super T> predicate); 

可以看到，在filter()方法中，需要传递Predicate接口的对象，源码下载Predicate接口又是个什么鬼呢?点进去看下源码。

@FunctionalInterface public interface Predicate<T> {      boolean test(T t);     default Predicate<T> and(Predicate<? super T> other) {          Objects.requireNonNull(other);         return (t) -> test(t) && other.test(t);     }     default Predicate<T> negate() {          return (t) -> !test(t);     }     default Predicate<T> or(Predicate<? super T> other) {          Objects.requireNonNull(other);         return (t) -> test(t) || other.test(t);     }     static <T> Predicate<T> isEqual(Object targetRef) {          return (null == targetRef)                 ? Objects::isNull                 : object -> targetRef.equals(object);     } } 

可以看到，Predicate是一个函数式接口，其中接口中定义的主要方法为test()方法，test()方法会接收一个泛型对象t，返回一个boolean类型的数据。

看到这里，相信大家明白了：filter()方法是根据Predicate接口的test()方法的返回结果来过滤数据的，如果test()方法的返回结果为true，符合规则;如果test()方法的返回结果为false，则不符合规则。

这里，我们可以使用下面的示例来简单的说明filter()方法的使用方式。

//内部迭代：在此过程中没有进行过迭代，由Stream api进行迭代 //中间操作：不会执行任何操作 Stream<Person> stream = list.stream().filter((e) -> {      System.out.println("Stream API 中间操作");     return e.getAge() > 30; }); 

我们，在执行终止语句之后，一边迭代，一边打印，而我们并没有去迭代上面集合，其实这是香港云服务器内部迭代，由Stream API 完成。

下面我们来看看外部迭代，也就是我们人为得迭代。

//外部迭代 Iterator<Person> it = list.iterator(); while (it.hasNext()) {      System.out.println(it.next()); } 

2.limit()方法

主要作用为：截断流，使其元素不超过给定数量。

先来看limit方法的定义，如下所示。

Stream<T> limit(long maxSize); 

limit()方法在Stream接口中的定义比较简单，只需要传入一个long类型的数字即可。

我们可以按照如下所示的代码来使用limit()方法。

//过滤之后取2个值 list.stream().filter((e) -> e.getAge() >30 ).limit(2).forEach(System.out :: println); 

在这里，我们可以配合其他得中间操作，并截断流，使我们可以取得相应个数得元素。而且在上面计算中，只要发现有2条符合条件得元素，则不会继续往下迭代数据，可以提高效率。

3.skip()方法

跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素 不足 n 个，则返回一个空流。与 limit(n) 互补。

源码定义如下所示。

Stream<T> skip(long n); 

源码定义比较简单，同样只需要传入一个long类型的数字即可。其含义是跳过n个元素。

简单示例如下所示。

//跳过前2个值 list.stream().skip(2).forEach(System.out :: println); 

4.distinct()方法

筛选，通过流所生成元素的 hashCode() 和 equals() 去 除重复元素。

源码定义如下所示。

Stream<T> distinct(); 

旨在对流中的元素进行去重。

我们可以如下面的方式来使用disinct()方法。

list.stream().distinct().forEach(System.out :: println); 

这里有一个需要注意的地方：distinct 需要实体中重写hashCode()和 equals()方法才可以使用。

映射

关于映射相关的方法如下表所示。

1.map()方法

接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素。

先来看Java8中Stream接口对于map()方法的声明，如下所示。

<R> Stream<R> map(Function<? super T, ? extends R> mapper); 

我们可以按照如下方式使用map()方法。

//将流中每一个元素都映射到map的函数中，每个元素执行这个函数，再返回 List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd"); list.stream().map((e) -> e.toUpperCase()).forEach(System.out::printf); //获取Person中的每一个人得名字name，再返回一个集合 List<String> names = this.list.stream().map(Person :: getName).collect(Collectors.toList()); 

2.flatMap()

接收一个函数作为参数，将流中的每个值都换成另 一个流，然后把所有流连接成一个流。

先来看Java8中Stream接口对于flatMap()方法的声明，如下所示。

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper); 

我们可以使用如下方式使用flatMap()方法，为了便于大家理解，这里，我就贴出了测试flatMap()方法的所有代码。

/**      * flatMap —— 接收一个函数作为参数，将流中的每个值都换成一个流，然后把所有流连接成一个流      */     @Test     public void testFlatMap () {          StreamAPI_Test s = new StreamAPI_Test();         List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");         list.stream().flatMap((e) -> s.filterCharacter(e)).forEach(System.out::println);         //如果使用map则需要这样写         list.stream().map((e) -> s.filterCharacter(e)).forEach((e) -> {              e.forEach(System.out::println);         });     }     /**      * 将一个字符串转换为流      */     public Stream<Character> filterCharacter(String str){          List<Character> list = new ArrayList<>();         for (Character ch : str.toCharArray()) {              list.add(ch);         }         return list.stream();     } 

其实map方法就相当于Collaction的add方法，如果add的是个集合得话就会变成二维数组，而flatMap 的话就相当于Collaction的addAll方法，参数如果是集合得话，只是将2个集合合并，而不是变成二维数组。

排序

关于排序相关的方法如下表所示。

从上述表格可以看出：sorted有两种方法，一种是不传任何参数，叫自然排序，还有一种需要传Comparator 接口参数，叫做定制排序。

先来看Java8中Stream接口对于sorted()方法的声明，如下所示。

Stream<T> sorted(); Stream<T> sorted(Comparator<? super T> comparator); 

sorted()方法的定义比较简单，我就不再赘述了。

我们也可以按照如下方式来使用Stream的sorted()方法。

/ 自然排序 List<Employee> persons = list.stream().sorted().collect(Collectors.toList()); //定制排序 List<Employee> persons1 = list.stream().sorted((e1, e2) -> {      if (e1.getAge() == e2.getAge()) {          return 0;     } else if (e1.getAge() > e2.getAge()) {          return 1;     } else {          return -1;     } }).collect(Collectors.toList()); 

写在最后

如果觉得文章对你有点帮助，请微信搜索并关注「 冰河技术 」微信公众号，跟冰河学习Java8新特性。

最后，附上Java8新特性核心知识图，祝大家在学习Java8新特性时少走弯路。

本文转载自微信公众号「冰河技术」，可以通过以下二维码关注。转载本文请联系冰河技术公众号。