Java JDK 1.8 新特性 Stream流

已于 2023-01-14 12:48:29 修改
阅读量671 收藏 6
点赞数
分类专栏： java 文章标签： java
于 2023-01-11 21:30:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43623492/article/details/128651235
版权

Stream流

stream流与IO流没有任何关系，stream流类似车间的生产线，对数据进行加工，不存储数据

获取Stream流的两种方式
public class StreamIntro {
    public static void main(String[] args) {
        // 方式一: 通过Collection接口的stream()方法获取流
        List<String> arrayList = new ArrayList<>();
        Stream<String> stream = arrayList.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream1 = set.stream();

        Map<String, String> map = new HashMap<>();
        Stream<String> stream2 = map.keySet().stream();
        Stream<String> stream3 = map.values().stream();
        Stream<Map.Entry<String, String>> stream4 = map.entrySet().stream();
        
        // 方式二: 通过Stream接口中的静态方法of获取流
        Stream<String> stream5 = Stream.of("zdy", "zyz", "cyx", "mcs");
        String[] strs = {"zdy", "zyz", "cyx", "mcs"};
        Stream<String> stream6 = Stream.of(strs);
    }
}

Stream常用方法

stream常用方法分为两类

终结方法：返回值不是Stream流类型的方法，不再支持链式调用，例如：count、forEach

非终结方法：返回值是Stream流类型的方法，支持链式调用，例如：filter、limit、map、skip

forEach方法

遍历集合中的每一个元素

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("zdy", "zyz", "cyx", "mcs");
        stream.forEach(System.out::println); // 打印 "zdy"  "zyz"  "cyx"  "mcs"
    }
}
count方法

计算集合的长度

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("zdy", "zyz", "cyx", "mcs");
        long count = stream.count();
        System.out.println(count); // 打印 4
    }
}
filter方法

自定义编写过滤规则，通过规则的数据留下，支持链式调用

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("zdy", "zyz", "cyx", "mcs");
        stream.filter(s -> s.contains("z")) // 包含"z"的留下
                .filter(s -> s.contains("y")) // 包含"y"的留下
                .forEach(System.out::println); // 打印 "zdy" "zyz"
    }
}
limit方法

取集合中的前n个数据

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("zdy", "zyz", "cyx", "mcs");
        stream.limit(2).forEach(System.out::println); // 打印 "zdy" "zyz"
    }
}
skip方法

从第几条数据开始取

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("zdy", "zyz", "cyx", "mcs");
        stream.skip(2).forEach(System.out::println); // 打印 "cyx" "mcs"
    }
}
map方法

将一种类型的流转换为另一种类型的流

public class StreamIntro {
    public static void main(String[] args) {
		// 通过map 将Stream<String>类型转换为Stream<Integer>类型
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        Stream<Integer> stream1 = stream.map(Integer::parseInt);
    }
}
sorted方法

排序方法，支持自定义比较器

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(5, 2, 7, 4);
        stream.sorted((num1, num2) -> num1 - num2).forEach(System.out::println); // 打印 2 4 5 7
    }
}
distinct方法

去重方法

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("zdy", "zdy", "zyz", "zyz", "cyx", "mcs");
        stream.distinct().forEach(System.out::println); // 打印 "zdy" "zyz" "cyx" "mcs"
    }
}
match方法

匹配方法，细分为三个，allMatch所有数据都满足条件，anyMatch任意一条数据满足条件，noneMatch没有数据满足条件，都返回boolean类型

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(5, 2, 7, 4);
        boolean match = stream.allMatch(num -> num > 4); // 所有数据都>4吗
        System.out.println(match); // 打印 "false"

        Stream<Integer> stream2 = Stream.of(5, 2, 7, 4);
        boolean anyMatch = stream2.anyMatch(num -> num > 4); // 有数据>4吗
        System.out.println(anyMatch); // 打印 "true"

        Stream<Integer> stream3 = Stream.of(5, 2, 7, 4);
        boolean noneMatch = stream3.noneMatch(num -> num == 3); // 没有数据=3吗
        System.out.println(noneMatch); // 打印 "true"
    }
}
max方法

获取最大值，支持自定义比较器，通过比较器也可以实现min的功能

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(5, 2, 7, 4);
        Optional<Integer> max = stream.max((num1, num2) -> num1 - num2);
        System.out.println(max.get()); // 打印 "7"
    }
}
min方法

获取最小值，支持自定义比较器，通过比较器也可以实现max的功能

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(5, 2, 7, 4);
        Optional<Integer> min = stream.min((num1, num2) -> num1 - num2);
        System.out.println(min.get()); // 打印 "2"
    }
}
reduce方法

将所有的数据归纳为一个数据

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(5, 2, 7, 4);
        // 参数1 默认值 参数2 数据处理方式 以下代码可以理解为 reduce=默认值-5-2-7-4
        Integer reduce = stream.reduce(0, (num1, num2) -> num1 - num2);
        System.out.println(reduce); // -18
    }
}
concat方法

合并两个流

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("zdy", "zyz", "cyx", "mcs");
        Stream<Integer> stream2 = Stream.of(5, 2, 7, 4);
        Stream<? extends Serializable> stream = Stream.concat(stream1, stream2);
        stream.forEach(System.out::println); // 打印 "zdy" "zyz" "cyx" "mcs" 5 2 7 4
    }
}

收集Stream流中的结果

Stream流结果保存到集合中
public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("zdy", "zyz", "cyx", "mcs");
        // 保存到Set中
        Set<String> collect = stream1.collect(Collectors.toSet());
        // 保存到List中
        List<String> collect1 = stream1.collect(Collectors.toList());
        // 保存到ArrayList
        ArrayList<String> collect2 = stream1.collect(Collectors.toCollection(ArrayList::new));
        // 保存到ArraySet
        HashSet<String> collect3 = stream1.collect(Collectors.toCollection(HashSet::new));
    }
}
Stream流结果保存到数组中
public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("zdy", "zyz", "cyx", "mcs");
        // 保存成数组
        String[] strings = stream1.toArray(String[]::new);
    }
}
Collectors.maxBy/minBy/summarizingInt

对流中数据进行聚合计算

public class StreamIntro {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("zdy", "zyz", "cyx", "mcs");
        Stream<Person> stream = Stream.of(new Person("zdy", 23),
                new Person("zyz", 24),
                new Person("cyx", 25),
                new Person("mcs", 26));
        // maxBy 获取年龄最大值 minBy 获取最小值
        Optional<Person> collect = stream.collect(Collectors.maxBy((p1, p2) -> p1.getAge() - p2.getAge()));
        System.out.println(collect.get());

        Stream<Person> stream2 = Stream.of(new Person("zdy", 23),
                new Person("zyz", 24),
                new Person("cyx", 25),
                new Person("mcs", 26));
        // summingInt 求年龄总和
        IntSummaryStatistics collect1 = stream2.collect(Collectors.summarizingInt(Person::getAge));
        // 年龄总和
        System.out.println(collect1.getSum());
        // 年龄平均值
        System.out.println(collect1.getAverage());
        // 统计数量
        System.out.println(collect1.getCount());
    }
}
Collectors.groupingBy

对流中数据进行分组 多级分组

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Person> stream2 = Stream.of(new Person("zdy", 23),
                new Person("zyz", 24),
                new Person("cyx", 23),
                new Person("mcs", 24));
        // 通过age进行分组 23一组 24一组
        Map<Integer, List<Person>> collect = stream2.collect(Collectors.groupingBy(Person::getAge));
        collect.forEach((k, v) -> {
            System.out.println(k + " " + v);
            // 打印 👇
            // 23 [Person(name=zdy, age=23), Person(name=cyx, age=23)]
			// 24 [Person(name=zyz, age=24), Person(name=mcs, age=24)]
        });
        
        Stream<Person> stream3 = Stream.of(new Person("zdy", 21),
                new Person("zyz", 22),
                new Person("cyx", 25),
                new Person("mcs", 24));
        // 年龄>23分一组 <23分一组
        Map<String, List<Person>> collect1 = stream3.collect(Collectors.groupingBy((person) -> {
            if (person.getAge() > 23) {
                return "高龄";
            } else {
                return "低龄";
            }
        }));
        collect1.forEach((k, v) -> {
            System.out.println(k + " " + v);
            // 打印 👇
            // 低龄 [Person(name=zdy, age=21), Person(name=zyz, age=22)]
			// 高龄 [Person(name=cyx, age=25), Person(name=mcs, age=24)]
        });
        
        Stream<Person> stream4 = Stream.of(new Person("zdy", 21),
                new Person("zyz", 22),
                new Person("cyx", 21),
                new Person("mcs", 22));
        // 多级分组 先根据年龄分组 再根据名字中是否含有"z"分组
        Map<Integer, Map<String, List<Person>>> collect2 = stream4.collect(Collectors.groupingBy(Person::getAge, Collectors.groupingBy((person) -> {
            if (person.getName().contains("z"))
                return "含有";
            else
                return "不含有";
        })));
        collect2.forEach((k, v) -> {
            System.out.println(k);
            v.forEach((key, value) -> {
                System.out.println("    " + key + " " + value);
                // 打印 👇
                // 21
				//     不含有 [Person(name=cyx, age=21)]
				//     含有 [Person(name=zdy, age=21)]
				// 22
				//     不含有 [Person(name=mcs, age=22)]
				//     含有 [Person(name=zyz, age=22)]
            });
        });
    }
}
Collectors.partitioningBy

对流中数据进行分区，true一区，false一区

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Person> stream2 = Stream.of(new Person("zdy", 21),
                new Person("zyz", 22),
                new Person("cyx", 25),
                new Person("mcs", 24));
        // 年龄>23分一区 <23分一区
        Map<Boolean, List<Person>> collect = stream2.collect(Collectors.partitioningBy(p -> {
            return p.getAge() > 23;
        }));
        collect.forEach((k, v) -> {
            System.out.println(k + " " + v);
            // 打印 👇
            // false [Person(name=zdy, age=21), Person(name=zyz, age=22)]
			// true [Person(name=cyx, age=25), Person(name=mcs, age=24)]
        });
    }
}
Collectors.joining

根据指定的字符串，将所有元素连接成一个字符串

public class StreamIntro {
    public static void main(String[] args) {
        Stream<Person> stream1 = Stream.of(new Person("zdy", 21),
                new Person("zyz", 22),
                new Person("cyx", 25),
                new Person("mcs", 24));
        // 根据一个字符进行拼接
        String collect = stream1.map(Person::getName).collect(Collectors.joining("_"));
        System.out.println(collect);
        // 打印 👇
        // zdy_zyz_cyx_mcs

        Stream<Person> stream2 = Stream.of(new Person("zdy", 21),
                new Person("zyz", 22),
                new Person("cyx", 25),
                new Person("mcs", 24));
        // 根据三个字符进行拼接 三个字符串分别为分隔符、前缀、后缀
        String collect1 = stream2.map(Person::getName).collect(Collectors.joining("_", "@", "^"));
        System.out.println(collect1);
        // 打印 👇
        // @zdy_zyz_cyx_mcs^
    }
}

并行Stream流

获取并行流的两种方式
public class StreamIntro {
    public static void main(String[] args) {
        // 方式一 直接获取并行流
        ArrayList<Object> list = new ArrayList<>();
        Stream<Object> stream = list.parallelStream();

        // 方式二 将串行流转换为并行流
        Stream<Integer> parallel = Stream.of(1, 3, 4, 5, 6, 7, 3, 2).parallel();

        long count = parallel.filter(num -> {
            System.out.println(Thread.currentThread() + " " + num);
            // 打印 👇 由此可见是多个线程一起执行
            // Thread[main,5,main] 7
            // Thread[ForkJoinPool.commonPool-worker-23,5,main] 3
            // Thread[main,5,main] 6
            // Thread[ForkJoinPool.commonPool-worker-5,5,main] 2
            return num > 3;
        }).count();
    }
}
zhangdy_plus
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk1.8新特性.doc
04-01
JDK1.8引入了许多重要的新特性，极大地提升了Java编程的效率和性能。以下是这些特性的详细介绍： 1、**Lambda表达式**： Lambda表达式是JDK1.8的一个重大改进，它允许开发者以更简洁的方式传递代码块。在上述示例中...
java jdk1.8 中文版
05-09
以上只是Java JDK 1.8部分核心特性，实际使用中还有许多其他改进和增强，如模块化系统（Project Jigsaw），尽管该特性在Java 8中并未完全实现，但在后续版本中得到了加强。通过深入学习和掌握这些知识点，开发者能够...
JDK1.8新特性——Stream流
lrs998563的博客
07-21 3142
Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的StreamAPI表达式。Stream是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作，在新版的JPA【连接数据库】中，也已经加入了Stream。StreamAPI给我们操作集合带来了强大的功用，同时StreamAPI操作简单，容易上手。......
JDK1.8新特性——Stream
weixin_42412601的博客
01-28 1586
@Test public void studyStream() throws Exception{ //参考：https://www.runoob.com/java/java8-streams.html //生成流 //stream() 为集合创建串行流 //parallelStream() 为集合创建并行流 ...
【Java】jdk1.8新特性-Stream流
lchuyan的博客
08-14 267
Stream流是JAVA8 API的新成员，它允许以声明性处理数据集合。其通过函数式编程使得代码更简洁且可读性更高。
WIN10 Java jdk 1.8安装教程
weixin_48052655的博客
11-30 2925
基本一直点安装就好，这个界面，要记住这个安装路径，后面会用到，此处我的是没有进行更改，有需要的也可以进行更改。还是一直点击下一步即可。由于今天换了新的办公室，有了新的电脑，所以要对机器安装一下JDK1.8的版本,于是顺便写一下教程。安装到此结束，希望大家可以顺利安装！我一路下来没遇到什么问题，有问题也可以评论区留言或者私信！我下载的是目前最新的jdk-8u391-windows-x64.exe。到这个界面，我们的安装已经结束了，后面进行配置教程。点击下载链接进行下载。
【java】windows下安装jdk1.8详细图文操作说明（包会）
最新发布
tttzzzqqq2018的博客
03-20 4543
【实操】【java】windows下安装jdk1.8详细图文操作说明（包会）
【Java面试系列】JDK 1.8 新特性之 Stream API.pdf
02-21
Stream 是 Java 8 的新特性，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation）或者大批量数据操作。 Stream 是用函数式编程方式在集合类上进行复杂操作的工具，...
JDK 1.8 新特性之Stream 详解.md
10-22
Stream
jdk1.8版本免安装
07-26
在这个"jdk1.8版本免安装"的压缩包中，我们可以找到JDK 1.8.0_181的具体内容，这是一个更新版本，包含了修复的漏洞和性能改进。 首先，JDK 1.8最重要的特性之一是Lambda表达式，它简化了函数式编程，使得处理集合...
Java 8中处理集合的优雅姿势——Stream
johnhuster的专栏
03-11 515
转载自：https://mp.weixin.qq.com/s/adKZrOe6nFEmuADHijsAtA 在Java中，集合和数组是我们经常会用到的数据结构，需要经常对他们做增、删、改、查、聚合、统计、过滤等操作。相比之下，关系型数据库中也同样有这些操作，但是在Java 8之前，集合和数组的处理并不是很便捷。 不过，这一问题在Java 8中得到了改善，Java 8 API添加了一个新的抽象称...
JDK 1.8 stream 操作list 集合 方法
All In.
10-12 3376
forEach 循环 : ArrayList<User> list = new ArrayList<User>(); User user1 = new User(1,"1"); User user2 = new User(2,"2"); User user3 = new User(3,"3"); list.add(user1); list.add(user2); list.add(user3); list.stream().forEach(System.out ..
jdk1.8 lamda表达式操作stream流List全纪录
Ricardo.M.Yu的博客
11-08 408
java8 stream流相关操作
java 1.8 Stream
单人影的博客
12-08 702
stream: 是数据渠道,用于操作数据源(数组,集合等.)所产生的元素序列 集合讲的是数据,流讲的是计算. 并行: parallel 注意: stram 自己不会存储元素. stream 不会改变源对象,相反 他们会返回一个持有结果的新stream. stream 操作是延迟执行的,这意味着他们会等到需要结果的时候才执行. 使用步骤: 1.创建...
Stream集合详细操作（jdk1.8新特性）
qq_53464269的博客
03-05 2957
Stream集合
jdk8的Stream流
qq_44860734的博客
05-14 513
Stream流 当我们需要对集合中的元素进行操作的时候，除了必须的添加，删除，获取外，最经典的就是集合遍历 Stream流的含义： 获取流，过滤流张，过滤长度，注意打印，使得代码更加的简介直观。 一、Stream流的获取方式 通过collection获取 List list = Arrays.asList(1,2,3,4,5,6); Stream stream = list.stream(); map接口没有实现Collection接口，这时我们可以根据Map获取对应的key，value的集合。 Map
有关jdk1.8 stream&lambda
低端博客
05-24 1784
stream默认是串行流，parrallelstream是并行流(流中的每个元素操作是并行的，没有特定的先后顺序），本质上是高级的iterator。 flatMap对于一维意味来说没有什么意义，将二维list平铺成一维。 获取流的操作可以这样: Stream> integerListStream = Stream.of(  Arrays.asList(1, 2),   Arrays.as
jdk1.8新特性总结及使用示例
11-16
除了Lambda表达式外，JDK1.8还引入了Stream API、接口的默认方法和静态方法、新时间日期API等新特性。这些新特性都使得Java编程更加简洁高效，同时也更贴近现代编程的需求。 总的来说，JDK1.8的新特性大大增强了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值