stream详解

最新推荐文章于 2024-05-16 15:30:42 发布
最新推荐文章于 2024-05-16 15:30:42 发布
阅读量141 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51001722/article/details/130960880
版权

JDK8 Stream详解

概念

Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 。

特点

（1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环

（2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。

流程

1）第一步：把集合转换为流stream
2）第二步：操作stream流
stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果

操作符

两种：中间操作符、终止操作符

中间操作符

流方法

含义

示例

filter

用于通过设置的条件过滤出元素

List strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");List filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

distinct

返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。

List numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);

limit

会返回一个不超过给定长度的流。

List strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");List limited = strings.stream().limit(3).collect(Collectors.toList());

skip

返回一个扔掉了前n个元素的流。

List strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");List skiped = strings.stream().skip(3).collect(Collectors.toList());

map

接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。

List strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");List mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList());

flatMap

使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。

List strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");Stream flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);

sorted

返回排序后的流

List strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");List sorted1 = strings1.stream().sorted().collect(Collectors.toList());

示例代码：

1）filter

2）distinct

3）limit

4）skip

5）map

6）flatMap

7）sorted

Map、flatMap区别

/**
 * 功能描述:根据条件过滤集合数据
 * @return : void
 */
@Test
public void filter(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
    out.println(filtered);
}
/**
 * 功能描述:去除集合中重复数据
 * @return : void
 */
@Test
public void distinct(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> distincted = strings.stream().distinct().collect(Collectors.toList());
    out.println(distincted);
}
/**
 * 功能描述:指定获取集合前x条数据，重新构造一个新的集合
 * @return : void
 */
@Test
public void limit(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> limited = strings.stream().limit(3).collect(Collectors.toList());
    out.println(limited);
}
/**
 * 功能描述:排除集合前x条数据，把后面的数据重新构造一个新的集合
 * @return : void
 */
@Test
    public void skip(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> skiped = strings.stream().skip(3).collect(Collectors.toList());
    out.println(skiped);
}
/**
 * 功能描述:对集合中所有元素统一处理
 * @return : void
 */
@Test
public void map(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList());
    out.println(mapped);
}
/**
 * 功能描述:对集合中所有元素统一处理
 * @return : void
 */
@Test
public void flatMap(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    Stream<String> stringStream = strings.stream().map(x -> x);
    Stream<String> stringStream1 = strings.stream().flatMap(x -> Arrays.asList(x.split(" ")).stream());
}
/**
 * 功能描述 : 对集合进行排序
 * @return : void
 */
@Test
public void sorted(){
    List<String> strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    List<String> strings2 = Arrays.asList("张三", "李四", "王五", "赵柳", "张哥","李哥", "王哥");
    List<Integer> strings3 = Arrays.asList(10, 2, 30, 22, 1,0, -9);
    List<String> sorted1 = strings1.stream().sorted().collect(Collectors.toList());
    List<String> sorted2 = strings2.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
    List<Integer> sorted3 = strings3.stream().sorted().collect(Collectors.toList());
    out.println(sorted1);
    out.println(sorted2);
    out.println(sorted3);
}

map：对流中每一个元素进行处理
flatMap：流扁平化，让你把一个流中的“每个值”都换成另一个流，然后把所有的流连接起来成为一个流 
总结：map是对一级元素进行操作，flatmap是对二级元素操作。

本质区别：map返回一个值；flatmap返回一个流，多个值。

应用场景：map对集合中每个元素加工,返回加工后结果；flatmap对集合中每个元素加工后，做扁平化处理后（拆分层级，放到同一层）然后返回

/**
 * 方法一
 * 功能描述:  通过使用map、flatMap把字符串转换为字符输出对比区别
 * @return : void
 */
@Test
public void flatMap2Map(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    final Stream<Character> flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);
    flatMap.forEach(System.out::println);
    //----------------------------------------------
    final Stream<Stream<Character>> mapStream = strings.stream().map(Java8StreamTest::getCharacterByString);
    //mapStream.forEach(System.out::println);
    out.println("------------------------------------------------");
    mapStream.forEach(stream-> {stream.forEach(character->{System.out.println(character);});});

}

公共方法（字符串转换为字符流）

/**
* 功能描述:字符串转换为字符流
* @param str
* @return : java.util.stream.Stream<java.lang.Character>
*/
public static Stream<Character> getCharacterByString(String str) {
    List<Character> characterList = new ArrayList<>();
    for (Character character : str.toCharArray()) {
    	characterList.add(character);
    }
    return characterList.stream();
}

终止操作符

流方法

含义

示例

anyMatch

检查是否至少匹配一个元素，返回boolean。

List strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");boolean b = strings.stream().anyMatch(s -> s == "abc");

allMatch

检查是否匹配所有元素，返回boolean。

List strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");boolean b = strings.stream().allMatch(s -> s == "abc");

noneMatch

检查是否没有匹配所有元素，返回boolean。

List strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");boolean b = strings.stream().noneMatch(s -> s == "abc");

findAny

将返回当前流中的任意元素。

List strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");Optional any = strings.stream().findAny();

findFirst

返回第一个元素

List strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");Optional first = strings.stream().findFirst();

forEach

遍历流

List strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");strings.stream().forEach(s -> out.println(s));

collect

收集器，将流转换为其他形式。

List strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");Set set = strings.stream().collect(Collectors.toSet());List list = strings.stream().collect(Collectors.toList());Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));

reduce

可以将流中元素反复结合起来，得到一个值。

List strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");Optional reduce = strings.stream().reduce((acc,item) -> {return acc+item;});if(reduce.isPresent())out.println(reduce.get());

count

返回流中元素总数。

List strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");long count = strings.stream().count();

示例代码

1）anyMatch

2）allMatch

3）noneMatch

4）findAny

5）findFirst

6）forEach java

7）collect

8）reduce

9）count

/**
 * 功能描述 : 判断集合中是否至少存在一个元素满足条件
 * @return : void
 */
@Test
public void anyMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().anyMatch(s -> s == "abc");
    out.println(b);
}
/**
 * 功能描述 : 判断集合中是否所有元素都满足条件
 * @return : void
 */
@Test
public void allMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().allMatch(s -> s == "abc");
    out.println(b);
}
/**
 * 功能描述 : 判断集合中是否所有元素都不满足条件
 * @return : void
 */
@Test
public void noneMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().noneMatch(s -> s == "abc");
    out.println(b);
}
/**
 * 功能描述 : 返回当前流中任意元素
 * @return : void
 */
@Test
public void findAny(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> any = strings.stream().findAny();
    if(any.isPresent()) out.println(any.get());
}
/**
 * 功能描述 : 返回当前流中第一个元素
 * @return : void
 */
@Test
public void findFirst(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> first = strings.stream().findFirst();
    if(first.isPresent()) out.println(first.get());
}
/**
 * 功能描述 : 遍历流
 * @return : void
 */
@Test
public void foreach(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    strings.stream().forEach(s -> out.println(s));
}
/**
 * 功能描述 : 流转换为其他形式
 * @return : void
 */
@Test
public void collect(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Set<String> set = strings.stream().collect(Collectors.toSet());
    List<String> list = strings.stream().collect(Collectors.toList());
    Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
    out.println(set);
    out.println(list);
    out.println(map);
}
/**
 * 功能描述 : 将流中元素反复结合起来，得到一个值
 * @return : void
 */
@Test
public void reduce(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    //reduce方法一
    Optional<String> reduce1 = strings.stream().reduce((acc,item) -> {return acc+item;});
    //reduce方法二
    String reduce2 = strings.stream().reduce("itcast", (acc, item) -> {
    	return acc + item;
    });
    //reduce方法三
    ArrayList<String> reduce3 = strings.stream().reduce(
        new ArrayList<String>(),
   		new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
    		@Override
    		public ArrayList<String> apply(ArrayList<String> acc, String item) {
    			acc.add(item);
    			return acc;
    		}
    	}, 
        new BinaryOperator<ArrayList<String>>() {
   			@Override
    		public ArrayList<String> apply(ArrayList<String> acc, ArrayList<String> item) {
    		return acc;
    		}
    	}
    );
    if(reduce1.isPresent())out.println(reduce1.get());
    out.println(reduce2);
    out.println(reduce3);
}
/**
* 功能描述 : 返回流中元素总数
* @return : void
*/
@Test
public void count(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    long count = strings.stream().count();
    out.println(count);
}

注意：文章中因排序部分用到外部比较器，需要导入外部jar包

<!--apache集合操作工具包-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>
李李子-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java8-Stream详解
12-21
Stream1.1 Stream介绍1.1.1 介绍1.1.2 Stream特点1.1.3 直接对集合遍历操作与使用Stream操作集合的对比1.2 Stream使用1.2.1 使用流程1.2.2 获取Stream接口对象1.2.3 延迟方法1.2.4 终结方法 1. Stream 1.1 Stream...
JVM的运行时数据区内部结构
weixin_42383680的博客
09-04 466
运行时数据区内部结构 JVM为什么需要运行时数据区： 内存是非常重要的系统资源，是硬盘和CPU 的中间仓库及桥梁，承载着操作系统和应用程序的实时运行。JVM内存布局（运行时数据区）规定了Java在运行过程中内存申请、分配、管理的策略，保证了JVM的高效稳定运行。 Java虚拟机定义若干种程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应的，这些与线程对应的数据区域会随着线程开始和结束而创...
Stream流详解
ss810540895的博客
08-05 2万+
stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。............
Stream流的讲解及使用
x871752024的博客
07-30 1940
Stream流 在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 引言 传统集合的多步遍历代码 几乎所有的集合（如Collection接口或Map接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如： public class Demo10ForEach { public static void main(String[] args) {
Stream详解
qq_42449963的博客
10-28 6400
一、简介      java8新添加了一个特性：流Stream。Stream让开发者能够以一种声明的方式处理数据源（集合、数组等），它专注于对数据源进行各种高效的聚合操作（aggregate operation）和大批量数据操作 (bulk data operation)。      Stream API将处理的数据源看做一种Stream（流），Stream（流）在Pipeline（管道）中传输和运算，支持的运算包含筛选、排序、
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java-Stream详解
yueerba126的博客
06-30 5576
Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。
Spring Cloud Stream详解
怪咖@的博客
08-26 7715
Spring Cloud Stream是一个用于构建 与 共享消息系统 连接的高度可扩展的 事件驱动微服务。通过Stream可以很轻松的整合RabbitMQ和Kafka，并且可以在两个消息中间件之间来回切换使用。一句话，屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型。.........
SpringCloud Stream详解
qq_45769329的博客
11-19 1万+
SpringCloud Stream消息驱动
【Java 8系列】Stream详解，看这一篇就够啦
Yangy的博客
12-23 5万+
热门系列： 【Java 8系列】Java开发者的判空利器 -- Optional 【Java 8系列】Lambda 表达式，一看就废 程序人生，精彩抢先看 1.前言 2.正文 3.总结 ...
Java Stream 详解
05-25
Java Stream 详解
JDK 1.8 新特性之Stream 详解.md
10-22
Stream
vb adodb.stream 详解
01-27
vb adodb stream aeecss adodb resouse recordset
Java8 Stream详解.md
05-05
Java8 Stream详解.md
jar包增量更新分析
junlaiyan的专栏
05-16 251
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 616
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 900
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c【语言】了解指针，爱上指针（1）
最新发布
yzqy_的博客
05-16 899
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java stream详解
06-02
Java 8引入了Stream API，它是一种函数式编程风格的API，可以帮助我们进行复杂的集合操作，以及实现并行处理等功能。本文将详细介绍Java Stream API的使用方法。 ## 什么是Stream Stream是Java 8中新增的一种数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值