Stream

Stream流: java8之后出现的一种新的流式处理机制
    作用: 简化数组和集合的操作
    步骤:
        (1) 得到Stream流对象  , 将集合或者数组转成Stream对象
            集合:  单列集合.stream();得到Stream对象

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    Collections.addAll(list, "张三1", "李四1", "王五1", "赵六1", "田七1", "孙八1");
    List<String> list2 = new ArrayList<>();
    Collections.addAll(list2, "张三2", "李四2", "王五2", "赵六2", "田七2", "孙八2");
}

             数组:   Arrays.stream(数组);

      Stream<String> s1 = list.stream();
      String[] arr = {"张三", "李四", "王五", "赵六", "孙七"};
      Stream<String> s2 = Arrays.stream(arr);

        (2)研究Stream中有那些功能可以简化数组和集合的操作
   1.终结方法: 特点, 方法调用结束后,返回值不是Stream流对象, 不能在继续使用流的功能
                void forEach(Consumer<? super T> action)  遍历流的元素
                long count(); 统计流中元素的个数
                Optional<T> min(Comparator<? super T> comparator);
                Optional<T> max(Comparator<? super T> comparator);

        //终结方法中的foreach
        list.stream().forEach(s -> System.out.println(s));
        //终结方法中的count
        System.out.println(list.stream().count());
        //终结方法中的max
        String max = list.stream().max((o1, o2) -> o1.length() - o2.length()).get();
        System.out.println(max);

   2.中间方法: 方法调用结束后,返回值还是Stream流对象, 可以继续使用流的功能,支持链式编程
              Stream<T>  filter(Predicate predicate);
              Stream<T> limit(long count); 限制前几个
              Stream<T> skip(long n); 跳过前几个
              Stream<T> distinct(); 去重, 底层采用hash去重
              Stream<T> sorted();// 自然排序
              Stream<T> sorted(比较器);// 自然排序
              static  Stream<T> concat(Stream<? extends T> s1, Stream<? extends T> s2); 将两个流合并成一个流
              Stream <R>  map(Function<? super T, ? extends R> mapper); 转换
                   (1) 修改流中的元素
                   (2) 将流中的元素从一种类型转成另外一种类型

// 过滤
list.stream().filter(s -> s.length() > 3).forEach(s -> System.out.println(s));
//限制前几个
list.stream().limit(3).forEach(s -> System.out.println(s));
//跳过前几个
list.stream().skip(3).forEach(s -> System.out.println(s));
//去重
list.stream().distinct().forEach(s -> System.out.println(s));
//自然排序
list.stream().sorted().forEach(s -> System.out.println(s));
//比较器自然排序
list.stream().sorted((o1, o2) -> o2.length()-o1.length()).forEach(s ->System.out.print(s));                
//合并流
Stream.concat(list.stream(), list2.stream()).forEach(s -> System.out.println(s));
//流的首字去除
list.stream().map(s -> s.substring(1)).forEach(s -> System.out.println(s));
//将字符串变成对象
list.stream().map(s -> new Student(s)).forEach(stu -> System.out.println(stu));

   3.转化方法: 特点: 将流转成集合
           stream擅长的是过滤, 但是开发过程有时候过滤后要进行添加,但是stream流中只有过滤的功能没有添加的能力,需要转成集合后才能添加
           Stream<T> collect(Collector<? super T, A, R> collector);

        //添加
        List<String> collect = list.stream().filter(s -> s.length() == 3).collect(Collectors.toList());
        collect.add("whh");
        System.out.println(collect);

     注意事项:
        流对象只能被操作一次, 不能被操作多次, 否则会报异常,设计者建议使用Stream一行代码解决所有问题