Java8新特性 Stream流 API

已于 2023-04-14 19:15:14 修改
阅读量84 收藏
点赞数
分类专栏： Java基础 文章标签： java
于 2023-04-14 18:02:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xcxcxcxx1/article/details/130159411
版权

Stream流

体验stream

img

  • 不使用stream流
public static void main(String[] args) throws ExecutionException, InterruptedException {
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    List<String> collect = new ArrayList();
    for(String s : list){
        if(s.startsWith("张")){
            collect.add(s);
        }
    }
    List<String> collect1 = new ArrayList();
    for(String s : collect){
    	if(s.length() == 3){
            collect1.add(s);
        }
    }
    for(String s : collect1) {
        System.out.println(s);
    }
}
  • 使用stream流
public static void main(String[] args) throws ExecutionException, InterruptedException {
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    // 一行代码解决
    list.stream().filter(name -> name.startsWith("张"))
        .filter(name->name.length() == 3)
        .forEach(System.out::println);
}

Stream流的作用

结合了Lambda表达式，简化集合、数组的操作

Stream流的使用步骤

  • 先得到一条Stream流(流水线)，并把数据放上去

  • 利用Stream流中的API进行各种操作

    • 中间方法（方法调完还可以调用其它方法）：过滤、转换
    • 终结方法（方法调完不可以调用其它方法）：统计、打印
怎么得到一条Stream流
获取方法方法名说明
单列集合default Stream stream()Collection中的默认方法
双列集合无无法直接使用stream流
数组public static Stream stream(T[] array)Arrays工具类中的静态方法
一堆零散数据public static Stream of(T …values )Stream接口中的静态方法

单列集合

public static void main(String[] args){
    List<String> list = new ArrayList<>();
    Collections.addAll(list,"a","b","c","d","e");
    // 获取到一条流水线，并将集合中的数据放到流水线上
    Stream<String> stream = list.stream();
    // 使用终结方法打印流水上的所有数据
    stream.forEach(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });

    // 使用链式编程(需要注释上面代码，stream只能用一次)
    stream.forEach(System.out::println);
}

双列集合

public static void main(String[] args){
    Map<String,Integer> map = new HashMap<>();
    map.put("aaa",111);
    map.put("bbb",222);
    map.put("ccc",333);
    map.put("ddd",444);
    // 先转成单列集合再使用stream流
//  map.keySet().stream().forEach(System.out::println);
    map.entrySet().stream().forEach(System.out::println);
}

数组

    public static void main(String[] args){
        String[] arr = {"aaa","bbb","ccc","ddd"};
        // 使用Arrays工具类中的stream方法
        Arrays.stream(arr).forEach(System.out::println);
    }

零散数据

    public static void main(String[] args){
        Stream.of("a","b","c").forEach(System.out::println);
    }
Stream流的中间方法
名称说明
Stream filter(Predicate<? super T predicate>)过滤
Stream limit(long maxSize)获取前几个
Stream skip(long n)跳过前几个元素
Stream distinct()元素去重，依赖hashCode和equals方法
static Stream concat(Stream a,Stream b)合并a和b两个流为一个流
Stream map(Function<T,R> mapper)转换流中的数据类型

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

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

filter

public static void main(String[] args){
    List<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
    // 过滤，把张开头的留下，其余数据不要
    list.stream().filter(name->name.startsWith("张"))
        .filter(name->name.length()==3)
        .forEach(System.out::println);
}

limit

    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        // 获取前3个元素
        list.stream().limit(3).forEach(System.out::println);
    }

skip

    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        // 跳过前4个元素
        list.stream().skip(4).forEach(System.out::println);
    }

distinct

    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","张无忌","张无忌","张无忌","张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        // 获取前几个元素
        list.stream().distinct().forEach(System.out::println);
    }

底层使用hashSet去重，所以要重写hashCode和equals方法

concat

    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","张无忌","张无忌","张无忌","张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        List<Integer> list2 = new ArrayList<>();
        Collections.addAll(list2,1,2);
        Stream.concat(list.stream(),list2.stream()).forEach(System.out::println);
    }

map

/**
 * @author xc
 */
public class solution {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-20","赵敏-11","张强-14","张三丰-13","张翠山-91","张良-41","王二麻子-44","谢广坤-22");
        list.stream().map(p -> {
            String[] split = p.split("-");
            return new P(split[0], Integer.parseInt(split[1]));
        }).collect(Collectors.toList()).forEach(System.out::println);
    }

}
class P{
    private String name;
    private int age;
    public P(){}

    public P(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "P{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
Stream流的终结方法
名称说明
void forEach(Consumer action)遍历
long count()统计
toArray()收集流中的数据，放到数组中
collect(Collector collector)收集流中的数据，放到集合中

forEach

    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        list.stream().forEach(name->System.out.println(name+"ss") );
    }

toArray

    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        String[] strings = list.stream().toArray(String[]::new);
        for (String s : strings) {
            System.out.println(s);
        }
    }

collect

/**
 * @author xc
 */
public class solution {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-20","赵敏-11","张强-14","张三丰-13","张翠山-91","张良-41","王二麻子-44","谢广坤-22");
        list.stream().map(p -> {
            String[] split = p.split("-");
            return new P(split[0], Integer.parseInt(split[1]));
        }).collect(Collectors.toList()).forEach(System.out::println);
    }

}
class P{
    private String name;
    private int age;
    public P(){}

    public P(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "P{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
收集方法

收集成集合

/**
 * @author xc
 */
public class solution {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-20","赵敏-11","张强-14","张三丰-13","张翠山-91","张良-41","王二麻子-44","谢广坤-22");
        List<P> collect = list.stream().map(v->new P(v.split("-")[0],Integer.parseInt(v.split("-")[1]))).collect(Collectors.toList());
        for (P s : collect) {
            System.out.println(s);
        }
    }

}
class P{
    private String name;
    private int age;
    public P(){}

    public P(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

收集成set

/**
 * @author xc
 */
public class solution {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-20","赵敏-11","张强-14","张三丰-13","张翠山-91","张良-41","王二麻子-44","谢广坤-22");
        Set<P> collect = list.stream().map(v->new P(v.split("-")[0],Integer.parseInt(v.split("-")[1]))).collect(Collectors.toSet());
        for (P s : collect) {
            System.out.println(s);
        }
    }

}
class P{
    private String name;
    private int age;
    public P(){}

    public P(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

收集成Map

public class solution {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-20","赵敏-11","张强-14","张三丰-13","张翠山-91","张良-41","王二麻子-44","谢广坤-22");
        Map<String,Integer> collect = list.stream().collect(Collectors.toMap(s->s.split("-")[0],v->Integer.parseInt(v.split("-")[1])));
        for (Map.Entry<String, Integer> m : collect.entrySet()) {
            System.out.println(m.getKey()+" "+m.getValue());
        }
    }
}

注意：收集过程中key不能重复，否则会报错

练习

img

public class solution {
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);

        List<Integer> collect = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
        for (Integer i : collect) {
            System.out.println(i);
        }

    }
}

img

public class solution {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"zhangsan,23","lisi,24","wangwu,25");
        Map<String, Integer> collect = list.stream()
                .filter(p -> Integer.parseInt(p.split(",")[1]) >= 24)
                .collect(Collectors.toMap(k -> k.split(",")[0], v -> Integer.parseInt(v.split(",")[1])));
        for (Map.Entry<String, Integer> m : collect.entrySet()) {
            System.out.println(m.getKey()+" "+m.getValue());
        }
    }
}

img

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


/**
 * @author xc
 */
public class solution {
    public static void main(String[] args){
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三,23","李四,24","王五,25","刘麻子,26","林俊杰,27","鲁智深,28");
        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"张三1,23","杨四2,24","王五3,25","杨麻子4,26","黑狗5,27","赵云6,28");

        Stream<String> stream1 = list1.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);
        Stream<String> stream2 = list2.stream().filter(s -> s.split(",")[0].startsWith("杨")).skip(1);
        List<Actor> collect = Stream.concat(stream1, stream2).map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1]))).collect(Collectors.toList());
        for (Actor actor : collect) {
            System.out.println(actor);
        }
    }
}
class Actor{
    private String name;
    private int age;
    public Actor(){}

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

    @Override
    public String toString() {
        return "P{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
.collect(Collectors.toList());
        for (Actor actor : collect) {
            System.out.println(actor);
        }
    }
}
class Actor{
    private String name;
    private int age;
    public Actor(){}

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

    @Override
    public String toString() {
        return "P{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
xc6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8新特性之Stream API
MOKE_SPACE
07-25 1016
概述 Stream API 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。总得来说，Stream API 就是提供了一种高效且易于使用的处理数据的方式。 注：需要会使用 Lambda 表达...
java8新特性Lambda与stream视频教程-文档和代码.rar
10-25
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以...
Java8新特性：StreamAPI（超详解）
weixin_52533007的博客
03-31 7073
用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道。Stream 自己不会存储元素。Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Java8新特性 stream流常用方法
热门推荐
cc_1209的博客
06-27 3万+
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理，...
java8新特性——StreamAPI
Mr_ZhouR的博客
11-08 1612
什么是Stream？ 是数据渠道，用于操作数据源（集合数组等）所生成的元素序列 “集合讲的是数据，流讲的是计算” 注意： Strram自己不会存储元素。 Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream Stream操作时延迟执行的。这意味着他们会等到需要结果的时候才执行 Stream的三个操作步骤： 创建Stream 中间操作 终止操作（终端操作） 创建Strea...
Java8新特性——Stream API的终止操作
胜天半子祁同伟
11-08 8151
Java8新特性——Stream API的终止操作
Java8新特性Stream流
weixin_51725434的博客
12-19 1134
Java8新特性Stream流
Java8新特性Stream详解
程序员Forlan的博客
12-13 1529
本文详细介绍了Java中的Stream API，包括Stream的定义，操作分类以及具体操作方法。同时，通过综合使用示例，展示了Stream在实际问题解决中的能力。
Java8新特性 Stream流常用方法
weixin_44338615的博客
06-26 3308
Java8 API添加一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream使用一种类似用SQL语句从数据库中查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。 元素流在管道中经过中间操作(intermediate operation）的处理，最后由最终操作得到前
Java 8 新特性——Stream
wenqi1992的博客
07-13 1471
Java 8 新特性之 Stream 的详细讲解，丰富的示例，通熟易懂
Java8新特性-Stream流的介绍与具体使用
有见寒舍
02-19 1147
Java8新特性-stream流
JAVA8的新特性学习笔记
03-01
该笔记主要记录了学习Java8新增特性的全部信息，包含概念讲解及代码示例，主要针对Lambda表达式、函数式接口、方法引用及构造器引用、Stream API、Optional类几个模块深入浅出的介绍了各个模块的使用。希望对大家的...
java8新特性
12-14
java SE8 新特性，每一位java开发工程师的必备宝典，其中包括lambda表达式以及lambda编程、stream API处理、新的日期与时间API、JavaScript引擎、并发增强处理、杂项处理等等。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 989
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 785
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 287
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 254
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java多线程创建方式
weixin_57763462的博客
05-28 1072
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值