Stream

一、概述
- 传统集合的多步遍历代码（如Collection接口或Map接口等）
  - 循环遍历的弊端*
二、流式思想概述
三、Stream综合案例
- 收集到数组中

一、概述

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端

传统集合的多步遍历代码（如Collection接口或Map接口等）

public class Demo10ForEach {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        for (String name : list) {
              System.out.println(name);
        }
    }  
}

循环遍历的弊端*

因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环

public class Demo11NormalFilter {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        List<String> zhangList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("张")) {
                  zhangList.add(name);
            }
        }

        List<String> shortList = new ArrayList<>();
        for (String name : zhangList) {
            if (name.length() == 3) {
                  shortList.add(name);
            }
        }

        for (String name : shortList) {
              System.out.println(name);
        }
    }
}

Stream的更优写法

public class Demo12StreamFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        list.stream()
              .filter(s -> s.startsWith("张"))
            .filter(s -> s.length() == 3)
            .forEach(s -> System.out.println(s));
    }
}

思想：获取流、过滤姓张、过滤长度为3、逐一打印

二、流式思想概述

注意：请暂时忘记对传统IO流的固有印象！

流式思想类似于工厂车间的“生产流水线”。

这里的filter、map、skip都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法count执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

获取流方式

所有的Collection集合都可以通过stream默认方法获取流；

Stream接口的静态方法of可以获取数组对应的流。

1.根据Collection获取流

import java.util.*;
import java.util.stream.Stream;
/*
  获取Stream流的方式

  1.Collection中 方法
      Stream stream()
  2.Stream接口 中静态方法
      of(T...t) 向Stream中添加多个数据
*/
public class Demo13GetStream {
  public static void main(String[] args) {
      List<String> list = new ArrayList<>();
      // ...
      Stream<String> stream1 = list.stream();

      Set<String> set = new HashSet<>();
      // ...
      Stream<String> stream2 = set.stream();
  }
}

2.根据数组获取流

由于数组对象不可能添加默认方法，所以Stream接口中提供了静态方法of

public class Demo14GetStream {
  public static void main(String[] args) {
      String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
      Stream<String> stream = Stream.of(array);
  }
}

of方法的参数其实是一个可变参数，所以支持数组。

常用方法

终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。本小节中，终结方法包括count和forEach方法。
非终结方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为非终结方法。）
forEach : 逐一处理
void forEach(Consumer<? super T> action); 参数：
```
Consumer属于消费函数式接口，我们在使用void forEach(Consumer<? super T> action);方法的时候可以传递lambda,完成Consumer接口中的 void accept(T t);
```

该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。例如：

import java.util.stream.Stream;

public class Demo15StreamForEach {
    public static void main(String[] args) {
        Stream<String> stream =  Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷爷","蛇精","蝎子精");
        //Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
        stream.forEach((String str)->{System.out.println(str);});
    }
}

filter：过滤

Stream filter(Predicate<? super T> predicate); 参数： Predicate 表示判断函数式接口，可以使用lambda，我们在使用filter(Predicate<? super T> predicate);方法的时候可以传递lambda完成Predicate 接口中的抽象方法 boolean test(T t); 如果，满足条件，方法test(T t)返回true，那么filter(Predicate<? super T> predicate);就会将满足条件的数据放到流水线中

该接口接收一个Predicate函数式接口参数（可以是一个Lambda）作为筛选条件。

public class Demo16StreamFilter {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
    }
}

count：统计个数

正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：

long count();

public class Demo17StreamCount {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter(s -> s.startsWith("张"));
        System.out.println(result.count()); // 2
    }
}

limit：取用前几个

limit方法可以对流进行截取，只取用前n个。方法签名：

Stream limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

import java.util.stream.Stream;

public class Demo18StreamLimit {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}

skip：跳过前几个

Stream skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

import java.util.stream.Stream;

public class Demo19StreamSkip {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 1
    }
}

映射：map

需要将流中的元素映射到另一个流中，可以使用map方法

Stream map(Function<? super T, ? extends R> mapper); 属于延迟方法

public class StreamMapDemo {
    public static void main(String[] args) {
        //创建老流对象存储String类型
        Stream<String> strStream = Stream.of("123", "345", "567");
        //使用map方法将老流转换为新流
        //<R> Stream<R> map(Function<? super T, ? extends R> mapper);
        //由于map方法的参数需要Function接口，Function只有一个抽象方法R apply(T t);属于函数式接口
        //可以使用lambda
        /*Stream<Integer> integerStream = strStream.map((s) -> {
            return Integer.parseInt(s);
        });*/
         Stream<Integer> integerStream = strStream.map(s->Integer.parseInt(s));

        //取出新流中的数据
        integerStream.forEach(name->System.out.println(name));
    }
}

Function接口

唯一的抽象方法：R apply(T t);

concat：组合

static Stream concat(Stream<? extends T> a, Stream<? extends T> b): 把参数列表中的两个Stream流对象a和b,合并成一个新的Stream流对象

import java.util.stream.Stream;

public class Demo20StreamConcat {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
    }
}

三、Stream综合案例

现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用Stream依次进行以下若干操作步骤：

第一个队伍只要名字为3个字的成员姓名；
第一个队伍筛选之后只要前3个人；
第二个队伍只要姓张的成员姓名；
第二个队伍筛选之后不要前2个人；
将两个队伍合并为一个队伍；
根据姓名创建Person对象；

打印整个队伍的Person对象信息。 ```java public class DemoArrayListNames { public static void main(String[] args) {

 List<String> one = new ArrayList<>();
 one.add("迪丽热巴");
 one.add("宋远桥");
 one.add("苏星河");
 one.add("老子");
 one.add("庄子");
 one.add("孙子");
 one.add("洪七公");

 List<String> two = new ArrayList<>();
 two.add("古力娜扎");
 two.add("张无忌");
 two.add("张三丰");
 two.add("赵丽颖");
 two.add("张二狗");
 two.add("张天爱");
 two.add("张三");
 // ....

} }

//Stream流式 public class DemoStreamNames { public static void main(String[] args) { List one = new ArrayList<>(); // …

    List<String> two = new ArrayList<>();
    // ...

    // 第一个队伍只要名字为3个字的成员姓名；
    // 第一个队伍筛选之后只要前3个人；
    Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);

    // 第二个队伍只要姓张的成员姓名；
    // 第二个队伍筛选之后不要前2个人；
    Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);

    // 将两个队伍合并为一个队伍；
    // 根据姓名创建Person对象；
    // 打印整个队伍的Person对象信息。
     Stream.concat(streamOne, streamTwo).map((name)->{return new Person(name);}).forEach((p)->{System.out.println(p);});
}

}

<a name="JYUx3"></a>
### 收集Stream结果
对流操作完成之后，如果需要将其结果进行收集，例如获取对应的集合、数组等，如何操作？
<a name="dTC9p"></a>
### 收集到集合中
> Stream流提供collect方法，其参数需要一个java.util.stream.Collector<T,A, R>接口对象来指定收集到哪种集合中。幸运的是，java.util.stream.Collectors类提供一些方法，可以作为Collector接口的实例：
> - public static <T> Collector<T, ?, List<T>> toList()：转换为List集合。
> - public static <T> Collector<T, ?, Set<T>> toSet()：转换为Set集合

```java
public class Demo15StreamCollect {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("10", "20", "30", "40", "50");
        List<String> list = stream.collect(Collectors.toList());
        Set<String> set = stream.collect(Collectors.toSet());
    }
}

收集到数组中

Stream提供toArray方法来将结果放到一个数组中，返回值类型是Object[]的：

Object[] toArray();

import java.util.stream.Stream;

public class Demo16StreamArray {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("10", "20", "30", "40", "50");
        Object[] objArray = stream.toArray();
    }
}