Stream的详解

1. 概述：

   Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

2. 特点：

   1 . 不是数据结构，不会保存数据。
   2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
   3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。
   

3. 获取Stream:

   
   核心的API;
   终结方法：返回值类型不再是Stream类型的方法，不在支持链式调用。
   非终结方法：返回值类型仍是Stream类型的方法，支持链式调用。
   Stream注意事项：
   1、Stream只能操作一次
   2、Stream方法返回的是新的流
   3、Stream不调用终结方法，中间的操作不会执行。

4. forEach
   forEach：使用来遍历Stream中的数据

 void forEach(Consumer<? super T> action);

该方法接收一个Consumer接口，会将每一个元素交给函数处理

  @Test
  void test015() {
    Stream.of("1","2","3")
        .forEach(System.out::println);
  }

5. count
   Stream流中的count方法用来统计其中的元素个数

  long count();

该方法返回一个long值，代表元素的个数。

  @Test
  void test016() {
    long count = Stream.of("1", "2", "3").count();
    System.out.println(count);
  }

6. filter
   filter方法的作用是用来过滤数据的，返回符合田间的数据。
   
   可以通过filter方法讲一个流转换成另一个子集流

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

该接口接收一个Predicte函数式接口参数的筛选条件。

  @Test
  void test011() {
    List<String> list=Arrays.asList("次日清晨辞别老诰命啊","普救寺僧人都来送行啊","扳鞍认蹬我上了白龙马呀");
    list.stream()
        .filter(s -> s.startsWith("次"))
        .filter(s -> s.length()==10)
        .forEach(s -> System.out.println(s));
  }

7. limit
   limit方法可以对流进行截取处理，之前的n个数据，

Stream<T> limit(long maxSize);

参数是一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：

 @Test
  void test013() {
  Stream.of("次日清晨辞别老诰命啊","普救寺僧人都来送行啊","扳鞍认蹬我上了白龙马呀")
    .limit(1)
    .forEach(System.out::println);
  }

8. skip
   如果希望跳过前几个元素，可以使用skip方法获取一个汲取之后的新流：

 Stream<T> skip(long n);

  @Test
  void test014() {
    Stream.of("次日清晨辞别老诰命啊","普救寺僧人都来送行啊","扳鞍认蹬我上了白龙马呀")
        .skip(2)
        .forEach(System.out::println);
  }

9. map
   如果我们需要讲流中的元素映射到另一个流中，可以说i用map方法：

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

该接口需要一个Funtion函数式接口参数，可以将当前流中的T类型的数据转换为另一种R类型的数据。

  @Test
  void test015() {
    Stream.of("1","2","3")
        .map(Double::parseDouble)
        .forEach(System.out::println);
  }

10. sorted
    如果需要将数据排序，可以使用sorted方法：

Stream<T> sorted();

在使用的时候可以根据自然规则排序，也可以通过比较来指定对用的排序规则。

  @Test
  void test016() {
      Stream.of("1","3","0")
          .map(Integer::parseInt)
//          .sorted()//根据自然数的排序
          .sorted((o1, o2) -> o2-o1)//控制升序降序
          .forEach(System.out::println);
  }

11. distinct
    如果有重复的可以使用distinct方法：

 Stream<T> distinct();

  @Test
  void test017() {
    Stream.of("次日清晨辞别老诰命啊","普救寺僧人都来送行啊","扳鞍认蹬我上了白龙马呀","普救寺僧人都来送行啊")
        .distinct()
        .forEach(System.out::println);
  }

12. reduce
    通过一群数据的到一条数据，可以使用reduce方法：

T reduce(T identity, BinaryOperator<T> accumulator);

  @Test
  void test018() {
    Integer reduce = Stream.of(1, 6, 2, 12, 5, 2234, 16)
        //identity是默认值
        //第一次的时候会将默认值赋值给x
        //之后每次回将上一次的操作结果赋值给X Y激素hi每次从数据中获取的元素
        .reduce(0, (x, y) -> {
          System.out.println("x="+x+"，y="+y);
          return x + y;
        });
    System.out.println(reduce);
  }

 @Test
  void test018() {
    Integer max= Stream.of(1, 6, 2, 12, 5, 2234, 16)
        .reduce(0, (x, y) -> {
          return x > y? x:y;
        });
    System.out.println(max);
  }

13. reduce 和 map 一起使用

  public static void main(String[] args) {
//业务：计算人的年龄总和
    Integer reduce = Stream.of(
            new Person("李丽珍", 22),
            new Person("李白", 21),
            new Person("李世民", 12),
            new Person("李梦菲", 6)
        ).map(Person::getAge)
        .reduce(0, Integer::sum);
    System.out.println(reduce);
  }

//业务：求出最大你年龄的名字
 public static void main(String[] args) {
    List<Person> reduce = Arrays.asList(
        new Person("李丽珍", 22),
        new Person("李白", 21),
        new Person("李世民", 20),
        new Person("李梦菲", 18)
    );
    Integer reduce1 = reduce.stream().map(Person::getAge).reduce(100, Integer::min);
    System.out.println(reduce1);
    for (Person person : reduce) {
      if (person.getAge().equals(reduce1)){
        System.out.println(person);
      }
    }
  }

14. concat
    如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

  public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
    Objects.requireNonNull(a);
    Objects.requireNonNull(b);

    @SuppressWarnings("unchecked")
    Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
            (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
    Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
    return stream.onClose(Streams.composedClose(a, b));
}

  @Test
  void test019() {
    Stream<String> stream1 = Stream.of("次日清晨辞别老诰命啊", "普救寺僧人都来送行啊", "扳鞍认蹬我上了白龙马呀", "普救寺僧人都来送行啊");
    Stream<String> stream2 = Stream.of("公开", "内部", "秘密", "机密");
    Stream.concat(stream1, stream2).forEach(System.out::println);
  }