Stream流常用方法总结

导读:

概括讲,可以将Stream流操作分为3种类型:

  • 创建Stream --开始管道
  • Stream中间处理  --中间管道
  • 终止Steam --终止管道

每个Stream管道操作类型都包含若干API方法,先列举下各个API方法的功能介绍。

  • 开始管道

主要负责新建一个Stream流,或者基于现有的数组、List、Set、Map等集合类型对象创建出新的Stream流。

API 功能说明
stream() 创建出一个新的stream串行流对象
parallelStream() 创建出一个可并行执行的stream流对象
Stream.of() 通过给定的一系列元素创建一个新的Stream串行流对象
  • 中间管道

负责对Stream进行处理操作,并返回一个新的Stream对象,中间管道操作可以进行叠加

API 功能说明
filter() 按照条件过滤符合要求的元素, 返回新的stream流
map() 将已有元素转换为另一个对象类型,一对一逻辑,返回新的stream流
flatMap() 将已有元素转换为另一个对象类型,一对多逻辑,即原来一个元素对象可能会转换为1个或者多个新类型的元素,返回新的stream流
limit() 仅保留集合前面指定个数的元素,返回新的stream流
skip() 跳过集合前面指定个数的元素,返回新的stream流
concat() 将两个流的数据合并起来为1个新的流,返回新的stream流
distinct() 对Stream中所有元素进行去重,返回新的stream流
sorted() 对stream中所有的元素按照指定规则进行排序,返回新的stream流
peek() 对stream流中的每个元素进行逐个遍历处理,返回处理后的stream流
  • 终止管道

顾名思义,通过终止管道操作之后,Stream流将会结束,最后可能会执行某些逻辑处理,或者是按照要求返回某些执行后的结果数据。

API 功能说明
count() 返回stream处理后最终的元素个数
max() 返回stream处理后的元素最大值
min() 返回stream处理后的元素最小值
findFirst() 找到第一个符合条件的元素时则终止流处理
findAny() 找到任何一个符合条件的元素时则退出流处理,这个对于串行流时与findFirst相同,对于并行流时比较高效,任何分片中找到都会终止后续计算逻辑
anyMatch() 返回一个boolean值,类似于isContains(),用于判断是否有符合条件的元素
allMatch() 返回一个boolean值,用于判断是否所有元素都符合条件
noneMatch() 返回一个boolean值, 用于判断是否所有元素都不符合条件
collect() 将流转换为指定的类型,通过Collectors进行指定
toArray() 将流转换为数组
iterator() 将流转换为Iterator对象
foreach() 无返回值,对元素进行逐个遍历,然后执行给定的处理逻辑

举例练习: 

package com.wei.demo01;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@SpringBootTest
class DemoApplicationTests {

    /**
     * stream foreach 遍历流
     */
    @Test
   public void test1(){
       Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi");
       st.forEach(name -> System.out.println(name));
   }

    /**
     * filter过滤流
     */
   @Test
    public void test2(){
       Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
       Stream<String> z = st.filter(name -> name.startsWith("z") && name.length() == 3);
       z.forEach(name-> System.out.println(name));
   }

    /**
     * map map流 一对一转换
     */
    @Test
    public void test3(){
        Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
        st.map(str -> str += str.toUpperCase()).forEach(str -> System.out.println(str));
    }
    /**
     * count 统计流
     * 相当于size 统计元素个数
     * 返回long值
     */
    @Test
    public void test4(){
        Stream<String> st = Stream.of("1", "2", "3", "4", "5", "6");
       long ct =  st.map(str -> Integer.parseInt(str))
                .filter(str -> str >= 3)
               .count();
        System.out.println(ct);
    }
    /**
     * limit 截取流
     * 截取前几个,n=2,截取前两个打印
     */
    @Test
    public void test5(){
        Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
        st.limit(3).forEach(str -> System.out.println(str));
    }

    /**
     * skip 跳跳流
     * 跳过前几个元素
     */
    @Test
    public void test6(){
        Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
        st.skip(2).forEach(str -> System.out.println(str));
    }

    /**
     * concat 合并流
     * 把两个流合并起来
     */
    @Test
    public void test7(){
        Stream<String> st = Stream.of("zhangsan", "lisi", "wanger", "mazi", "zhangfei","zha");
        Stream<String> st1 = Stream.of("1", "2", "3", "4", "5", "6");
        Stream<String> concat = Stream.concat(st, st1);
        concat.forEach(str -> System.out.println(str));

    }

    /**
     * 问题是:从给定句子中返回单词长度大于5的单词列表,按长度倒序输出,最多返回3个
     *
     *
     *  * 【常规方式】
     *  * 从给定句子中返回单词长度大于5的单词列表,按长度倒序输出,最多返回3个
     *  *
     *  * @param sentence 给定的句子,约定非空,且单词之间仅由一个空格分隔
     *  * @return 倒序输出符合条件的单词列表
     *
     */
    public static List<String>  test8(String juzi){
        String[] words = juzi.split(" ");
       List<String> list = new ArrayList<>();
        for (String word:words
             ) {
            if (word.length() > 5){
                list.add(word);
            }
        }
        list.sort((o1, o2) -> o2.length() - o1.length());
        System.out.println(list);
        if (list.size() > 3) {
            list = list.subList(0, 3);
        }
        return  list;
    }

    public static void main(String[] args) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long startTime = System.currentTimeMillis();
        List<String> strings = test8("i love you so much amercian haahhahah zhognguo meiguo xiaoriben suoheng");
        long endTime = System.currentTimeMillis();
        long resultTime1 = endTime - startTime;
        String format = simpleDateFormat.format(resultTime1);
        System.out.println(format);
        System.out.println(strings);

        long startTime1 = System.currentTimeMillis();
        List<String> strings1 = test9("i love you so much amercian haahhahah zhognguo meiguo xiaoriben suoheng");
        long endTime2 = System.currentTimeMillis();
        long resultTime = endTime2 - startTime1;
        String format1 = simpleDateFormat.format(resultTime);
        System.out.println(format1);
       System.out.println(strings1);
    }
    /**
     * 利用流的思想解决以上问题
     */
    @Test
    public static  List<String> test9(String juzi){
        return Arrays.stream(juzi.split(" "))
                .filter(word -> word.length() > 5)
                .sorted((o1, o2) -> o2.length() - o1.length())
                .limit(3)
                .collect(Collectors.toList());
    }

    /**
     * flatMap是 一对多
     * 从多层转向单层 就要用faltMap
     * 单层到单层 一对一,就要用map
     */
    @Test
    public void stringToIntFlatmap() {
        List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
        // 使用流操作
        List<String> results = sentences.stream()
                .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
                .collect(Collectors.toList());
        System.out.println(results);
    }
}

参考地址:https://www.cnblogs.com/softwarearch/p/16466235.html

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码

)">
< <上一篇
下一篇>>