Stream流常用方法总结

文章详细介绍了Java中的StreamAPI,包括创建Stream、中间处理和终止管道的操作,如filter、map、limit、skip等,并提供了多个示例代码来展示如何使用这些方法处理数据流。此外,还通过一个具体问题的两种解决方案对比展示了Stream的高效性。
摘要由CSDN通过智能技术生成

导读:

概括讲,可以将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

  • 4
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
JavaStream常用方法包括获取Stream、中间方法和终结方法。 获取Stream方法有两种:集合获取Stream和数组获取Stream。集合获取Stream可以使用集合类的stream()方法,例如Map的keySet()方法可以获取键,values()方法可以获取值,entrySet()方法可以获取键值对。数组获取Stream可以使用Arrays类的stream()方法,将数组转换为Stream。 中间方法是对Stream进行操作的方法,一次操作完毕之后,还可以继续进行其他操作。常用的中间方法包括filter()、map()、flatMap()、distinct()、sorted()、limit()和skip()等。filter()方法用于过滤元素,map()方法用于对元素进行映射,flatMap()方法用于扁平化处理,distinct()方法用于去重,sorted()方法用于排序,limit()方法用于限制元素数量,skip()方法用于跳过元素。 终结方法Stream的最后一个操作,一个Stream只能有一个终结方法常用的终结方法包括forEach()、collect()、count()、min()、max()、reduce()和toArray()等。forEach()方法用于遍历元素,collect()方法用于将元素收集到集合中,count()方法用于统计元素数量,min()方法用于获取最小值,max()方法用于获取最大值,reduce()方法用于对元素进行归约操作,toArray()方法用于将元素转换为数组。 综合应用Stream常用方法可以实现对数据的筛选、转换、排序、统计等操作,提高代码的简洁性和可读性。 #### 引用[.reference_title] - *1* *2* *3* [Java 基础进阶篇(十二):Stream 常用方法总结](https://blog.csdn.net/weixin_43819566/article/details/130537949)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阳光不锈@

如果有帮助的话,打赏一下吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值