Stream流

原创 已于 2022-01-20 19:39:55 修改 · 344 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2021-01-20 21:54:31 首次发布

Stream流

1.Stream流

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

/*
    需求：按照下面的要求完成集合的创建和遍历
        1:创建一个集合，存储多个字符串元素
        2:把集合中所有以"张"开头的元素存储到一个新的集合
        3:把"张"开头的集合中的长度为3的元素存储到一个新的集合
        4:遍历上一步得到的集合
 */
public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<String>();

        for(String s : list) {
            if(s.startsWith("张")) {
                zhangList.add(s);
            }
        }

//        System.out.println(zhangList);

        //把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList = new ArrayList<String>();

        for(String s : zhangList) {
            if(s.length() == 3) {
                threeList.add(s);
            }
        }

//        System.out.println(threeList);

        //遍历上一步得到的集合
        for(String s : threeList) {
            System.out.println(s);
        }
        System.out.println("--------");

        //Stream流来改进
//        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

1.1 Stream流的常见生成方式

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

/*
    Stream流的常见生成方式
        1:Collection体系的集合可以使用默认方法stream​()生成流
            default Stream<E> stream​()
        2:Map体系的集合间接的生成流
        3:数组可以通过Stream接口的静态方法of​(T... values)生成流
 */
public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream​()生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();

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

        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<String, Integer>();
        Stream<String> keyStream = map.keySet().stream();//键集合生成流
        Stream<Integer> valueStream = map.values().stream();//值集合生成流
        //键值对对象生成流
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of​(T... values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

1.2 Stream流中间操作

在这里插入图片描述

1.2.1 filter

/*
    Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤
    Predicate接口中的方法	boolean test​(T t)：对给定的参数进行判断，返回一个布尔值
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：把list集合中以张开头的元素在控制台输出
//        list.stream().filter((String s) -> {
//            return s.startsWith("张");
//        }).forEach(System.out::println);

        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");
        

        //需求2：把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("--------");

        //需求3：把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

在这里插入图片描述

1.2.2 limit&skip

/*
    Stream<T> limit​(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
    Stream<T> skip​(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");

        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");

        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

在这里插入图片描述

1.2.3 concat&distinct

/*
    static <T> Stream<T> concat​(Stream a, Stream b)：合并a和b两个流为一个流
    Stream<T> distinct​()：返回由该流的不同元素（根据Object.equals(Object) ）组成的流
 */
public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        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);
    }
}

在这里插入图片描述

1.2.4 sorted

/*
    Stream<T> sorted​()：返回由此流的元素组成的流，根据自然顺序排序
    Stream<T> sorted​(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序
        Comparator接口中的方法	int compare​(T o1, T o2)
 */
public class StreamDemo04 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");

        //需求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);

        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);
    }
}

在这里插入图片描述

1.2.5 map&mapToInt

/*
    <R> Stream<R> map​(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流
        Function接口中的方法		R apply​(T t)
    IntStream mapToInt​(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果
        IntStream：表示原始 int 流
        ToIntFunction接口中的方法	 int applyAsInt​(T value)
 */
public class StreamDemo05 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需求：将集合中的字符串数据转换为整数之后在控制台输出
//        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("----------");
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("----------");

        //int sum​() 返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

在这里插入图片描述

1.3 Stream流终结操作

1.3.1 forEach&count

在这里插入图片描述

/*
    Stream流的常见终结操作方法
        void forEach​(Consumer action)：对此流的每个元素执行操作
            Consumer接口中的方法	void accept​(T t)：对给定的参数执行此操作
        long count​()：返回此流中的元素数
 */
public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

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


        //需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

在这里插入图片描述

1.4 Stream流综合练习

在这里插入图片描述

/*
    演员类
 */
public class Actor {
    private String name;

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/*
    现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作：
        1:男演员只要名字为3个字的前三人
        2:女演员只要姓林的，并且不要第一个
        3:把过滤后的男演员姓名和女演员姓名合并到一起
        4:把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
            演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
*/
public class StreamTest {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");


        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

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

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

        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);

        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
//        stream.map(Actor::new).forEach(System.out::println);
        stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
        */

        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                womanList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).
                forEach(p -> System.out.println(p.getName()));
    }
}

在这里插入图片描述

1.5 Stream流的收集操作

在这里插入图片描述

/*
    Stream流的收集方法
        R collect​(Collector collector)

    它是通过工具类Collectors提供了具体的收集方式
        public static <T> Collector toList​()：把元素收集到List集合中
        public static <T> Collector toSet​()：把元素收集到Set集合中
        public static Collector toMap​(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
 */
public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");

        /*
        //需求1：得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

        //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for(String name : names) {
            System.out.println(name);
        }
        */

        //创建Set集合对象
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);

        /*
        //需求3：得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age > 25);

        //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for(Integer age : ages) {
            System.out.println(age);
        }
        */


        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};

        //需求5：得到字符串中年龄数据大于28的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        //需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));

        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key + "," + value);
        }

    }
}

在这里插入图片描述

Strem流
weixin_46101397的博客
03-28 1767
1.1概述 说到Strem便容易想到I/O Strem,而实际上，谁规定“流”就一定是流呢？在Java8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.2传统集合遍历的弊端 需求：筛选出姓张且名字长度为3的人的名字并打印 List <String> list = new ArryList<> (); list...
Stream流详解
最新发布
m0_74030445的博客
10-12 721
本文全面解析了Java 8的Stream API核心特性与应用。Stream是函数式处理集合数据的工具，不存储数据且不修改原集合，支持链式调用和延迟执行。核心流程分为三步：创建Stream（集合/数组/静态方法）、中间操作（过滤/映射等延迟操作）、终止操作（触发执行并关闭流）。文章通过实际示例演示了Stream的典型用法，并强调了并行流注意事项。进阶部分深入探讨了Optional与Stream的结合使用、高级收集器（如分组groupingBy）等高级特性，以及性能调优建议。最后总结了Stream如何使代码更
Java--Stream(流)--使用/实例/流操作
IT利刃出鞘的博客
09-17 1万+
Stream（流操作） 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。 也可以使用 Stream API 来并行执行操作。
Stream流方式处理List示例
qq_42570967的博客
12-04 2973
Stream流方式处理List
【Java8】Stream流对List进行输出的一些语句
weixin_43681666的博客
10-16 5598
import java.util.Arrays; import java.util.List; import java.util.Random; import java.util.function.Predicate; import java.util.stream.Collectors; //jdk1.8 之前接口中不能实现方法。 //jdk1.8 之后加入了default关键字，可以在接口中实现方法 interface myFliter{ boolean check(int a); } p.
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
深入解析Jdk8中Stream流的使用让你脱离for循环
08-25
深入解析Jdk8中Stream流的使用让你脱离for循环 本文主要介绍了Jdk8中Stream流的使用，让开发者脱离传统的for循环。Stream流是Jdk8中引入的一种新式编程方式，能够使开发者更方便、更高效地处理数据。 什么是Stream...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
一个示例带你掌握Java Stream中的FlatMap
houdou2092的博客
05-19 3465
一个例子解释Java Stream中的FlatMap 我们可以通过下面的例子来更好的理解flatmap的使用 首先定义两个类型 /** * 学生类 */ @Data @AllArgsConstructor public static class Student{ /** * 姓名 */ private String name; } /** * 班级类 */ @Data @AllArgsConstructor public static class MainCla
Java函数式编程之【流（Stream）的装饰】装饰器【map】和【flatMap】
weixin_42369079的博客
08-03 1218
函数式编程可分为三个步骤：Stream（流）的创建、Stream的中间操作和Stream的终止操作。其中Stream（流）的中间操作可以有n个，而流的终止操作只能有一个。本文详细介绍Stream（流）的中间操作。
java8 获取set值_「Java8新特性」关于Java8的Stream API，看这一篇就够了
weixin_30446393的博客
01-21 650
转载：https://mp.weixin.qq.com/s/d_UumCMUrXtjXKGDhg-1DQ写在前面Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*) ，那什么是Stream API呢？Java8中的Stream又该如何使用呢？什么是Stream?Java8中有两大最为重要的改变。第一个是 Lam...
使用Stream流对集合排序
程序员大腾的博客
11-17 2万+
有一些业务需要对集合按照一些规则进行排序，本篇介绍如何用Stream()对集合进行升序或者降序操作。之前只有接触过使用数据库进行排序，有一些情况需要不同的排序结果，如果进行多次查询会多次操作数据库，所以有些地方使用流对集合操作是更好的选择。Stream 流 -> 调用 sorted 方法 -> 方法内传入对比规则，用容器对象的属性作为入参作为排序依据，默认升序，需要倒叙的话后面调用.reversed() 方法。
Java8 - Streams flatMap()
热门推荐
小工匠
01-02 3万+
生成包含所有对象中所有书籍的流。过滤掉包含单词python的书，并收集一个Set以删除重复的书。可以将 2 levels Stream 转换成 1 level Stream.方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接。，这样就可以轻松地循环 Stream 并对其进行处理。将List转换为对象流，每个对象都包含一组书籍，使用。想 将 2 级 Stream 扁平化为一级，如。处理包含多个级别的 Stream ，比如。来看个简单的功能实现，以及常犯的一些错误。或将 二维数组转换为 一维数组。
Java Stream flatMap解析
weixin_57349625的博客
06-27 6177
运行如下代码 输出 以下代码, 等效于上面的 输出 接口的文档 可以看到demo中方法接受的实例对象以此对应的简写, 为参数, 为返回值对应demo中的代码使用String数组构建stream, 此时流类型为 用处理流内元素, 返回为, 此时流类型为 再用flatMap处理, 就是上一层流的元素类型, 扁平化后流内变为flatMap与map最直观的区别就是 flatMap返回的是, 而map是最终flatMap返回的多个流的内容被添加到一个流中...
List的stream中Long对象与long判等问题记录
努力奋斗
07-01 849
在stream.filter中比较Long!=long的过程中的结果并没有真正过滤掉，具体现象如下
java8 匹配set_Java8新特性 Stream() 数据操作
weixin_42236063的博客
02-27 417
定义了一个实体类，Apple.javapublic class Apple {private Integer id;private String name;private Double money;private Integer num;/**状态： 1： 正常 2： 非正常**/private String status;public String getStatus() {return sta...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值