首页 > 其他分享 >Stream流

Stream流

时间：2023-02-10 19:11:39浏览次数：36  
标签：Stream list System add println out

体验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

标签：Stream,list,System,add,println,out
From： https://www.cnblogs.com/chawaner/p/17110081.html

相关文章

  • JAVA8之Stream（其一：分页）
    分页，是项目开发中的常驻者，想必大家都使用过PageHelper进行分页，或者利用mysql语句的limit进行分页。利用PageHelper去分页，无非就是在你的sql语句外层嵌套一个limit，一旦遇到......
  • upstream和proxy模块
    nginx负载均衡-upstream和proxy模块（1）Cloud研习社 Cloud研习社 2023-01-1007:31 发表于北京收录于合集#一站式教程195个#云计算148个#计算机137个#nginx37......
  • Java FileInputStream/FileOutputStream的应用 文件读取和写入//京鸿通信科技//www.ky
    这是一对继承于InputStream和OutputStream的类，用于本地文件读写（二进制格式读写并且是顺序读写，读和写要分别创建出不同的文件流对象）；本地文件读写编程的基本过程为：① 生......
  • JDK8 新语法介绍(Lambda、Stream、Optional)
    (目录)lambda表达式代码中的遇到的函数式接口（有且仅有一个抽象方法），可以用lambda来代替，比如MQ发消息，我们传统的做法：jmsTemplate.send(newMessageCreator(){......
  • npmFix the upstream dependency conflict, or retry npm ERR! this command with --f
      因为node7在某些事件处理上比node6更加严格，解读上面的报错信息，找到解决方案npminstall--legacy-peer-deps即可成功安装node_modules ......
  • java8排序stream().sorted()
    默认升序 先以年龄升序排序年龄相同是按分数降序List<Student>list=userList.stream().sorted(Comparator.comparing(Student::getAge).thenComparing(Student::g......
  • java-Stream流的常用方法
    一 常见创建流的三种方式//list集合创建流方式newArrayList<>().stream();newHashSet<>().stream();//map集合创建流方式,原......
  • JDK8 Stream的使用
    借助Lambda表达式，可以简化集合类的操作。一、List 二、Set三、Map四、Array ......
  • RocketMQ Streams拓扑构建与数据处理过程
    本文作者：倪泽，ApacheRocketMQcommitter、RSQLDB/RocketMQStreamsMaintainer01背景RocketMQStreams1.1.0版本已于近期发布，相对之前版本有以下改进和优化：1、API层面支持......
  • GStreamer基础教程13 - 调试Pipeline
    摘要在很多情况下，我们需要对GStreamer创建的Pipeline进行调试，来了解其运行机制以解决所遇到的问题。为此，GStreamer提供了相应的调试机制，方便我们快速定位问题。 查......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99