Stream流

已于 2023-07-02 18:42:11 修改
阅读量43 收藏
点赞数
分类专栏： Java se 文章标签： java windows 开发语言
于 2023-07-02 18:40:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61611746/article/details/131501793
版权
本文介绍了Java中的StreamAPI，展示了如何使用Stream进行数据过滤、转换和收集操作，强调了其在函数式编程中的作用，如filter、map、forEach等方法，并通过实例解释了Stream的中间操作和终结操作，以及如何进行流的生成和合并。
摘要由CSDN通过智能技术生成

1.Stream流体验

import java.util.ArrayList;

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

使用Stream流的方式完成过滤操作
list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3);
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义: 生成流、过滤姓张、过滤长度为3、逐一打印
Stream流把真正的函数式编程风格引入到Java中

2.Stream流的生成方法

方法名说明
list.stream()生成流：通过数据源(集合，数组等)生成流
filter()中间操作：一个流后面可以跟随零个或多个中间操作， 其目的主要是打开流，做出某种程度的数据过滤映射,然后返回一个新的流,交给下一个操作使用
forEach()终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用“光" 了,无法再被操作。所以这必定是流的最后一个操作

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.stream.Stream;

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

        //单列集合
        ArrayList<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //Stream<String> stream=list.stream();
        //stream.forEach(s->System.out.println(s));
        list.stream().forEach(s->System.out.println(s));
       /* aaa
        bbb
        ccc*/
        System.out.println("===========");

        //双列集合
        HashMap<String,Integer> hm=new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);
        //双列集合不能直接获取Stream流，有两种方法
        //KeySet
            //先获取到所有键
            //再把这个set集合中所有的键放到Stream流中
        hm.keySet().stream().forEach(s->System.out.println(s));
        /*lisi
        qianqi
        zhaoliu
        zhangsan
        wangwu*/
        System.out.println("===========");

        //entrySet
            //先获取到生源地键值对对象
            //再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s->System.out.println(s));
        /*lisi=24
        qianqi=27
        zhaoliu=26
        zhangsan=23
        wangwu=25*/
        System.out.println("===========");

        //数组
        int[] arr={1,2,3,4,5};
        Arrays.stream(arr).forEach(s->System.out.println(s));
        System.out.println("===========");

        //同种数据类型的多个数据
        Stream.of(1,2,3,4,5,6,7,8).forEach(s->System.out.println(s));

    }

}

3.Stream流的中间操作方法

中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。

方法名说明
Stream filter(Predicate predicate)用于对流中的数据进行过滤
Stream limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)合并a和b两个流为一个流
Stream distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream sorted()返回由此流的元素组成的流，根据自然顺序排序
Stream sorted(Comparator comparator)返回由该流的元素组成的流，根据提供的Comparator进行排序
Stream map(Function mapper)返回由给定函数应用于此流的元素的结果组成的流
IntStream mapToInt(ToIntFunction mapper)返回一个IntStream其中包含将给定函数应用于此流的元素的结

 filter


import java.util.ArrayList;

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("张飞");

        //需要1：把list集合中以张开头的在控制台输出
        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：把以张开头，长度为3的在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
//        张无忌
//        张三峰
    }
}

limit 和 skip


import java.util.ArrayList;

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("张飞");

        //需要1：取前三个数据在控制台输出
        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个元素，把剩下元素的前两个输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
//        大熊猫
//        张三峰
    }
}

 concat 和 distinct


import java.util.ArrayList;
import java.util.stream.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("张飞");

        //需要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()和sorted(Comparator comparator)


import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("b123");
        list.add("a1");
        list.add("f1234");
        list.add("c12");
        list.add("e12345");
        list.add("d12345");

        //需要1：按照字母顺序在控制台输出
        list.stream().sorted().forEach(System.out::println);
//        a1
//        b123
//        c12
//        d12345
//        e12345
//        f1234

        //需求2：按照字符串长度，长度相同自然排序
        list.stream().sorted((s1, s2) -> {
            int num1 = s1.length() - s2.length();
            int num2 = num1 == 0 ? s1.compareTo(s2) : num1;
            return num2;
        }).forEach(System.out::println);
//        a1
//        c12
//        b123
//        f1234
//        d12345
//        e12345
    }
}

map 和 mapToInt


import java.util.ArrayList;

public class Demo {
    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");

        //需要:将集合中的字符串转换为整数后在控制台输出
//        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        //方法引用
//        list.stream().map(Integer::parseInt).forEach(System.out::println);
//        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//        10
//        20
//        30
//        40
//        50

        //InStream中方法 :int sum()返回流中元素总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result); //150
    }
}

4.Stream流的终结操作方法 

 终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。

方法名说明
void forEach(Consumer action)对此流的每个元素执行操作,Consumer接口中的方法——void accept(T t)对给定的参数执行此操作
long count()返回此流中的元素数

import java.util.ArrayList;

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("张飞");

        //需求1：输出集合中的元素
        list.stream().forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张三峰
//        小白
//        张飞

        //需求2：统计以张开头的个数
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count); //3
    }
}

5.Stream流的收集操作

附加：在Stream流中无法直接修改集合，数组等数据源中的数据，修改的是流上的数据

Stream流的收集方法

方法名说明
R collect(Collector collector)但是这个收集方法的参数是一个Collector 接口

工具类Collectors提供了具体的收集方式

方法名说明
public static Collector toList()把元素收集到List集合中
public static Collector toSet()把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo {
    public static void main(String[] args) {
        //创建list集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("大熊猫");
        list.add("张飞");
        list.add("小熊猫");

        //需求1：得到名字为三个字的流
        Stream<String> listStream = list.stream().filter(name -> name.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<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);

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

        //定义个字符串数组，由姓名和年龄组成
        String[] strArray = {"小黑,10", "小白,20", "小熊猫,30", "大熊猫,40"};

        //需求5：得到字符串数组中年龄大于25的流
        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 vlaue = map.get(key);
            System.out.println(key + "," + vlaue);
//            大熊猫,40
//            小熊猫,30
        }
    }
}

练习：

 演员类：

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

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + '\'' +
                '}';
    }
}

 测试类：

import java.util.ArrayList;
import java.util.stream.Stream;

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> stream1 = manList.stream().filter(s -> s.length() == 3).limit(2);

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

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

        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
//        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(2),
                        womanList.stream().filter(s -> s.startsWith("杨")).skip(1)).map(Actor::new).
                forEach(p -> System.out.println(p.getName()));

    }
}

 

天演L
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 8万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java Stream流详解
唯有努力，方可自信！
06-10 3万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
stream流详解
weixin_45785893的博客
11-17 2万+
Stream流 一 ：Stream流的介绍 stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果； stream不会改变数据源，通常情况下会产生一个新的集合； stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。 对stream操作分为终端操作和中间操作，那么这两者分别代表什么呢？ 终端操作：会消费流，这种操作会产生一个结果的，如果一个流被消费过了，那它就不能被重用的。 中间操作：中间操作会产生另一个流。因此中间操作可以用来创建执行一系列动作的管道。一个特别需要注意的点
Stream流详解
ss810540895的博客
08-05 3万+
stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。............
Stream流的常用方法
DQ6667的博客
04-11 4万+
1、快速创建List List list = Stream.of("1", "2").collect(Collectors.toList()); 2、取对象的某一列 低效方式： List<String> userNameList = new ArrayList<>(); for (String) List<String> userNameList = list.stream().map(User::getName).collect(Collectors.toList(
Java8新特性Stream流详解
陈老老老板的博客
10-25 2万+
既然我们已经知道了这些强大的内置收集器，接下来就让我们尝试构建自定义收集器吧。比如说，我们希望将流中的所有人转换成一个字符串，包含所有大写的名称，并以|分割。为了达到这种效果，我们需要通过Collector.of()创建一个新的收集器。同时，我们还需要传入收集器的四个组成部分：供应器、累加器、组合器和终止器。
Java - Stream流详解
weixin_73869209的博客
06-05 1万+
Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。Stream流的处理是惰性求值的，只有在执行终止操作时才会开始处理数据。
Stream流和Optional
qq_45888932的博客
02-19 2433
Stream流
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1191
浅析synchronized锁升级的原理与实现
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 675
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 565
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8680
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 400
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 841
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
stream 流方式
04-25
stream流是Java中用于处理输入输出的一种方式。它提供了一种便捷的方式来读取和写入数据，可以用于处理文件、网络连接等各种输入输出操作。 stream流可以分为输入流和输出流两种类型。输入流用于从外部读取数据，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值