java进阶-JDK1.8之后新特性：Stream流

已于 2022-03-11 21:32:05 修改
阅读量694 收藏 3
点赞数 1
分类专栏： 大杂烩 文章标签： java
于 2022-03-10 16:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lalala_dxf/article/details/123319180
版权

Stream流

1、概述

java.util.stream.Stream接口，表示能应用在一组元素上，一次执行的操作序列，也就是可以对一组数据进行连续的多次操作。
在这里插入图片描述

Stream在使用的时候，需要指定一个数据源，比如 java.util.Collection的子类，List或者Set都可以，但是Map类型的集合不支持。

Stream是对集合功能的增强，它提供了各种非常便利、高效的聚合操作，可以大批量数据操作，同时再结合Lambda表达式，就可以极大的提高编程效率。

Stream的API提供了串行和并行两种模式进行操作数据。
Stream操作分为中间操作或者最终操作两种：

  1. 中间操作：返回Stream本身，这样就可以将多个操作依次串起来（例如map、flatMap、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered）
  2. 最终操作：返回特定类型的计算结果（forEach、forEachOrdered、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator）

可以把这个Stream操作理解成穿线，把操作都串起来了

例如：

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

        list = list.stream()
                .filter(e->e%2==0) //过滤，保留偶数
                .sorted((e1,e2)->e2-e1) //排序，倒序
                .collect(Collectors.toList()); //最终操作，收到一个新的List集合中并返会

        System.out.println(list); //[8, 6, 4, 2]
    }
}

分析：

接口Stream<T> filter(Predicate<? super T> predicate);中的参数是一个Predicate接口，该接口中有个test()抽象方法；接口 Stream<T> sorted(Comparator<? super T> comparator);中的参数是一个比较器Comparator接口类型的；

可以看出，在list集合转为Stream后，可以经过连续的多次数据操作，最后返回我们想要的结果，并且实现功能代码比之前更加优雅、简洁。你甚至可以把stream操作理解成生产车间的流水线作业，一个最初的产品（数据），经过中间多个连续的不同工序（操作），得到最终的产品。

值、数组、集合、基本类型转Stream

可以将现有的数据，转换为Stream对象，然后再使用Stream的API对数据进行一些系列操作。

值转Stream

在这里插入图片描述
通过Arrays.stream()方法将传入的值放到stream对象中，返回stream对象

public Test{

	public static void main(String[] args){
		Stream<String> stream = Stream.of("a","b","c"); //将值转stream
		System.out.println(Arrays.toString(stream.toArray()));
	}
}

分析：传入泛型类型的值，返回一个stream对象，通过stream.toArray()方法将stream对象转换为数组对象，再通过Arrays工具类的toString方法输出数组。

数组转Stream

两个方法：
（1）Arrays工具类中的stream方法可以将数组转换为stream对象
（2）Stream接口中的of方法可以将数组转换为stream对象
例如：

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

        String[] arr = {"a","b","c"};
        //第一种方式Arrays.stream(数组)
        Stream<String> stream1 = Arrays.stream(arr);
        //第二种方式：Stream.of(数组)
        //Stream<String> stream2 = Stream.of(arr); 

        //测试
        System.out.println(Arrays.toString(stream1.toArray())); //[a, b, c]
       //System.out.println(Arrays.toString(stream2.toArray())); //[a, b, c]
    }
}

集合转Stream

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

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c");
        
        Stream<String> stream = list.stream(); //将集合list转换为stream对象

        System.out.println(Arrays.toString(stream.toArray())); //[a,b,c]
    }
}

基本类型转Stream

虽然也可以用Stream类型，并指定泛型：
Stream
Stream
Stream
但是，在数据量较大的时候，自动拆箱/装箱会比较消耗性能，所以提供了下面三种专门针对基本类型的Stream
对于基本数值类型，有专门的三种Stream类型：
IntStream
LongStream
DoubleStream

例如：以IntStream类型为例

public class Test {
    public static void main(String[] args) {
        IntStream stream1 = IntStream.of(new int[]{1, 2, 3});

        IntStream stream2 = IntStream.range(1, 3); //表示1到3的范围内为左闭右开[1,3)

        //IntStream stream3 = IntStream.rangeClosed(1, 3); //左右都闭[1,3]
        
    }
}

Stream转数组、集合、字符串等

Stream转数组

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java"); //将三个字符串转换为stream

        String[] strings = stream.toArray(String[]::new); //将stream转换为数组
        //String[]::new是构造器引用中的数组构造引用，且是String类型的数组，通过该方式创建一个数组对象，将stream转换过来的值存放到该数组对象中
        System.out.println(Arrays.toString(strings)); //[hello, world, java]
    }
}

分析，把String[]::new单独拎出来，可以发现它是被IntFunction接收的IntFunction aNew = String[]::new;，查看IntFunction接口源码可以发现里面有一个抽象方法R apply(int value);，通过重写该接口中的apply方法，返回一个数组对象，如下：

IntFunction ic = new IntFunction() {
            @Override
            public Object apply(int value) {
                return new String[value];
            }
        }

简化成lambda表达式如下
IntFunction ic = value->new String[value];
再次简化就成Strig[] ::new

Stream转集合

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java"); //将三个字符串转换为stream

        List<String> list = stream.collect(Collectors.toList());

//        ArrayList<String> list = stream.collect(Collectors.toCollection(ArrayList::new));

//        Set<String> set = stream.collect(Collectors.toSet());

//        HashSet<String> set = stream.collect(Collectors.toCollection(HashSet::new));
    }
}

分析：collect方法中的参数是Collectors接口对象，作用是将元素收集到一个可以修改的容器中，并返回该容器
在这里插入图片描述
（1）toList()方法源码如下
在这里插入图片描述
主要作用是返回一个List集合，stream.collect()将stream中的内容放到这个List集合中。
（2）toCollection()方法原码如下：
在这里插入图片描述
ArrayList::new（构造方法引用）可以构造一个ArrayList集合，toCollection()方法将元素放到构造的ArrayList中
（3）toSet()方法和HashSet::new也如上两个这么理解

需要注意的是一个Stream在代码只能使用一次，再次使用就会报错，如多次使用一个Stream对象就会抛出以下异常：java.lang.IllegalStateException: stream has already been operated upon or closed

Stream转字符串

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java");
        String result = stream.collect(Collectors.joining("-")); //使用“-”将字符串连接起来hello-world-java
        System.out.println(result);
    }
}

Stream中的常见操作

最终操作

（1）iterator()方法

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java");
        Iterator<String> it = stream.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

（2）forEach()方法
将Stream中的每个元素交给Consumer函数处理
在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java");
        stream.forEach(System.out::println);
    }
}

（3）count()方法
统计流中的元素个数，并返回结果

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java");
        System.out.println(stream.count());;
    }
}

（4）max()方法
返回流中基于comparator所指定的比较规则，比较出的最大值

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java");
       /* 实例方法引用:类名::非静态方法名
       Optional<String> max = stream.max(new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        */
        Optional<String> max = stream.max(String::compareTo);
        System.out.println(max.get());
    }
}

（5）min()方法
返回流中基于comparator所指定的比较规则，比较出的最小值
在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java");
       /* 实例方法引用:类名::非静态方法名
       Optional<String> min = stream.min(new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        */
        Optional<String> max = stream.min(String::compareTo);
        System.out.println(max.get());
    }
}

（6）collect方法
将元素收集到一个可以修改的容器中，并返回该容器。
在这里插入图片描述
使用样例1：

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        //把Stream中的元素，按照字符串长度进行分组，长度相同算是一组，并存放到同一个集合中
        //map的key是字符串的长度，value是同一组的数据
        Map<Integer, List<String>> map = stream.collect(Collectors.groupingBy(String::length));

        map.forEach((k,v) -> System.out.println(k + " : " + v));
    }
}


4 : [java]
5 : [hello, world]
6 : [python]
8 : [zhangsan]
10 : [javascript]

使用样例2：

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        //把Stream中的元素，按照指定条件分割成俩组，条件返回true是一组，条件返回false是另一组
        //map的key是true或者false，value是对应的数据
        // 按照数据中是否包含"java"字符串来进行划分

        Map<Boolean, List<String>> map = stream.collect(Collectors.partitioningBy(s -> s.indexOf("java") != -1));
        map.forEach((k,v) -> System.out.println(k + " : " + v));
    }
}

//结果：
false : [hello, world, python, zhangsan]
true : [java, javascript]

（7）Match()方法
匹配操作，Stream中提供了多种匹配模式

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        //所有元素匹配成功才返回true 否则返回false
        boolean allMatch = stream.allMatch((s) -> s.startsWith("j"));
        System.out.println(allMatch);

        //任意一个匹配成功就返回true 否则返回false
//        boolean anyMatch = stream.anyMatch((s)->s.startsWith("j"));
//        System.out.println(anyMatch);

        //没有一个匹配的就返回true，否则返回false
//        boolean noneMatch = stream.noneMatch((s) -> s.startsWith("j"));
//        System.out.println(noneMatch);

    }

这些操作不能同时执行，因为一个Stream只能使用一次

（9）findFirst()
返回Stream的第一个元素

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        Optional<String> first = stream.findFirst();
        System.out.println(first.get()); //hello
    }
}

中间操作

（1）filter方法()
过滤方法，返回满足predicate指定的条件的所有元素的一个新流
在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
       stream.filter(e -> e.contains("o")).forEach(System.out::println);
    }
}

（2）map()方法
对调用流中的元素，应用Function所指定的操作，然后返回一个新流
在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        List<Integer> list = stream.map(str -> str.length()).collect(Collectors.toList());
        list.forEach(System.out::println);
    }
}
//结果
5
5
4
6
10
8

map生成的是个1:1映射，每个输入元素，都按照规则转换成为另外一个元素

（3）reduce()方法
将一组数据俩俩合并，最后得出一个结果

public class Test {
    public static void main(String[] args) {
//        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        IntStream stream = IntStream.rangeClosed(1, 10);
        //reduce方法需要提供一个起始值(种子)
        // 然后依照运算规则,和Stream中的第一个数据进行操作，得出结果
        // 再将这个结果和Stream中的第二个数据进行操作，再得出结果，依次类推，直到得出最终结果
        int result = stream.reduce(0,(a,b) -> a+b);
        System.out.println(result); //55
    }
}

（4）sorted()方法
排序

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        //默认自然排序
        stream.sorted().forEach(System.out::println);
    }
}

//输出结果
hello
java
javascript
python
world
zhangsan

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        //比较器排序，注意Lambda表达式中返回的值前加了符号
        stream.sorted((o1,o2) -> -o1.compareTo(o2)).forEach(System.out::println);
    }
}

（5）limit()方法
返回Stream 的前面 n 个元素

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
        stream.limit(5).forEach(System.out::println); 
    }
}

（6）skip()方法
跳过前 n 个元素只要后面的元素。

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "world", "java","python","javascript","zhangsan");
       stream.skip(3).forEach(System.out::println); //跳过前面3个元素
    }
}

（7）distinct()方法
去除重复数据

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello","hello", "world", "java","python","javascript","zhangsan");
        stream.distinct().forEach(System.out::println);
    }
}

静态方法

（1）concat()方法
拼接两个流

public class Test {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("hello", "world");
        Stream<String> stream2 = Stream.of("tom", "mary");
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(System.out::println);
    }
}

（2）Stream.generate()方法
通过Supplier接口,可以自己来控制数据的生成。
在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        Random random = new Random();

        //生成100个随机数,并输出
        Stream.generate(() -> random.nextInt(100))
                .limit(100)
                .forEach(System.out::println);

        //生成100个随机数,并存放到集合中
        Stream.generate(()->random.nextInt())
                .limit(100)
                .collect(Collectors.toList());
    }
}

Stream.iterate，它跟 reduce 操作很像，需要接受一个起始值（种子），然后通过函数得出一个结果，再把结果当做参数传给函数，再得出第二个结果，依次类推，其实就是一个递归操作。

IO流与Stream

在IO流中，也有方法，可以将读取到的数据转换为Stream对象。
在这里插入图片描述
例如:

public class Test {
    public static void main(String[] args) throws FileNotFoundException {
        BufferedReader br = null;
        br = new BufferedReader(new FileReader("src/com/demo.a.txt"));
        int maxLen = br.lines() //io流转为Stream
                .mapToInt(String::length)  //每行字符串转换为它的字符长度
                .max() //获取最大长度的数字
                .getAsInt(); //返回int类型的数据
        System.out.println(maxLen);

        try {
            br.close();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

并行流

Stream有串行和并行两种。串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。

创建并行Stream的两种方式：
（1）调用串行Stream的parallel()方法，可以将其转换并行Stream

Stream<String> stream = Stream.of("hello","world","java");
Stream<String> parallelStream = stream.parallel();

（2）调用集合对象的parallelStream方法，之后获取并行Stream

List<String> list = new ArrayLIst<>();
Collections.addAll(list,"hello","world","java");

Stream<String> parallelStream = list.parallelStream();
持久的棒棒君
关注
专栏目录
Java1.8新特性 -- Stream流总结
weixin_42947972的博客
07-10 722
Stream流 1.8 java推出的新特性 Stream流的出现,可以让我们减少代码量,使得代码更加的优雅,同时会使得代码不易阅读 使用传统的写法: //创建一个集合 List<String> list = new ArrayList<>(); //添加 list.add("张三"); list.add("李四"); list.add("王五"); //遍历 for(String name : list){ System.out.println(name)
java1.8新特性（四 创建 stream对象）
weixin_30361641的博客
01-07 323
java1.8 提供了 stream对象 可以用作 对 集合 数组的 一系列操作，都是基于lambda 表达式 ，所以得先熟悉lambda 表达式 集合创建stream对象 // 1.集合创建stream对象 List<User> asList = Arrays.asList(new User("张三", 15), new User("李四", 25...
Arrays.stream使用方法总结
最新发布
weixin_45271005的博客
07-03 1014
本文介绍Arrays的stream流用法。
jdk1.8新特性Stream流处理
qq_41144042的博客
12-15 377
引言： Stream流处理，不是IO流的处理，而是真正的函数式编程风格引入到Java中 概念 Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如
JDK1.8新特性---＞stream流
xiao-啸
08-05 707
jdk1.8新特性stream的相关操作
喜大苦奔！java不需要自己关闭io流了，就在jdk1.7
qidaorenzhe的博客
11-05 1472
以往，我们需要在finally中关闭自己写的io流，防止内存溢出，相当麻烦。如下 InputStream is=null; InputStreamReader isr=null; BufferedReader read=null; try { is = new FileInputStream(new File("...
javajdk1.8源码-yang-java-source:jdk1.8源码学习
05-20
源码学习是软件工程师进阶的必经之路，它能帮助我们理解Java平台的核心机制，包括类库、并发模型、垃圾收集以及新的语言特性，如Lambda表达式和Stream API。 【标签】"系统开源"意味着JDK 1.8的源代码是开放的，可...
java 1.8 map lambda_Java进阶篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用详解(很详细)...
weixin_33582311的博客
02-24 687
前言本篇主要讲述是Java中JDK1.8的一些新语法特性使用，主要是Lambda、Stream和LocalDate日期的一些使用讲解。LambdaLambda介绍Lambda 表达式(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda...
11. JDK1.8 新特性解析：Stream API 实战
Stream API 是 JDK1.8 引入的一个重要新特性，它提供了一种更便利、高效的处理集合的方式。通过 Stream API，我们可以通过一系列的流水线操作来处理集合中的数据，实现类似 SQL 查询语句的功能。 ### 1.1 什么是 ...
javajdk1.8源码-JavaSourceLearn-Leetcode:jdk1.8源码+leetcode刷题
05-20
Java JDK 1.8 是一个里程碑版本，引入了许多新的特性和优化，如 Lambda 表达式、Stream API 和方法引用来提升开发效率和代码质量。本资源提供了 JDK 1.8 的源码，配合 LeetCode 刷题，可以帮助开发者更全面地掌握 ...
《JAVA 进阶： JDK8新特性：Lambda，Stream API，Optional》
yexiangCSDN的专栏
07-29 336
dd
JAVA IO流中1.7之后关闭流的处理
aiyadage的博客
06-19 278
主要是对1.7之后try--catch,自动关闭流
java.util.stream.Stream
底层码农
03-22 6519
Stream
stream流带下标foreach循环
小爷欣欣
01-29 6005
stream.iterate(0,i->i+1).limit(pars.size()).foeach(i ->{system.out.printlen(i)});
java 使用stream累加对象中某个属性的值并返回总和
热门推荐
原&点、、
03-29 2万+
假设有一个包含对象的List列表，每个对象都有一个属性value，可以使用Java 8中的Stream流来累加对象中某个属性的值并返回总和。
Java8新特性 Stream流
一只文森特
11-24 1032
Java8新特性 Stream流
Stream流的简单使用
m0_46360888的博客
04-16 3920
stream
java.util.stream是哪个包_Java流库详解（java.util.stream）
weixin_32503491的博客
02-13 1122
Java流库(java.util.stream)流提供了一种让我们可以在比集合更高的概念级别上指定计算的数据视图。通过使用流，我们可以说明想要完成什么任务，而不是说明如何去实现它。(这一点受益于lambda表达式)我们将操作的调度留给具体的实现去解决。流大量的用到了lambda表达式(同根生于Java8)之后的篇幅将会说到lambda表达式一、 流的特点流的特点流并不储存元素。这些元素可能存储在底...
java.util.stream找不到_对java.util.stream库的介绍
weixin_42285866的博客
02-13 752
Java SE 8中的主要新语言功能是lambda表达式。您可以将lambda表达式视为匿名方法;类似方法，lambdas键入了参数，一个body和一个返回类型。但是真正的消息并不是lambda表达自己，而是它们能够实现的。Lambdas可以轻松地将行为表达为数据，从而可以开发更具表现力和更强大的库。在Java SE 8中也引入了一个这样的库，它是一个java.util.stream包(Strea...
JDK1.8新特性详解：Lambda、Stream API与时间日期API
"本文概述了JDK1.8的关键特性，包括Lambda表达式、函数式接口、方法引用和构造器调用、Stream API、接口的默认方法和静态方法以及新时间日期API。此外，还讨论了JDK1.8对HashMap数据结构的优化，引入了红黑树以提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值