2021-05-05 15:46  阅读(2478)
文章分类:Java 基础系列 文章标签:JavaJava 基础
©  原文作者:唯一浩哥 原文地址:https://www.jianshu.com/u/c52a29db48b6

一、概述

Stream操作简称流操作,这里的流与IO流毫无关系,这里的流指的是流式操作,就是流水线操作。

Stream流操作主要包包括三大模块:创建流操作、中间流操作、终结流操作。

其中创建流主要是创建Stream对象。每个Stream对象只能使用一次终结操作。

中间流操作指的是各种中间流操作方法,比如去重、过滤、排序等

终结流操作指的结果操作,终结操作的目的是产生最终结果。

二、创建流

2.1 基于数组创建流

        public class StreamTest {
            public static void createStream() {
                // 通过数组生成流
                int[] ints = {1,2,3,4,5,6};
                IntStream s1 = Arrays.stream(ints);
                Stream s2 = Stream.of("111","222","333");
                String[] ss = {"123","321","456","654"};
                Stream<String> s3 = Arrays.stream(ss);
            }
        }
    

3.2 通过构建器生成流

        public class StreamTest {
            public static void createStream() {
                // 通过构建器生成流
                Stream<Object> s4 = Stream.builder().add("123").add("321").add("444").add("@21").build();
            }
        }
    

3.3 基于集合生成流

        public class StreamTest {
            public static void createStream() {
                // 通过集合生成流
                List<String> lists = Arrays.asList("123","321","1212","32321");
                Stream<String> s5 = lists.stream();
                Stream<String> s6 = lists.parallelStream();// 并行流
            }
        }
    

3.4 创建空流

        public class StreamTest {
            public static void createStream() {
                // 创建空流
                Stream<String> s7  = Stream.empty();
            }
        }
    

3.5 基于函数创建无限流

        public class StreamTest {
            public static void createStream() {
                // 创建无限流
                Stream.generate(()->"number"+new Random().nextInt()).limit(100).forEach(System.out::println);
                Stream.iterate(0,n -> n+2).limit(10).forEach(System.out::println);
            }
        }
    

三、流中间操作

这里的流中间操作指的是该操作的返回值仍然是流。

序号 操作 方法 说明 备注
1 filter Stream<T>filter(Predicate<?superT>predicate) 返回当前流中满足参数predicate过滤条件的元素组成的新流 过滤器
2 map <R>Stream<R>map(Function<?superT,?extendsR>mapper) 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新流 函数
3 mapToInt IntStreammapToInt(ToIntFunction<?superT>mapper) 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新的Int流 函数
4 mapToLong LongStreammapToLong(ToLongFunction<?superT>mapper) 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新的Long流 函数
5 mapToDouble DoubleStreammapToDouble(ToDoubleFunction<?superT>mapper) 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新的Double流 函数
6 flatMap <R>Stream<R>flatMap(Function<?superT,?extendsStream<?extendsR>>mapper) 根据给定的mapper作用于当前流的每个元素,将结果组成新的流来返回 扁平函数
7 flatMapToInt IntStreamflatMapToInt(Function<?superT,?extendsIntStream>mapper) 根据给定的mapper作用于当前流的每个元素,将结果组成新的Int流来返回 扁平函数
8 flatMapToLong LongStreamflatMapToLong(Function<?superT,?extendsLongStream>mapper) 根据给定的mapper作用于当前流的每个元素,将结果组成新的Long流来返回 扁平函数
9 flatMapToDouble DoubleStreamflatMapToDouble(Function<?superT,?extendsDoubleStream>mapper) 根据给定的mapper作用于当前流的每个元素,将结果组成新的Double流来返回 扁平函数
10 distinct Stream<T>distinct() 返回去掉当前流中重复元素之后的新流 去重
11 sorted Stream<T>sorted() 返回当前流中元素排序之后的新流,需要元素类型实现Comparable 排序
12 sorted Stream<T>sorted(Comparator<?superT>comparator) 返回当前流中元素排序之后的新流,需要传递一个Comparator 排序
13 peek Stream<T>peek(Consumer<?superT>action) 针对流中的每个元素执行操作action 查阅
14 limit Stream<T>limit(longmaxSize) 返回指定的数量的元素组成的新流 限制
15 skip Stream<T>skip(longn) 返回第n个之后的元素组成的新流 跳过

扁平函数,就是将当前流的每个元素通过执行给定的mapper操作,从而扩充,释放每个元素内的子元素,从而形成一个由所有子元素组成的新流,比如当前流是包含N个字符串的流,使用这个方法,可以获取到包含字符串中字符组成的流。

3.1 filter

filter方法是过滤器方法,针对的是流中所有元素,满足条件的元素将会被保留以组成新的流。

        public class StreamTest {
            public static void filterTest(List<String> list){
                list.stream()
                        .filter(e -> e.length() > 4 && e.length()<7)// 过滤掉长度小于等于4,大于等于7的元素
                        .peek(System.out::println)// 查阅中间流结果
                        .collect(Collectors.toList());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                filterTest(list);
            }
        }
    

执行结果为:

        asdaa
        3e3e3e
    

filter方法的参数是Predicate类型,这个函数式接口用于获取一个参数返回一个boolean值,整个参数作为过滤条件。

3.2 map

map方法可以理解为函数,需要针对流中的每个元素执行,然后将执行的结果组成新的流返回。

        public class StreamTest {
            public static void mapTest(List<String> list){
                list.stream()
                        .map(e -> "@" + e)// 为每个元素执行操作:添加前缀
                        .peek(System.out::println)// 查阅中间流结果
                        .collect(Collectors.toList());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                mapTest(list);
            }
        }
    

执行结果为:

        @123
        @456
        @789
        @1101
        @asdaa
        @3e3e3e
        @2321eew
        @212121121
    

map方法的参数类型为Function,该函数式接口用于接受一个参数,返回一个结果。

mapToInt、mapToLong、mapToDouble方法是map方法的扩展,其参数分别为ToIntFunction、ToLongFunction、ToDoubleFunction,分别接口一个参数,返回指定类型的值,分别为int、long、double,那么定义方法的时候就要注意返回值的类型了,必须一致,最后组成的新流就是一个int或long或double元素流(IntStream、LongStream、DoubleStream)。

mapToInt的简单使用(其他类似):

        public class StreamTest {
            public static void mapToIntTest(List<String> list){
                list.stream()
                        .mapToInt(e -> e.length())// 以元素的长度为新流
                        .peek(System.out::println)// 查询中间结果
                        .toArray();
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                mapToIntTest(list);
            }
        }
    

执行结果为:

        3
        3
        3
        4
        5
        6
        7
        9
    

3.3 flatMap

flatMap和map还是有点关系的,都是针对流中的每一个元素进行操作,将结果组成新流,不过flatMap含有一层扩展之意,就是当流中元素包含子元素的时候,通过该方法,获取到元素的子元素,并将子元素组成新流返回。

        public class StreamTest {
            public static void flatMap(List<String> list){
                list.stream()
                        .filter(e -> e.length()>5 && e.length()<7)
                        .peek(System.out::println)
                        .map(e -> e.split(""))// 将每个字符串元素分解为字符数组
                        .flatMap(Arrays::stream)//将每个字符数组并转化为流
                        .peek(System.out::println)
                        .collect(Collectors.toList());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                flatMap(list);
            }
        }
    

执行结果为:

        3e3e3e
        3
        e
        3
        e
        3
        e
    

flatMapToInt、flatMapToLong、flatMapToDouble类似于之前的mapToInt之类。

3.4 distinct

distinct方法用于去重,很简单。

        public class StreamTest {
            public static void distinctTest(){
                int[] int1 = {1,2,3,4};
                int[] int2 = {5,3,7,1};
                List<int[]> ints = Arrays.asList(int1,int2);
                ints.stream()
                        .flatMapToInt(Arrays::stream)
                        .distinct()
                        .peek(System.out::println)
                        .toArray();
            }
            public static void main(String[] args) {
                distinctTest();
            }
        }
    

执行结果为:

        1
        2
        3
        4
        5
        7
    

结果中显而易见,重复的1和3被去除了。

3.5 sorted

sorted表示对流中的元素进行排序,需要使用Conparable和Comparator。

        public class StreamTest {
            public static void sortedTest(List<String> list){
                System.out.println("----自然顺序:");
                list.stream().sorted().peek(System.out::println).collect(Collectors.toList());
                System.out.println("----指定排序:");
                list.stream().sorted((a,b) -> a.length()-b.length()).peek(System.out::println).collect(Collectors.toList());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                sortedTest(list);
            }
        }
    

执行结果为:

        ----自然顺序:
        1101
        123
        212121121
        2321eew
        3e3e3e
        456
        789
        asdaa
        ----指定排序:
        123
        456
        789
        1101
        asdaa
        3e3e3e
        2321eew
        212121121
    

当调用无参的sorted方法时,采用自然排序法排序,当使用指定比较器的方式时,可以自由指定排序规则。

3.6 limit

limit可用于从首个元素开始截取N个元素,组成新流返回。

        public class StreamTest {
            public static void limitTest(List<String> list){
                list.stream().limit(2).peek(System.out::println).collect(Collectors.toList());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                limitTest(list);
            }
        }
    

执行结果为:

        123
        456
    

3.7 skip

skip表示放弃N个元素,将剩余元素组成新流返回。

        public class StreamTest {
            public static void skipTest(List<String> list){
                list.stream().skip(2).peek(System.out::println).collect(Collectors.toList());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
                skipTest(list);
            }
        }
    

执行结果为:

        789
        1101
        asdaa
        3e3e3e
        2321eew
        212121121
    

放弃了前2个元素,将剩余元素组成了新流。

四、流终结操作

序号 操作 方法 说明 备注
1 forEach voidforEach(Consumer<?superT>action) 对流中的每个元素执行指定的操作action 遍历
2 forEachOrdered voidforEachOrdered(Consumer<?superT>action) 如果有序,则按序遍历流中元素,针对每个元素执行指定操作 按序遍历
3 toArray Object[]toArray() 返回一个包含流中所有元素的数组 数组化
4 toArray <A>A[]toArray(IntFunction<A[]>generator) 返回一个包含流中所有元素的参数指定类型的数组 数组化
5 reduce Treduce(Tidentity,BinaryOperator<T>accumulator) 以给定初始值为基础归纳流中元素,返回一个值 归纳
6 reduce Optional<T>reduce(BinaryOperator<T>accumulator) 直接归纳流中的元素,返回一个封装有结果的Optional 归纳
7 reduce <U>Ureduce(Uidentity,BiFunction<U,?superT,U>accumulator,BinaryOperator<U>combiner) 以给定的初始值为基础,(并行)归纳流中元素,最后将各个线程的结果再统一归纳,返回一个值 归纳
8 collect <R,A>Rcollect(Collector<?superT,A,R>collector) 根据给定的收集器收集元素 归纳
9 collect <R>Rcollect(Supplier<R>supplier,BiConsumer<R,?superT>accumulator,BiConsumer<R,R>combiner) 根据给定的各个参数归纳元素 归纳
10 max Optional<T>max(Comparator<?superT>comparator) 根据给定的比较器,返回流中最大元素的Optional表示 最大值
11 min Optional<T>min(Comparator<?superT>comparator) 根据给定的比较器,返回流中最小元素的Optional表示 最小值
12 count longcount() 返回流中元素的个数 计数
13 anyMatch booleananyMatch(Predicate<?superT>predicate) 校验流中是否有满足给定条件的元素 校验
14 allMatch booleanallMatch(Predicate<?superT>predicate) 校验流中的元素是否全部满足给定条件 校验
15 noneMatch booleannoneMatch(Predicate<?superT>predicate) 校验流中的元素是否全不满足给点条件 校验
16 findFirst Optional<T>findFirst() 返回首个元素的Optional表示,如果为空流,返回空的Optional 返回首个元素
17 findAny Optional<T>findAny() 如果流中有元素,则返回第一个元素的Optional表示,否则返回一个空的Optional 校验是否为空流

4.1 forEach和forEachOrdered

forEach就是遍历操作,针对流中的每个元素做最后的操作。

        public class StreamTest {
            public static void forEachTest(List<String> list){
                list.stream().parallel().forEach(System.out::println);
            }
            public static void forEachOrderedTest(List<String> list){
                list.stream().parallel().forEachOrdered(System.out::println);
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                forEachTest(list);
                System.out.println("----------");
                forEachOrderedTest(list);
            }
        }
    

执行结果为:

        asdaa
        212121121
        789
        1101
        2321eew
        3e3e3e
        456
        123
        ----------
        123
        456
        789
        1101
        212121121
        asdaa
        3e3e3e
        2321eew
    

二者都是遍历操作,从结果是可以看出来,如果是单线程(也就是不加parallel方法的情况)那么二者结果是一致的,但是如果采用并行遍历,那么就有区别了,forEach并行遍历不保证顺序(顺序随机),forEachOrdered却是保证顺序来进行遍历的。

4.2 toArray

        public class StreamTest {
            public static void toArrayTest(List<String> list){
                Object[] objs = list.stream().filter(e -> e.length()>6).toArray();
                String[] ss = list.stream().filter(e -> e.length()>6).toArray(String[]::new);
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                toArrayTest(list);
            }
        }
    

toArray有两个方法,一个是无参方法,一个有参方法。

无参方法返回的只能是Object[]数组类型,而有参方法,可以指定结果数组类型,此乃二者区别。

使用有参方法可以直接完成类型转换,一次到位。

4.4 reduce

reduce方法有三个重载的方法,

        public interface Stream<T> extends BaseStream<T, Stream<T>> {
            Optional<T> reduce(BinaryOperator<T> accumulator);// 编号1
            T reduce(T identity, BinaryOperator<T> accumulator);// 编号2
            <U> U reduce(U identity,
                         BiFunction<U, ? super T, U> accumulator,
                         BinaryOperator<U> combiner);// 编号3
        }
    

这三个方法的作用其实是一样的,就是归纳总结的意思。

首先看编号1方法,只有一个参数accumulator,这是一个累加器,方法的作用就是将这个累加器作用到流中的每一个元素,他需要两个输入参数,有一个输出参数,意思是对两个元素执行某些操作,返回一个结果,然后将这个结果与下一个元素作为参数再输入该方法,执行操作后再返回一个新结果,以此类推,直到最后一个元素执行完毕,返回的就是最终结果,因为流中的元素我们是不确定的,那么我们就无法确定reduce的结果,因为如果流为空,那么将会返回null,所以使用Optional作为返回值,妥善处理null值。

再看编号2方法,在编号1方法的基础上加了一个identity,且不再使用Optional,为什么呢,因为新加的identity其实是个初始值,后续的操作都在这个值基础上执行,那么也就是说,,如果流中没有元素的话,还有初始值作为结果返回,不会存在null的情况,也就不用Optional了。

再看编号3方法,在编号2方法的基础上又加了一个参数combiner,其实这个方法是用于处理并行流的归纳操作,最后的参数combiner用于归纳各个并行的结果,用于得出最终结果。

那么如果不使用并行流,一般使用编号2方法就足够了。

示例:

        public class StreamTest {
            public static void reduceTest(){
                List<Integer> ints = Arrays.asList(1,2,3,4,5,6,7,8,9);
                Optional<Integer> optional = ints.stream().reduce(Integer::sum);
                System.out.println(optional.get());
                System.out.println("-------------");
                Integer max = ints.stream().reduce(Integer.MIN_VALUE, Integer::max);
                System.out.println(max);
                System.out.println("-------------");
                Integer min = ints.parallelStream().reduce(Integer.MAX_VALUE, Integer::min, Integer::min);
                System.out.println(min);
            }
            public static void main(String[] args) {
                reduceTest();
            }
        }
    

执行结果为:

        45
        -------------
        9
        -------------
        1
    

4.5 collect

collect操作是Stream中最强大的方法了,几乎可以得到任何你想要的结果,collect方法有两个重载方法:

        public interface Stream<T> extends BaseStream<T, Stream<T>> {
            <R> R collect(Supplier<R> supplier,
                          BiConsumer<R, ? super T> accumulator,
                          BiConsumer<R, R> combiner);// 编号1
            <R, A> R collect(Collector<? super T, A, R> collector);// 编号2
        }
    

collect是收集的意思,这里的作用就是收集归纳,将流中的数据映射为各种结果。

首先看看编号1方法,有三个参数:supplier用于生成一个R类型的结果容器来盛放结果,accumulator累加器用于定义盛放的方式,其中T为一个元素,R为结果容器,第三个参数combiner的作用是将并行操作的各个结果整合起来。

        public class StreamTest {
            public static void collectTest1(List<String> list){
                ArrayList<String> arrayList = list.stream().skip(4).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
                arrayList.forEach(System.out::println);
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                collectTest1(list);
            }
        }
    

执行结果:

        212121121
        asdaa
        3e3e3e
        2321eew
    

例子中,第一个:ArrayList::new表示创建一个新的ArrayList集合,第二个 ArrayList::add表示将元素一个一个添加到之前的集合中,第三个ArrayList::addAll表示将多个线程的ArrayList集合一个一个的整体添加到第一个集合中,最终整合出一个最终结果并返回。

然后我们重点来看看编号2方法。

它只需要一个Collector类型的参数,这个Collector可以称呼为收集器,我们可以随意组装一个收集器来进行元素归纳。

Collector是定义来承载一个收集器,但是JDK提供了一个Collectors工具类,在这个工具类里面预实现了N多的Collector供我们直接使用,之前的Collectors.toList()就是其用法之一。具体见下文。

        public class StreamTest {
            public static void collectTest2(List<String> list){
                Set<String> set = list.stream().skip(4).collect(Collectors.toSet());
                set.forEach(System.out::println);
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                collectTest2(list);
            }
        }
    

执行结果为:

        212121121
        2321eew
        3e3e3e
        asdaa
    

有关Collector具体可阅读:Java流式操作系列-Collector和Collectors

4.6 max\min

通过给定的比较器,得出流中最大\最小的元素,为避免null返回,这里使用Optional来封装返回值。

        public class StreamTest {
            public static void maxMinTest(List<String> list){
                System.out.println("长度最大:" + list.stream().max((a,b)-> a.length()-b.length()));
                System.out.println("长度最小:" + list.stream().min((a,b)-> a.length()-b.length()));
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                maxMinTest(list);
            }
        }
    

执行结果为:

        长度最大:Optional[212121121]
        长度最小:Optional[123]
    

4.7 count

count是无参方法,用于计数,返回流中元素个数。

        public class StreamTest {
            public static void countTest(List<String> list){
                System.out.println("元素个数为:" + list.stream().count());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                countTest(list);
            }
        }
    

执行结果为:

        元素个数为:8
    

4.8 anyMatch

该方法需要一个Predicate参数,用于校验流中的元素,只要有一个满足规则,则返回true,全不满足,返回false。

        public class StreamTest {
            public static void anyMatchTest(List<String> list){
                System.out.println(list.stream().anyMatch(e -> e.length()>10));
                System.out.println(list.stream().anyMatch(e -> e.length()>8));
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                anyMatchTest(list);
            }
        }
    

执行结果为:

        false
        true
    

4.9 allMatch

该方法同样需要一个Predicate参数,用于校验流中的所有元素,只有全部满足规则才能返回true,只要有一个不满足则返回false。

        public class StreamTest {
            public static void allMatchTest(List<String> list){
                System.out.println(list.stream().allMatch(e -> e.length()>1));
                System.out.println(list.stream().allMatch(e -> e.length()>3));
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                allMatchTest(list);
            }
        }
    

执行结果为:

        true
        false
    

4.10 noneMatch

该方法同样需要一个Predicate参数,用于校验流中的所有元素,只有所有元素都不满足规则的情况下返回true,否则返回false。

        public class StreamTest {
            public static void noneMatchTest(List<String> list){
                System.out.println(list.stream().noneMatch(e -> e.length()>10));
                System.out.println(list.stream().noneMatch(e -> e.length()>8));
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                noneMatchTest(list);
            }
        }
    

执行结果为:

        true
        false
    

4.11 findFirst

该方法无参数,主要用于获取流中的第一个元素,如果流无序,那么可能返回任意一个。

        public class StreamTest {
            public static void findFirstTest(List<String> list){
                System.out.println(list.stream().parallel().findFirst().get());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                findFirstTest(list);
            }
        }
    

执行结果为:

        123
    

4.12 findAny

该方法无参数,主要用于获取流中的任一元素。

        public class StreamTest {
            public static void findAnyTest(List<String> list){
                System.out.println(list.stream().parallel().findAny().get());
            }
            public static void main(String[] args) {
                List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
                findAnyTest(list);
            }
        }
    

执行结果为:

        asdaa
    

五、总结

流式操作代码描述性强,易理解,而且功能强大,可以简化很多集合操作。在我们需要对集合数据进行处理的时候,不妨试试使用流式操作来实现。

参考:


来源:https://www.jianshu.com/u/c52a29db48b6

点赞(0)
版权归原创作者所有,任何形式转载请联系作者; Java 技术驿站 >> Java基础系列-Stream
上一篇
Java基础系列-Collector和Collectors
下一篇
Java基础系列-Optional