Stream流

已于 2023-02-08 06:02:23 修改
阅读量295 收藏
点赞数
分类专栏： Java 文章标签： java
于 2023-02-07 08:19:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42218313/article/details/128911000
版权

体验Stream流

  • Stream流一般配合Lamda表达式使用
  • 函数式编程
  • 通过字面意思即可展示无关逻辑的语句

在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        //创建集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("李白");
        list.add("王二");
        list.add("张译");
        list.add("马文才");
        list.add("张怀民");

        //创建新集合，以存储“张”开头的元素
        ArrayList<String> zhang = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")){
                zhang.add(s);
            }
        }

        //创建新集合，以存储“张”开头的长度为3的元素
        ArrayList<String> zhangSan = new ArrayList<>();
        for (String s : zhang) {
            if (s.length()==3){
                zhangSan.add(s);
            }
        }
        
		//遍历集合
        for (String s : zhangSan) {
            System.out.println(s);
        }
    }
}

运行结果：

张三丰
张怀民

不难看出，代码过长且重复度过高；通过Stream流改进

public class Demo {
    public static void main(String[] args) {
        //创建集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("李白");
        list.add("王二");
        list.add("张译");
        list.add("马文才");
        list.add("张怀民");

		//使用Stream和方法引用改进
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

    }
}

运行结果：

张三丰
张怀民

Stream流的生成方式

Stream流的使用

  • 生成流
    通过数据源生成流
    如：list.stream()
  • 中间操作
    一个流后面可以跟多个中间操作
    如：filter()
    如：filter().filter()
  • 终结操作
    一个流只能有一个终结操作
    如：forEach()

Stream流的常见生成方式

在这里插入图片描述

public class Demo1 {
    public static void main(String[] args) {
        //Collection体系的集合,使用默认方法stream()生成流
        ArrayList<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        HashSet<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //Map体系集合，间接生成流
        HashMap<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(T... values)生成流
        String[] strArr = {"hello","world","java"};
        //of中的参数可变
        Stream<String> strArrStream = Stream.of(strArr);
        Stream<String> strArrStream1 = Stream.of("hello","world","java");
        Stream<Integer> strArrStream2 = Stream.of(10,20,33);
    }
}

Stream流中间操作

  • 以Stream开头的语句，做了终结操作之后，就不能再次开始；否则会报错。
  • 以数据源开始转为stream流的语句，做了终结操作之后，还可以再次以数据源开始做操作

在这里插入图片描述
在这里插入图片描述

filter

在这里插入图片描述

public class Demo {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("李白");
        list.add("王二");
        list.add("张译");
        list.add("马文才");
        list.add("张怀民");

        //输出“张”开头的元素
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("----------------");

        //输出长度为3的元素
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("----------------");

        //输出“张”开头，并且长度为3的元素
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

    }
}

运行结果：

张三丰
张译
张怀民
----------------
张三丰
马文才
张怀民
----------------
张三丰
张怀民

limit & skip

在这里插入图片描述
在这里插入图片描述

public class Demo {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("李白");
        list.add("王二");
        list.add("张译");
        list.add("马文才");
        list.add("张怀民");

        //输出前3个元素
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("-------------");

        //输出除了前3个元素以外的元素
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("-------------");

        //跳过前2个元素，输出接下来的2个元素
        list.stream().skip(2).limit(2).forEach(System.out::println);

    }
}

运行结果：

张三丰
李白
王二
-------------
张译
马文才
张怀民
-------------
王二
张译

concat & distinct

在这里插入图片描述

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("李白");
        list.add("王二");
        list.add("张译");
        list.add("马文才");
        list.add("张怀民");

        //需求1：获取前4个元素，组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //需求2：跳过2个元素，组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //需求3：合并需求1和需求2的流，输出
        //Stream.concat(s1,s2).forEach(System.out::println);

        //需求4：合并需求1和需求2的流，输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

运行结果：

张三丰
李白
王二
张译
马文才
张怀民

sorted

在这里插入图片描述

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("libai");
        list.add("yangyuhuan");
        list.add("wuzetian");
        list.add("zhaohuaizhen");
        list.add("sikongzhen");
        list.add("shangguanwaner");

        //需求1：按照字母顺序输出数据
        list.stream().sorted().forEach(System.out::println);
        System.out.println("------------");

        //需求2：按照字符串长度输出数据
        list.stream().sorted((s1, s2) -> s1.length() - s2.length()).forEach(System.out::println);
        System.out.println("------------");

        //需求3：按照字符串长度输出数据，长度相同时自然排序
        list.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            int num2 = num == 0 ? s1.compareTo(s2) : num;
            return num2;
        }).forEach(System.out::println);
    }
}

运行结果：

libai
shangguanwaner
sikongzhen
wuzetian
yangyuhuan
zhaohuaizhen
------------
libai
wuzetian
yangyuhuan
sikongzhen
zhaohuaizhen
shangguanwaner
------------
libai
wuzetian
sikongzhen
yangyuhuan
zhaohuaizhen
shangguanwaner

map & mapToInt

在这里插入图片描述

Stream流调用了mapToInt()方法，就会变成IntStream流
IntStream流可以调用sum()方法

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需求：使用map()将集合中的字符串转为整数后输出
        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        System.out.println("-----------");
        //方法引用
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("-----------");

        //需求2：使用mapToInt()将集合中的字符串转为整数后输出
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("-----------");

        //需求3：使用IntStream()中的sum(),返回int元素的总和,输出结果
        System.out.println(list.stream().mapToInt(Integer::parseInt).sum());
    }
}

运行结果：

10
20
30
40
50
-----------
10
20
30
40
50
-----------
10
20
30
40
50
-----------
150

Stream流常见的终结操作方法

在这里插入图片描述

forEach & count

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("李白");
        list.add("王二");
        list.add("张译");
        list.add("马文才");
        list.add("张怀民");

        //需求1：输出集合中的元素
        list.stream().forEach(System.out::println);

        //需求1：统计以“张”开头的元素，输出统计结果
        System.out.println(list.stream().filter(s -> s.startsWith("张")).count());
    }
}

运行结果：

张三丰
李白
王二
张译
马文才
张怀民
3

综合练习

在这里插入图片描述
在这里插入图片描述

public class Demo6 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("马保国");
        list1.add("陈龙");
        list1.add("张丰毅");
        list1.add("胡歌");
        list1.add("李永健");
        list1.add("赵本山");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("林黛玉");
        list2.add("刘亦菲");
        list2.add("陶虹");
        list2.add("宋佳");
        list2.add("林心如");
        list2.add("张嘉倪");

        //男演员只要名字为三个字的前3人
        Stream<String> man = list1.stream().filter(s -> s.length() == 3).limit(3);

        //女演员只要姓林的，并且不要第一个
        Stream<String> women = list2.stream().filter(s -> s.startsWith("林")).skip(1);

        //把man和women合并在一起
        Stream<String> concat = Stream.concat(man, women);

        //将concat中的元素作为构造方法的参数，创建对象，遍历数据
        concat.map(Actor::new).forEach(s-> System.out.println(s.getName()));
    }
}

运行结果：

马保国
张丰毅
李永健
林心如

收集操作

在这里插入图片描述

将流中的数据存入集合

public class Demo6 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("马保国");
        arrayList.add("陈龙");
        arrayList.add("张丰毅");
        arrayList.add("胡歌");
        arrayList.add("李永健");
        arrayList.add("张择端");

        //需求1：以流的方式拿到以“张”开头的元素，
        Stream<String> strStream = arrayList.stream().filter(s -> s.startsWith("张"));

        //需求2：将流收集到list集合,并遍历集合
        List<String> list = strStream.collect(Collectors.toList());
        for (String s : list) {
            System.out.println(s);
        }

        System.out.println("------");
        HashSet<Integer> hashSetset = new HashSet<>();
        hashSetset.add(10);
        hashSetset.add(20);
        hashSetset.add(30);
        hashSetset.add(33);
        hashSetset.add(35);

        //需求3：获取大于25的元素
        Stream<Integer> setStream = hashSetset.stream().filter(s -> s > 25);

        //需求4：将流收集到set集合,并遍历
        Set<Integer> set = setStream.collect(Collectors.toSet());
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

运行结果：

张丰毅
张择端
------
33
35
30

public class Demo6 {
    public static void main(String[] args) {
        String[] str = {"张艺兴,11","刘强东,29","朱之文,33","高启强,28"};
        //需求1：获取年龄大于28的元素
        Stream<String> stringStream = Stream.of(str).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        //需求2：把流存入Map集合，并遍历
        Map<String, Integer> map = stringStream.collect(Collectors.toMap(s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1])));
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
    }
}

运行结果：

朱之文-33
刘强东-29
茶碗儿
关注
专栏目录
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
详解Java8新特性Stream之list转map及问题解决
08-25
主要介绍了详解Java8新特性Stream之list转map及问题解决，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
list.stream().map().collect(Collectors.toList())
shylhd的专栏
01-22 1万+
ist.stream().map().collect(Collectors.toList())
Java8中List使用stream转Map常用的几个方式
drnrrwfs的博客
03-21 1万+
第一种： 取list中某2个字段作为Map的K,V 第二种：将id和实体Bean做为K,V 第三种： key存在重复记录时处理 第四种： 使用某个具体的Map类来保存，如保存时使用LinkedHashMap’, '第一种： 取list中某2个字段作为Map的K,V public Map<Long, String> getIdNameMap(List<User> users) { return accounts.stream().collect(Collectors.toMap
list.stream.map的使用
m0_67393593的博客
04-20 800
抽取对象中所有id的集合 List idList = ObjectList.stream.map(Object::getId).collect(Collectors.toList());
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
list.stream().map()用法
ke1ying的博客
03-24 1万+
jdk1.8lamdom表达式用法 List<Long> contentIds = contents.stream().map(Content::getContentId).collect(Collectors.toList()); 或者可以： List<Long> contentIds = contents.stream().map(model->{ return model.getContentid(); }).collect(Colle
list stream:List转Map
技术人集结地
09-07 1005
List中部分字段转Map public static void main(String[] args) { List<TestUser> userList = new ArrayList(); TestUser one = new TestUser(); one.setId(1); one.setName("这是老大"...
【java】java list.stream().map().collect(Collectors.toList())
kanseu的博客
07-27 2680
并赋值给permissions集合在返回list集合.collect(Collectors.toList())转换成list集合。//使用java8api方法list.stream().map().collect(Collectors.toList())filter()filter方法用于通过设置的条件过滤出元素。把一个源数据，可以是集合，数组，I/Ochannel，产生器generator等，转化成流。//获取空字符串的数量。//获取空字符串的数量。//获取对应的平方数。...
Java8中的List.stream().map()用法
qq_36570506的博客
06-21 8142
Java8中的List.stream().map()用法
List使用stream流转成map的几种方式详解
塞北的荒烟的博客
02-04 1万+
参考：https://www.jb51.net/article/281570.htm#_label8。
list.stream().map()用法详解
corleone_4ever的博客
02-13 2万+
https://www.runoob.com/java/java8-streams.html
使用stream将list转成map
热门推荐
李智龙的博客
11-24 14万+
jdk1.8 lambda表达式一行便可以将list转成map import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import org.junit.Test; /** * Created by Jackielee on 2017
stream 流方式
最新发布
04-25
stream流是Java中用于处理输入输出的一种方式。它提供了一种便捷的方式来读取和写入数据，可以用于处理文件、网络连接等各种输入输出操作。 stream流可以分为输入流和输出流两种类型。输入流用于从外部读取数据，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值