Stream流中的常用方法（forEach，filter，map，count，limit，skip，concat）和Stream流的特点

小丁学Java

已于 2023-10-18 19:25:46 修改

阅读量540

点赞数 4

分类专栏： # Stream 文章标签： forEach filter map count limit skip concat

于 2023-10-14 22:17:01 首次发布

本文链接：https://blog.csdn.net/m0_65152767/article/details/133829358

版权

Stream 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1、forEach方法

该方法接收一个Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据
用来遍历流中的数据，是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法

package com.csdn.stream;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class Demo02Stream_forEach {

    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("小明", "小兰", "小强");

//        stream.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });

//        stream.forEach(name -> System.out.println(name));
 
        stream.forEach(System.out::println);//小明 小兰 小强
    }
}

2、 filter方法

用于对Stream流中的数据进行过滤，方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤

package com.csdn.stream;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class Demo03Stream_filter {

    public static void main(String[] args) {

        Stream<String> stream = Stream.of("张三丰", "张翠山", "张无忌", "赵敏", "周芷若");

//        stream.filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张");
//            }
//        }).forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });

//        Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));
//        stream2.forEach(System.out::println);

//        stream.filter(name->name.startsWith("张")).forEach(name-> System.out.println(name));

        stream.filter(name -> name.startsWith("张")).forEach(System.out::println);
//                                                                    张三丰 
//                                                                    张翠山
//                                                                    张无忌

    }
}

3、Stream流的特点

只能使用一次，Stream流属于管道流，只能被消费（使用）一次，第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这时第一个Stream流已经使用完毕，就会关闭了，所以第一个Stream流就不能再调用方法了

package com.csdn.stream;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class Demo03Stream_filter {

    public static void main(String[] args) {

        Stream<String> stream = Stream.of("张三丰", "张翠山", "张无忌", "赵敏", "周芷若");

        Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));

        stream2.forEach(System.out::println);//张三丰 张翠山 张无忌

        //遍历Stream流
        stream.forEach(System.out::println);//IllegalStateException
    }
}
D:\Java\jdk-17\bin\java.exe
张三丰
张翠山
张无忌
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
	at java.base/java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:762)
	at com.csdn.stream.Demo03Stream_filter.main(Demo03Stream_filter.java:16)

4、map方法

如果需要将流中的元素映射到另一个流中，可以使用map方法，该接口需要一个Function函数式接口，可以将当前流中的 T 类型数据转换为另一种 R 类型的流

package com.csdn.stream;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;
public class Demo04Stream_map {

    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stringStream = Stream.of("1", "2", "3", "4", "5");

//        Stream<Integer> integerStream = stringStream.map(new Function<String, Integer>() {
//            @Override
//            public Integer apply(String s) {
//                return Integer.parseInt(s);
//            }
//        });
//        integerStream.forEach(new Consumer<Integer>() {
//            @Override
//            public void accept(Integer integer) {
//                System.out.println(integer);
//            }
//        });

        //使用map方法，把字符串类型的整数，转换（映射）为Integer类型的整数
        Stream<Integer> integerStream = stringStream.map(Integer::parseInt);
        //遍历integerStream流
        integerStream.forEach(System.out::println);//1 2 3 4 5 

    }
}

5、count方法

用于统计Stream流中元素的个数，是一个终结方法，返回值是一个long类型的整数，所以不能再继续调用Stream流中的其他方法了

package com.csdn.stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
public class Demo05Stream_count {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        Collections.addAll(list, "1", "2", "3", "4", "5");

        Stream<String> stream = list.stream();
        System.out.println(stream.count());//5
    }
}

6、limit方法

用于截取流中的元素，limit方法可以对流进行截取，只取用前 n 个，参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
package com.csdn.stream;
import java.util.stream.Stream;
public class Demo06Stream_limit {
    public static void main(String[] args) {
        String[] arr = {"喜羊羊", "美羊羊", "懒洋洋", "灰太狼", "红太狼"};
        //获取一个Stream流
        Stream<String> arr1 = Stream.of(arr);
        //使用limit对Stream流中的元素进行截取，只要前3个元素
        Stream<String> limit = arr1.limit(3);
        //遍历limit流
        limit.forEach(System.out::println);//喜羊羊   美羊羊   懒洋洋
    }
}

7、skip方法

skip用于跳过元素，如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流，如果流的当前长度大于 n ，则跳过前 n 个；否则将会得到一个长度为 0 的空流
package com.csdn.stream;
import java.util.stream.Stream;
public class Demo07Stream_skip {
    public static void main(String[] args) {
        String[] arr = new String[]{"喜羊羊", "美羊羊", "懒洋洋", "灰太狼", "红太狼"};
        //获取一个Stream流
        Stream<String> arr1 = Stream.of(arr);
        //使用skip方法跳过前3个元素
        Stream<String> skip = arr1.skip(3);
        //遍历skip流
        skip.forEach(System.out::println);//灰太狼  红太狼

    }
}

8、concat方法（concatenate）

用于把流组合到一起，如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

package com.csdn.stream;
import java.util.stream.Stream;
public class Demo08Stream_concat {

    public static void main(String[] args) {

        String[] arr = {"喜羊羊", "美羊羊", "懒洋洋", "灰太狼", "红太狼"};
        //创建一个Stream流
        Stream<String> arr1 = Stream.of(arr);
        //获取一个Stream流
        Stream<String> arr2 = Stream.of("张三丰", "张翠山", "张无忌", "赵敏", "周芷若");
        //把以上两个流组合为一个流
        Stream<String> concatenate = Stream.concat(arr1, arr2);
        //遍历concatenate流
        concatenate.forEach(System.out::println);// 喜羊羊 美羊羊 懒洋洋 灰太狼 红太狼 张三丰 张翠山 张无忌 赵敏 周芷若
    }
}

Stream流的练习

现在有两个ArrayList集合，分别存储倚天屠龙记人物名称和喜羊羊与灰太狼人物名称，要求完成如下的操作

倚天屠龙记人物只要名字为3个字的前3人
喜羊羊与灰太狼人物只要姓懒的，并且不要第 1 个
把过滤后的倚天屠龙记人物和喜羊羊与灰太狼人物合并到一起
把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据

package com.csdn.Stream2;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

public class StreamPractice {

    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三丰", "张翠山", "张无忌", "赵敏","周芷若");

        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "喜羊羊", "美羊羊", "懒洋洋", "灰太狼","红太狼");
/*

        //倚天屠龙记人物 只要名字为3个字的前3人
        Stream<String> limit = list.stream().filter(s -> s.length() == 3).limit(3);

        //喜羊羊与灰太狼人物只要姓懒的，并且不要 第 1 个
        Stream<String> skip = list2.stream().filter(s->s.startsWith("懒")).skip(1);

        //把过滤后的倚天屠龙记人物 和 喜羊羊与灰太狼人物 合并到一起
        Stream<String> concatenate = Stream.concat(limit, skip);

        //把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
//        concatenate.map(new Function<String, Actor>() {
//            @Override
//            public Actor apply(String s) {
//                return new Actor(s);
//            }
//        }).forEach(System.out::println);

        concatenate.map(Actor::new).forEach(System.out::println);

*/
        Stream.concat(list.stream().filter(s -> s.length() == 3).limit(3),
                        list2.stream().filter(s -> s.startsWith("懒")).skip(1)).
                map(Actor::new).forEach(System.out::println);
//                                                            Actor(name=张三丰)
//                                                            Actor(name=张翠山)
//                                                            Actor(name=张无忌)

    }
}
@Data
@NoArgsConstructor
@AllArgsConstructor
class Actor {
    private String name;
}

小丁学Java

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Stream流中的常用方法（forEach，filter，map，count，limit，skip，concat）和Stream流的特点

Stream流中的常用方法（forEach，filter，map，count，limit，skip，concat）和Stream流的特点
复制链接

扫一扫