Stream流

你的名字 2023-10-04 12:39 14阅读 0赞

##### 8.Stream流 #####

###### 8.1.背景 ######

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

###### 8.2.Stream的更优写法 ######

//直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。
    import java.util.ArrayList;
    import java.util.List;
    
    public class StreamFilter {
        
        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(System.out::println);
        }
    }

###### 8.3.流式思想 ######

###### 8.3.1.概述 ######

*  Stream（流）是一个来自数据源的元素队列
    
     *  元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
     *  数据源：流的来源。 可以是集合，数组 等。
 *  和以前的Collection操作不同， Stream操作还有两个基础的特征
    
     *  Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluentstyle）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
     *  内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。
 *  使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

###### 8.3.2.获取流 ######

*  java.util.stream.Stream
 *  Java 8新加入的最常用的流接口(但是并不是一个函数式接口)
 *  获取方式
    
    1.  所有的 Collection 集合都可以通过 stream 默认方法获取流；
    2.  Stream 接口的静态方法 of 可以获取数组对应的流。
 *  根据Collection获取流：java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

import java.util.*;
    import java.util.stream.Stream;
    public class CollectionGetStream {
        
        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();
            Vector<String> vector = new Vector<>();
            // ...
            Stream<String> stream3 = vector.stream();
        }
    }

*  根据Map获取流：java.util.Map 接口不是 Collection 的子接口，K-V数据结构不符合流元素的单一特征，故获取对应的流需要分key、value或entry等情况

import java.util.HashMap;
    import java.util.Map;
    import java.util.stream.Stream;
    public class MapGetStream {
        
        public static void main(String[] args) {
        
            Map<String, String> map = new HashMap<>();
            // ...
            Stream<String> keyStream = map.keySet().stream();
            Stream<String> valueStream = map.values().stream();
            Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
        }
    }

*  根据数组获取流：如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法of

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

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

###### 8.4.常用方法 ######

###### 8.4.1.分类 ######

*  延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
 *  终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。（只介绍 count 和 forEach 方法）

###### 8.4.2.逐一处理：forEach ######

*  与for循环中的“for-each”不同。

//void forEach(Consumer<? super T> action);
    //java.util.function.Consumer<T>接口是一个消费型接口。
    //Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
    
    
    //基本使用
    import java.util.stream.Stream;
    public class StreamForEach {
        
        public static void main(String[] args) {
        
            Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
            stream.forEach(name‐> System.out.println(name));
        }
    }

###### 8.4.3.过滤：filter ######

*  可以通过 filter 方法将一个流转换成另一个子集流

//Stream<T> filter(Predicate<? super T> predicate);
    //Predicate接口:boolean test(T t);方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的filter方法
    //将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。
    
    
    //基本使用
    import java.util.stream.Stream;
    public class StreamFilter {
        
        public static void main(String[] args) {
        
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.filter(s ‐> s.startsWith("张"));
        }	
    }

###### 8.4.3.映射：map ######

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

//<R> Stream<R> map(Function<? super T, ? extends R> mapper);
    //Function接口:R apply(T t);可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。
    
    
    //基本使用
    import java.util.stream.Stream;
    public class StreamMap {
        
        public static void main(String[] args) {
        
            Stream<String> original = Stream.of("10", "12", "18");
            Stream<Integer> result = original.map(str‐>Integer.parseInt(str));
    	}
    }

###### 8.4.4.统计个数：count ######

*  流提供 count 方法来数一数其中的元素个数：long count()，该方法返回一个long值代表元素个数

//基本使用
    import java.util.stream.Stream;
    public class StreamCount {
        
        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
        }
    }

###### 8.4.5.取用前几个：limit ######

*  limit 方法可以对流进行截取，只取用前n个

//Stream<T> limit(long maxSize);
    //参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作
    
    
    //基本使用
    import java.util.stream.Stream;
    public class StreamLimit {
        
        public static void main(String[] args) {
        
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.limit(2);
            System.out.println(result.count()); // 2
        }
    }

###### 8.4.6.跳过前几个：skip ######

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

//Stream<T> skip(long n);
    //如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流
    
    
    //基本使用
    import java.util.stream.Stream;
    public class StreamSkip {
        
        public static void main(String[] args) {
        
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.skip(2);
            System.out.println(result.count()); // 1
    	}
    }

###### 8.4.7.组合：concat ######

*  如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat
 *  这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

//static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
    
    //基本使用
    import java.util.stream.Stream;
    public class StreamConcat {
        
        public static void main(String[] args) {
        
            Stream<String> streamA = Stream.of("张无忌");
            Stream<String> streamB = Stream.of("张翠山");
            Stream<String> result = Stream.concat(streamA, streamB);
        }
    }

#####  #####