Java Stream流对象的使用案例

柔光的暖阳◎ 2023-03-13 02:21 24阅读 0赞

### 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方法，用于消费
        }