Java Stream流对象的使用案例

1. Stream流对象介绍 

java.util.stream.Stream<T>;是JDK8新加入的最常用的流接口

常用的获取流的方式
（1）所有的Collection集合都可以通过stream默认方法获取流；
     default Stream<E> stream();
 (2)Stream接口的静态方法of可以获取数组对应的流
     static <T> Stream<T> of(T... value);
     参数是一个可变参数，那么我们就可以传递一个数组。
Stream流的属于管道流，只能被使用一次，第一个Stream流调用完毕以后数据就会流向下一个Stream上，此时第一个Stream流已经关闭，不能在使用第一个Stream流调用方法

Stream流的常用方法：延迟方法返回是一个流，仍然可以调用流的方法，
 (1)filter();延迟方法，用于过滤流中的元素，返回的还是一个流。
     源码：Stream<T> filter(Predicate<? super T> predicate);
 (2)forEach();延迟方法，用于循环输出流中的元素
     源码：void forEach(Consumer<? super T> action);
 (3)count();用于统计Stream流中元素的个数，返回值是一个long类型的数据
 (4)limit();延迟方法，对流中的元素进行截取，返回的还是一个流，所以可以继续调用其他Stream流的方法
     源码：Stream<T> limit(long maxSize);
 (5)skip();延迟方法，希望跳过前n个元素，获取n元素之后元素形成一个新流。
     源码：Stream<T> skip(long n);
 (6)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));
    }

2.案例

    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");

        //map方法案例
        /*stream.map(str-> Integer.valueOf(str))//map方法中传入的是Function函数式接口，实现数据类型转换，该接口中的抽象方法是apply方法，用于数据类型转换
                .forEach(s-> System.out.println(s));结果：1 2 3 4 5 */

        //count方法案例
        /*long count = stream.count();
        System.out.println(count);//结果：5*/

        //limit方法案例
        /*Stream<String> stream2 = stream.limit(3);
        stream2.forEach(s-> System.out.println(s));//结果：1 2 3*/

        //skip方法案例
       /* Stream<String> stream3 = stream.skip(3);
        stream3.forEach(s-> System.out.println(s));//结果：4 5*/

       //concat方法案例
        /*Stream<String> stream4 = Stream.of("a", "b", "v", "b");
        Stream<String> stream5 = Stream.concat(stream, stream4);
        stream5.forEach(s-> System.out.println(s));//1 2 3 4 5 a b v b*/
    }

3. 对list集合的优化

（1）原代码:

//获取list集合中，元素包含a,且长度为3的元素，并打印
public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("AAA");
        list.add("ABB");
        list.add("Bcc");
        list.add("CsA");

        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if(s.contains("A")){
                listA.add(s);
            }
        }

        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if(s.length()==3){
                listB.add(s);
            }

        }

        for (String s : listB) {
            System.out.println(s);

        }
    }

（2）优化代码：

   //使用stream流对集合遍历进行优化
   public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("AAA");
        list.add("ABB");
        list.add("Bcc");
        list.add("CsA");

        list.stream().filter(s -> s.contains("A"))//该方法中传入的是一个Predicate函数式接口，实现过滤，接口中的抽象方法为test方法，用于判断
                     .filter(s->s.length()==3)
                     .forEach(s->System.out.println(s));//该方法中传入的是一个Consumer函数式接口，实现循环，该接口中的抽象方法是accept方法，用于消费
    }