3.Stream流的中间方法

已于 2025-03-10 13:28:00 修改
阅读量1k 收藏 15
点赞数 15
CC 4.0 BY-SA版权
分类专栏： Stream流 - Java版 文章标签： java 开发语言
于 2024-11-28 19:45:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ADCvbV/article/details/144119100

一.Stream流的中间方法：

1.distinct方法底层依赖hashCode方法和equals方法去重，使用时对于自定义数据类型根据需求重写hashCode方法和equals方法(注：基本数据类型和字符串类型不需要重写hashCode方法和equals方法就可以实现去重)。distinct方法底层利用HashSet集合进行去重，所以除了字符串类型外的自定义类型要根据需求重写hashCode方法和equals方法；

2.concat方法用于合并两个流，这两个流的数据类型尽可能的保持一致，如果数据类型不一致，那么最终的数据类型就是这两个流共同的父类类型，相当于进行了类型提升，导致无法使用子类里特有的功能；

3.map方法里的参数mapper是接口类型Function<T, R>，而且该接口是函数式接口，因此可用lambda表达式：

解析接口类型Function<T, R>：T表示流里原本的类型，R表示之后要转成的类型，方法apply的形参s依次表示流里面的每一个数据，方法apply的返回值表示转换之后的数据(注：T和R是泛型，不能是基本数据类型，如果写基本数据类型的话要用包装类，如int要用Integer)

4.concat方法是静态方法，因此可以类名.方法名进行调用：

5.filter方法里的形参predicate的数据类型是函数式接口,因此可以先写匿名内部类，再用lambda表达式进行优化:

6.stream流中间方法的特点是调用完stream流的中间方法后还可以继续使用stream流里的其他方法。

二.代码演示：

1.filter方法(过滤)：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
​
        //1.filter:过滤->把"张"开头的留下，其余数据过滤不要
        list.stream().filter(new Predicate<String>() {  //list.stream()意思是获取Stream流,并把数据放到Stream流当中
            @Override
            public boolean test(String s) {  //形参s代表流中的每一个数据
                boolean flag=s.startsWith("张"); //startsWith返回布尔类型，是"张"开头返回true，不是返回false
                return flag; //返回false，表示当前数据舍弃;返回true，表示当前数据保留
            }
        }).forEach(s-> System.out.println(s)); //打印结果
        /*注：打印结果里的s是forEach里的s，不是test方法里的s*/
    }
}
上述例子中filter方法的方法体只是用来指定过滤掉哪些数据，对于集合中的数据类型不会改变，打印集合依旧是打印集合中剩余的数据。
注：Predicate是函数式接口，上例中由于是在流里new的Predicate接口，所以Predicate接口的泛型和流里的数据的类型要保持一致，此时list集合获取的stream流，所以流里的数据的类型就是list集合的类型即String型，所以Predicate接口的泛型是String型

new Predicate<String>()用到了匿名内部类，可用lambda表达式优化：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
​
        //1.filter:过滤->把"张"开头的留下，其余数据过滤不要
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        /*s依次表示流水线上的数据，s.startsWith("张")表示开始过滤不需要的数据，以"张"开头的留下 */
    }
}
​

代码折行(折行处回车即可折行)，可提高链式编程代码的可读性：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
​
        //1.filter:过滤->把"张"开头的留下，其余数据过滤不要
        list.stream().
                filter(s -> s.startsWith("张")).
                forEach(s -> System.out.println(s));
        /*s依次表示流水线上的数据，s.startsWith("张")表示开始过滤不需要的数据，以"张"开头的留下 */
    }
}

注：String类里的startsWith方法和endsWith方法
​

2.中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程：

例如：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
        
        Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));/*留下以"张"开头*/
        Stream<String> stream2 = stream1.filter(s -> s.length() == 3);/*留下长度为3,stream1调用了方法即使用了stream1。stream流只能用一次，因此stream1之后不能再用了*/
        stream2.forEach(s -> System.out.println(s));/*遍历,stream2调用了方法即使用了stream2。stream流只能用一次，因此stream2之后不能再用了*/
        /*注：之后stream1和stream2这两个流就不能再用了,这样使得代码占用内存较大,因此可使用链式编程节省内存 */
    }
}
​

3.修改Stream流中的数据，不会影响原来集合或者数组中的数据：

例如：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
​
        //1.filter:过滤->把"张"开头的留下，其余数据过滤不要
        list.stream().
                filter(s -> s.startsWith("张")).
                forEach(s -> System.out.println(s));
        /*s依次表示流水线上的数据，s.startsWith("张")表示开始过滤不需要的数据，以"张"开头的留下 */
​
        System.out.println("========================================");
        System.out.println(list);
        /*运行结果为[张无忌, 周芷若, 赵敏, 张强, 张三丰, 张翠山, 张良, 王二麻子, 谢广坤]
          集合中的数据没发生改变*/
    }
}
​

4.limit方法(获取前几个元素)：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
        
       //2.limit:获取前几个元素
       list.stream().
               limit(3). //3代表获取前3个元素，不是索引
               forEach(s -> System.out.println(s)); //遍历
    }
}
​

5.skip方法(跳过前几个元素)：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
​
       //3.skip:跳过前几个元素
       list.stream().
               skip(4). //4代表跳过前4个元素
               forEach(s -> System.out.println(s)); //遍历
    }
}
​

6.练习：

package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //注：修改Stream流中的数据，不会影响原来集合或者数组中的数据
        
       //练习：获取 "张强","张三丰","张翠山" 这3个元素
       /*方法一:先获取前6个元素，再跳过前3个元素*/
       list.stream().limit(6).skip(3).forEach(s -> System.out.println(s));
       /*方法二:先跳过前3个元素，再获取前3个元素*/
       list.stream().skip(3).limit(3).forEach(s -> System.out.println(s));
    }
}
​

7.distinct方法(元素去重，依赖hashCode和equals方法)：

package com.itheima.a01mystream;

import java.util.ArrayList;
import java.util.Collections;

public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list1=new ArrayList<>();
        Collections.addAll(list1,"张无忌","张无忌","张无忌","张强","张三丰","张翠山","张良","王二麻子","谢广坤");

        list1.stream().distinct().forEach(s -> System.out.println(s));
        /*运行结果为 张无忌
                    张强
                    张三丰
                    张翠山
                    张良
                    王二麻子
                    谢广坤 */
    }
}

8.concat方法(合并a和b两个流为一个流)：

package com.itheima.a01mystream;

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

public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list1=new ArrayList<>();
        Collections.addAll(list1,"张无忌","张无忌","张无忌","张强","张三丰","张翠山","张良","王二麻子","谢广坤");

        ArrayList<String> list2=new ArrayList<>();
        Collections.addAll(list2,"周芷若","赵敏");

        Stream.concat(list1.stream(),list2.stream()). //合并list1流和list2流
                forEach(s -> System.out.println(s));//遍历
        /*list1.stream()调用了stream()才成为了流 */

    }
}

9.map方法(转换流中的数据类型)：

普通：
package com.itheima.a01mystream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class StreamDemo8 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20",
                "张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");

        //要求:只获取里面的年龄并进行打印
        //获取stream流
        Stream<String> stream = list.stream();
        //遍历
        stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) { //s代表集合的每一个元素
                String[] result = s.split("-");
                System.out.println(result[1]);
            }
        });
    }
}

注：Consumer接口是一个函数式接口

用lambda表达式优化：

package com.itheima.a01mystream;

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

public class StreamDemo8 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20",
                "张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");

        //需求:只获取里面的年龄并进行打印
        //获取stream流
        Stream<String> stream = list.stream();
        //遍历
        stream.forEach(s -> { //s代表集合的每一个元素
                String[] result = s.split("-");
                System.out.println(result[1]);
            }
        );
    }
}

注：String类里的split方法，用于切割字符串

split方法举例：

public class Main {
    public static void main(String[] args) {
        String s="1-2-3";
        String[] arr = s.split("-"); //代表要用-切割字符串s，结果为数组，但结果不包括-
        for (String result : arr) {
            System.out.printf("%s，",result);
        }
        //运行结果为1，2，3，

    }
}
高级：
package com.itheima.a01mystream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class StreamDemo8 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20",
                "张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");

        //需求:只获取里面的年龄并进行打印
         /*相当于字符串里提取数字:String -> int*/
        /*第一个类型:流中原本的类型
          第二个类型:之后要转成的类型*/
        //apply的形参s:依次表示流里面的每一个数据
        //返回值:表示转换之后的数据
        list.stream().map(new Function<String, Integer>() { //要用泛型
            @Override
            public Integer apply(String s) { //这个s表示集合里的每一个数据如张无忌-15
                //1.切割:比如张无忌-15切割为张无忌和15,此时结果为数组,0索引上为张无忌,1索引上为15
                String[] arr = s.split("-");
                //2.获取年龄:但是为字符串
                String ageString = arr[1];
                //3.转换为int型,可利用int型的包装类Integer里的parseInt方法
                int age = Integer.parseInt(ageString);
                return age; //返回整型，所以apply方法的返回类型用整型Integer
            }
        }).forEach(s -> System.out.println(s));
        /*当map方法执行完毕之后，流上的数据就变成了整数，
        所以在调用forEach方法中，s依次表示流里面的每一个数据，这个数据现在就是整数了*/
    }
}

用lambda表达式优化：

package com.itheima.a01mystream;

import java.util.ArrayList;
import java.util.Collections;

public class StreamDemo8 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20",
                "张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");

        //需求:只获取里面的年龄并进行打印
         /*相当于字符串里提取数字:String -> int*/
        /*第一个类型:流中原本的类型
          第二个类型:之后要转成的类型*/
        list.stream().
                map(s -> Integer.parseInt( s.split("-")[1] )). //这个s表示集合里的每一个数据如张无忌-15
                forEach(s -> System.out.println(s)); //这个s就是最终要的年龄
        //s.split("-")结果为字符串数组，s.split("-")[1]表示获取字符串数组1索引上的元素
        //s.split("-")[1]是字符串型,Integer.parseInt( s.split("-")[1]为整型
    }
}

注：Integer类里的parseInt方法可以把字符串转化为整数，parseInt方法是静态方法，可以类名.方法名进行调用，也可以使用类名::静态方法名（方法引用）进行调用

Stream流的获取及中间方法,终结方法的使用
weixin_47766774的博客
01-07 668
我们需要先得到一条Stream流,把数据放上去,然后利用Stream流中的API进行各种操作.1.中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程.获取Stream流后对数据进行处理,在这里,我们可以用中间方法和终结方法.2.修改Stream流中的数据，不会影响原来集合或者数组中的数据。contact方法使用(尽可能让要合并的数据保持一致)接下来是Stream流终结方法的使用.forEach及count方法的使用.toArray方法的使用。collect方法的使用。
Java——Stream流（2/2）：Stream流的中间方法、终结方法（方法、案例演示）
li13437542099的博客
06-06 939
Stream流的中间方法指的是调用完成后会返回新的Stream流，可以继续使用(支持链式编程)。 Stream流的终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。
Stream流中间操作方法
Leon_Jinhai_Sun的博客
09-12 2144
概念 中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。 常见方法 方法名 说明 Stream<T> filter(Predicate predicate) 用于对流中的数据进行过滤 Stream<T> limit(long maxSize) 返回此流中的元素组成的流，截取前指定参数个数的数据 Stream<T> skip(long n) 跳过指定参数个数的数据，返回由该流的..
分析 Java Stream 的 distinct 去重原理：从实现机制到性能优化
潜意识Java的博客
06-21 997
理解distinct()的底层实现原理，不仅能避免自定义对象去重时的常见错误，更能在处理大规模数据时选择合适的优化策略。记住：去重操作的本质是空间与时间的权衡，根据具体业务场景（数据规模、有序性、精确性要求）选择最优方案，才能实现性能与功能的平衡。
【Java】`Stream流`的中间方法
qq_39921135的博客
07-06 915
概念：中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作。
Stream的中间操作
tainxiawuti的博客
08-26 584
1）筛选与切片 public class EmployeeData { public static List<Employee> getEmployees(){ List<Employee> list = new ArrayList<>(); list.add(new Employee(1001, "马化腾", 34, 6000.38)); ...
Stream流的中间方法
zhaojinyu511的博客
11-16 110
Collections.addAll(list,"张三","张无忌","张三","张三","张敏","张翠山","张三丰","李四","王五","赵敏");Collections.addAll(list3,"黑马-14","程序员-15");Collections.addAll(list2,"黑马","程序员");//limit 获取前几个元素。//map 转换流中的数据类型。//skip 跳过前几个元素。//distinct 去重。//filter: 过滤。//concat 合并。
java.Stream流处理(处理方案示例).md
11-15
Java Stream流处理是一种强大的数据处理API，它提供了高效处理集合数据的方式。在Java 8中引入，Stream允许开发者以声明性的方式处理数据集合，支持顺序和并行聚合操作。使用Stream API可以简化代码，增强其可读性...
java.Stream流处理(解决方案).md
12-05
3. 流的操作通常分为中间操作和终端操作。 4. 中间操作返回一个新的流对象，例如filter和map操作。 5. 终端操作返回非流结果，例如collect、forEach和reduce操作。 6. 流可以是无限的，并且可以延迟计算。 在实际...
java.Stream流处理.md
11-29
使用Stream API进行数据处理时，我们首先需要将数据源转换成Stream，然后连续应用多个操作（中间操作如filter、map、sorted等），最后收集结果到新的数据结构。这种方式符合函数式编程范式，易于并行处理，并且能够...
Stream流常见中间操作方法
weixin_52848782的博客
10-26 704
Stream流常见中间操作方法
Stream流的常见中间操作方法
qq_52629349的博客
04-11 591
Stream流的常见中间操作方法
Stream流学习笔记2：Stream流的常用中间方法
m0_54851012的博客
12-06 867
distinct的底层是利用HashSet进行去重的，而HashSet需要利用到hashCode和equals方法，所以在对自定义类进行去重的时候需要重写这两个方法。，其中第一个类型为流中原本的数据类型，第二个类型转换之后的类型。方法，该方法的形参依次表示流上的每一个数据，返回值是转换之后的数据，当map方法执行完毕之后，流上的数据就变成了。当执行完结束操作后，上面的stream就会自动关闭，如果后面的操作继续使用stream这条流，就会抛出。中间操作不会修改原来的数据，原来的list中的内容是不变的。
Java 8 Stream中间操作（方法）示例
最佳 Java 编程
06-16 1994
Java 8 Streams中间操作的完整指南。 所有内置Stream API中间操作（方法）的列表以及示例。 1.概述 在本教程中，我们将学习什么是 Java 8 Stream 中的中间操作 。 所有这些操作都在java.util.stream.Stream包中 。 在上一教程中，我们讨论了Java 8 Stream API和Lambda Expressions 。 规则： J...
Stream流常见的中间操作方法 Stream流中常见的终结操作方法 反射 类加载器 类加载 反射概述
weixin_54425421的博客
09-23 592
文章目录Stream流常见的中间操作方法Stream流中常见的终结操作方法反射类加载器类加载反射概述 Stream流常见的中间操作方法 Streamfilter(Predicate predicate):用于对流中的数据进行过滤 predicate接口中的方法 boolean test（T t）：对给定的参数进行判断，返回一个布尔值 Stream limit（long maxSize):返回此流中元素组成的流，截取前指定参数个数的数据 Stream skip（long n) :跳过指定参数个数据，返
Stream流的中间操作
wwennxx的博客
05-14 388
package com.llw; import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.stream.Stream; public class TestStream2 { List<User> users = Arrays.asList(new User
3、java stream流的中间方法
weixin_60948956的博客
01-03 181
【代码】3、java stream流的中间方法。
8.Stream 流
最新发布
07-16
1. Stream流中的中间操作和终结操作有什么区别？ 2. 如何创建并行Stream流？使用时需要注意什么？ 3. Stream流在处理大数据集时有哪些优势？ 4. 为什么说Stream流是惰性求值的？请举例说明。 5. 如何避免Stream流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值