探索flutter框架开发的app在移动应用市场的潜力与挑战
1004
2023-04-04
JDK1.8新特性Stream流式操作的具体使用
一. 前言
随着java的发展,越来越多的企业开始使用JDK1.8 版本。JDK1.8 是自 JDK1.5之后最重要的版本,这个版本包含语言、编译器、库、工具、JVM等方面的十多个新特性。本次文章将着重学习Stream。
Stream 是JDK1.8 中处理集合的关键抽象概念,Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
元素流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作(terminal operation)得到前面处理的结果。
+--------------------+ +------+ +------+ +---+ +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+ +------+ +------+ +---+ +-------+
简而言之,Stream API提供了一种高效且易于使用的处理数据的方式。
二. 什么是Stream
1.Stream(流)是一个来自数据源的元素队列并支持聚合操作。
元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
数据源 流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
聚合操作 类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等。
2.和以前的Collection操作不同, Stream操作还有两个基础的特征:
Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代: 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代http://。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。
特点:
1.Stream 不是数据结构,不会保存数据。
2.Stream 不会修改原来的数据源,它会将操作后的数据保存到另外一个对象中。(保留意见:毕竟peek方法可以修改流中元素)
3.惰性求值,流在中间处理过程中,只是对操作进行了记录,并不会立即执行,需要等到执行终止操作的时候才会进行实际的计算。
三. 关于Stream API
1. Stream API分类
Stream 操作分为中间操作或者终止操作两种,终止操作返回一特定类型的计算结果,而中间操作返回Stream本身,Stream 的操作类型具体分类如下:
解释:
无状态:指元素的处理不受之前元素的影响;
有状态:指该操作只有拿到所有元素之后才能继续下去。
非短路操作:指必须处理所有元素才能得到最终结果;
短路操作:指遇到某些符合条件的元素就可以得到最终结果,如 A || B,只要A为true,则无需判断B的结果。
2. 如何使用Stream流?
使用Stream流分为三步。
创建Stream
一个数据源(如:集合、数组),获取一个Stream流。
中间操作
一个中间操作链,对数据源(如:集合、数组)的数据进行处理。
终止操作
一个终止操作,执行中间操作链,并产生一个计算结果。
3. Stream的中间操作和结束操作
中间操作
filter: 过滤流,过滤流中的元素,返回一个符合条件的Stream
map: 转换流,将一种类型的流转换为另外一种流。(mapToInt、mapToLong、mapToDouble 返回int、long、double基本类型对应的Stream)
flatMap:简单的说,就是一个或多个流合并成一个新流。(flatMapToInt、flatMapToLong、flatMapToDouble 返回对应的IntStream、LongStream、DoubleStream流。)
distinct: 返回去重的Stream。
sorted: 返回一个排序的Stream。
peek: 主要用来查看流中元素的数据状态。
limit: 返回前n个元素数据组成的Stream。属于短路操作
skip: 返回第n个元素后面数据组成的Stream。
结束操作
forEach: 循环操作Stream中数据。
toArray: 返回流中元素对应的数组对象。
reduce: 聚合操作,用来做统计。
collect: 聚合操作,封装目标数据。
min、max、count: 聚合操作,最小值,最大值,总数量。
anyMatch: 短路操作,有一个符合条件返回true。
allMatch: 所有数据都符合条件返回true。
noneMatch: 所有数据都不符合条件返回true。
findFirst: 短路操作,获取第一个元素。
findAny: 短路操作,获取任一元素。
forEachOrdered: 暗元素顺序执行循环操作。
四. 如何获取Stream流
在 Java 8 中, 集合接口有两个方法来生成流:
stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。
1. 常见几种集合流的创建
/**
* stream,获取各种集合的stream流
*/
@Test
public void testCollectionStream(){
//List集合
List
//Set集合
Set
//Map集合
Map
//数组
String[] stringArray = {"张三三","李四","王五","王五","赵八",};
//通过list获取stream流
Stream
//通过set获取stream流
Stream
//通过map获取stream流
Stream
//通过array获取stream流
Stream
}
2. 构造流的几种常见方法
@Test
public void testCollectionStream(){
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String[] strArray = new String[]{"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List
stream = list.stream();
}
五. Stream在代码中的使用方式
关于Stream的常见操作方式,主要分为两大类: 中间操作和终止操作 ,接下来就通过这两大分类,讲解下具体的语法用法。
1. 流的中间操作
1.1 筛选过滤
filter:过滤流中的某些元素
/**
* filter 方法 , 返回符合过滤条件的值
*/
@Test
public void testFilter() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.stream().filter(e -> e.contains("张")).forEach(System.out::println);
}
或
filter多个过滤筛选条件
/**
* list集合stream流式操作
*/
@Test
public void testStreamList() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.stream().filter(e -> e.startsWith("张")) //过滤所有姓张的人
.filter(e -> e.length() == 3) //过滤所有姓名是3个字的人
.forEach(System.out::println); //遍历打印,System.out::println表明System.out调用println打印方法
}
limit(n):获取前n个元素
/**
* limit 方法 ,返回前n个元素数据值组成的Stream。
*/
@Test
public void testLimit() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
list.stream().limit(3).forEach(System.out::println); //取前3个
}
skip(n):跳过n元素,配合limit(n)可实现分页
/**
* skip方法 ,跳过前n个元素的中间流操作,返回剩下的值。
*/
@Test
public void testSkip() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
//list.stream().skip(3).forEach(System.out::println); //跳过前3个
list.stream().skip(3).limit(2).forEach(System.out::println); //skip+limit实现分页
}
distinct:通过流中元素的 hashCode() 和 equals() 去除重复元素
/**
* distinct, 返回去重的Stream
*/
@Test
public void testDistinct() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
list.stream().distinct().collect(Collectors.toList()).forEach(System.out::println);
}
1.2 排序
sorted():自然排序,流中元素需实现Comparable接口
/**
* sorted: 返回一个排序的Stream
*/
@Test
public void testSorted() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
list.stream().distinct().sorted().collect(Collectors.toList()).forEach(System.out::println);
}
sorted(Comparator com):定制排序,自定义Comparator排序器
1.3 映射
map:接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
/**
* 遍历map集合,截取substring(2)开始的值
*/
@Test
public void testMap() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
Stream
stream.forEach(System.out::println);
}
forEach:ForEach流式遍历集合
/**
* forEach, ForEach流式遍历list集合
*/
@Test
public void testForEach() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.stream().forEach(System.out::println);
}
2. 流的终止操作
2.1 匹配、聚合操作
allMatch:接收一个 Predicate 函数,当流中每个元素都符合该断言时才返回true,否则返回false
/**
* allMatch:接收一个 Predicate 函数,当流中每个元素都符合该断言时才返回true,否则返回false
*/
@Test
public void testAllMatch() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
boolean b = list.stream()
.allMatch(e -> list.size() > 8);
System.out.println("b = " + b);
}
noneMatch:接收一个 Predicate 函数,当流中每个元素都不符合该断言时才返回true,否则返回false
/**
* noneMatch: 接收一个 Predicate 函数,当流中每个元素都不符合该断言时才返回true,否则返回false
*/
@Test
public void testNoneMatch() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
boolean b = list.stream().noneMatch(e->e.equals("张三"));
System.out.println("b = " + b);
}
anyMatch:接收一个 Predicate 函数,只要流中有一个元素满足该断言则返回true,否则返回false
/**
* anyMatch:接收一个 Predicate 函数,只要流中有一个元素满足该断言则返回true,否则返回false
*/
@Test
public void testAnyMatch() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
boolean b = list.stream().anyMatch(e -> e.equals("王二麻子"));
System.out.println("b = " + b);
}
findFirst:返回流中第一个元素
/**
* findFirst:返回流中第一个元素
*/
@Test
public void testFindFirsth() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
Optional
System.out.println("first = " + first.get());
}
findAny:返回流中的任意元素
/**
* findAny:返回流中第一个元素
*/
@Test
public void testFindAny() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
Optional
System.out.println("any = " + any.get());
}
count:返回流中元素的总个数
/**
* count,获取List集合的长度
*/
@Test
public void testCount() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
long count = list.stream().count();
System.out.println("count = " + count);
int size = list.size();
System.out.println("size = " + size);
}
2.2 Collector 工具库:Collectors
Collectors
Student s1 = new Student("aa", 10,1);
Student s2 = new Student("bb", 20,2);
Student s3 = new Student("cc", 10,3);
List
//装成list
List
//转成set
Set
//转成map,注:key不能相同,否则报错
Map
//字符串分隔符连接
String joinName = list.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)
//聚合操作
//1.学生总数
Long count = list.stream().collect(Collectors.counting()); // 3
//2.最大年龄 (最小的minBy同理)
Integer maxAge = list.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get(); // 20
//3.所有人的年龄
Integer sumAge = list.stream().collect(Collectors.summingInt(Student::getAge)); // 40jMVeul
//4.平均年龄
Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge)); // 13.333333333333334
// 带上以上所有方法
DoubleSummaryStatistics statistics = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
//分组
Map
//多重分组,先根据类型分再根据年龄分
Map
//分区
//分成两部分,一部分大于10岁,一部分小于等于10岁
Map
//规约
Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get(); //40
六、Stream操作代码
为了方便小伙伴们看到这篇博客时,学习的更加轻松,这里贴出源码,小伙伴们学习是可贴到IDEA运行查看Stream过滤筛选的结果,以此对Stream的流式操作更加熟悉。
package com.java8.example.chapter3;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @desc: Stream流式操作
* @author: cao_wencao
* @date: 2020-09-17 15:24
*/
public class TestStreamList {
/**
* list集合stream流式操作
*/
@Test
public void testStreamList() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.stream().filter(e -> e.startsWith("张")) //过滤所有姓张的人
.filter(e -> e.length() == 3) //过滤所有姓名是3个字的人
.forEach(System.out::println); //遍历打印,System.out::println表明System.out调用println打印方法
}
/**
* stream,获取各种集合的stream流
*/
@Test
public void testCollectionStream() {
List
Set
Map
String[] stringArray = {"张三三", "李四", "王五", "王五", "赵八",};
//通过list获取stream流
Stream
//通过set获取stream流
Stream
//通过map获取stream流
Stream
//通过array获取stream流
Stream
}
/**
* forEach, ForEach流式遍历list集合
*/
@Test
public void testForEach() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.stream().forEach(System.out::println);
}
/**
* filter 方法 , 返回符合过滤条件的值
*/
@Test
public void testFilter() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.stream().filter(e -> e.contains("张")).forEach(System.out::println);
}
/**
* 遍历map集合,截取substring(2)开始的值
*/
@Test
public void testMap() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
Stream
stream.forEach(System.out::println);
}
/**
* count,获取List集合的长度
*/
@Test
public void testCount() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
long count = list.stream().count();
System.out.println("count = " + count);
int size = list.size();
System.out.println("size = " + size);
}
/**
* limit 方法 ,返回前n个元素数据值组成的Stream。
*/
@Test
public void testLimit() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
list.stream().limit(3).forEach(System.out::println); //取前3个
}
/**
* skip方法 ,跳过前n个元素的中间流操作,返回剩下的值。
*/
@Test
public void testSkip() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
//list.stream().skip(3).forEach(System.out::println); //跳过前3个
list.stream().skip(3).limit(2).forEach(System.out::println); //skip+limit实现分页
}
/**
* collect,将流转化为集合
*/
@Test
public void testCollect() {
List
list.add("张三三");
list.add("李四");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
List
collect.forEach(System.out::println);
}
/**
* distinct, 返回去重的Stream
*/
@Test
public void testDistinct() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
list.stream().distinct().collect(Collectors.toList()).forEach(System.out::println);
}
/**
* sorted: 返回一个排序的Stream
*/
@Test
public void testSorted() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
list.stream().distinct().sorted().collect(Collectors.toList()).forEach(System.out::println);
}
/**
* anyMatch:接收一个 Predicate 函数,只要流中有一个元素满足该断言则返回true,否则返回false
*/
@Test
public void testAnyMatch() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
boolean b = list.stream().anyMatch(e -> e.equals("王二麻子"));
System.out.println("b = " + b);
}
/**
* noneMatch: 接收一个 Predicate 函数,当流中每个元素都不符合该断言时才返回true,否则返回false
*/
@Test
public void testNoneMatch() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
boolean b = list.stream().noneMatch(e->e.equals("张三"));
System.out.println("b = " + b);
}
/**
* allMatch:接收一个 Predicate 函数,当流中每个元素都符合该断言时才返回true,否则返回false
*/
@Test
public void testAllMatch() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
boolean b = list.stream()
.allMatch(e -> list.size() > 8);
System.out.println("b = " + b);
}
/**
* findFirst:返回流中第一个元素
*/
@Test
public void testFindFirsth() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
Optional
System.out.println("first = " + first.get());
}
/**
* findAny:返回流中第一个元素
*/
@Test
public void testFindAny() {
List
list.add("张三三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
list.add("孙七");
list.add("赵八");
list.add("王二麻子");
Optional
System.out.println("any = " + any.get());
}
/**
* max:返回流中元素最大值
*/
@Test
public void testMax() {
List
list.add(11);
list.add(22);
list.add(33);
list.add(44);
list.add(55);
list.add(66);
list.add(77);
list.add(88);
Integer integer = list.stream().max(Integer::compareTo).get();
System.out.println("integer = " + integer);
}
/**
* min:返回流中元素最小值
*/
@Test
public void testMin() {
List
list.add(11);
list.add(22);
list.add(33);
list.add(44);
list.add(55);
list.add(66);
list.add(77);
list.add(88);
Integer integer = list.stream().min(Integer::compareTo).get();
System.out.println("integer = " + integer);
list.stream().limit(1).limit(2).distinct().skip(3).filter(f -> f.equals(55)).forEach(System.out::println);
}
}
总结
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。
发表评论
暂时没有评论,来抢沙发吧~