Java基础(二十六)：Stream流及Optional类

冬天vs不冷

发布于 2025-01-20 21:06:17

20500

代码可运行

文章被收录于专栏：springbootspringboot

运行总次数：0

代码可运行

Java基础系列文章

Java基础(一)：语言概述	Java基础(二)：原码、反码、补码及进制之间的运算	Java基础(三)：数据类型与进制	Java基础(四)：逻辑运算符和位运算符
Java基础(五)：流程控制语句	Java基础(六)：数组	Java基础(七)：面向对象编程	Java基础(八)：封装、继承、多态性
Java基础(九)：Object 类的使用	Java基础(十)：关键字static、代码块、关键字final	Java基础(十一)：抽象类、接口、内部类	Java基础(十二)：枚举类
Java基础(十三)：注解(Annotation)	Java基础(十四)：包装类	Java基础(十五)：异常处理	Java基础(十六)：String的常用API
Java基础(十七)：日期时间API	Java基础(十八)：java比较器、系统相关类、数学相关类	Java基础(十九)：集合框架	Java基础(二十)：泛型
Java基础(二十一)：集合源码	Java基础(二十二)：File类与IO流	Java基础(二十三)：反射机制	Java基础(二十四)：网络编程
Java基础(二十五)：Lambda表达式、方法引用、构造器引用	Java基础(二十六)：Stream流及Optional类	关于字符集（彻底搞清楚一个中文占几个字节？）

一、Stream介绍

1、什么是Stream

Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列
Stream和Collection集合的区别
- Collection是一种静态的内存数据结构，讲的是数据；主要面向内存，存储在内存中
- Stream是有关计算的，讲的是计算；面向CPU，通过CPU实现计算

2、Stream特点

Stream自己不会存储元素
Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的
- 这意味着他们会等到需要结果的时候才执行
- 即一旦执行终止操作，就执行中间操作链，并产生结果
Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了

3、Stream的操作三个步骤

创建 Stream
- 一个数据源（如：集合、数组），获取一个流
中间操作
- 每次处理都会返回一个持有结果的新Stream
- 即中间操作的方法返回值仍然是Stream类型的对象
- 因此中间操作可以是个操作链，可对数据源的数据进行n次处理
- 但是在终结操作前，并不会真正执行
终止操作(终端操作)
- 终止操作的方法返回值类型就不再是Stream了
- 因此一旦执行终止操作，就结束整个Stream操作了
- 一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream

二、创建Stream实例

1、通过集合创建Stream

Java8中的Collection接口被扩展，提供了两个获取流的方法：
- default Stream<E> stream() : 返回一个顺序流
- default Stream<E> parallelStream() : 返回一个并行流

@Test
public void test01(){
	List<String> list = Arrays.asList("a", "b", "c", "d");
	//创建顺序流（顺序执行）
	Stream<String> stream = list.stream();
	//创建并行流（多线程并行执行，速度快）
	Stream<String> parallelStream = list.parallelStream();
}

2、通过数组创建Stream

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
- public static <T> Stream<T> stream(T[] array): 返回一个流
- public static IntStream stream(int[] array)
- public static LongStream stream(long[] array)
- public static DoubleStream stream(double[] array)

@Test
public void test02(){
    String[] arr = {"hello","world"};
    Stream<String> stream = Arrays.stream(arr); 
}

@Test
public void test03(){
    int[] arr = {1,2,3,4,5};
    IntStream stream = Arrays.stream(arr);
}

3、通过Stream的of()创建Stream

可以调用Stream类静态方法 of(), 通过显示值创建一个流
它可以接收任意数量的参数
- public static<T> Stream<T> of(T… values) : 返回一个流

@Test
public void test04(){
    Stream<Integer> stream = Stream.of(1,2,3,4,5);
    stream.forEach(System.out::println);
}

4、创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流
- public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
- public static<T> Stream<T> generate(Supplier<T> s)

@Test
public void test05() {
	// 迭代累加，获取前五个
	Stream<Integer> stream = Stream.iterate(1, x -> x + 2);
	stream.limit(5).forEach(System.out::println);

    System.out.println("**********************************");
    
	// 一直生成随机数，获取前五个
	Stream<Double> stream1 = Stream.generate(Math::random);
	stream1.limit(5).forEach(System.out::println);
}

输出结果：

1
3
5
7
9
**********************************
0.1356905695577818
0.33576714141304886
0.7325647295361851
0.29218866245097375
0.24849848127040652

三、Stream中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理
而在终止操作时一次性全部处理，称为“惰性求值”

准备测试数据

// @Data 注在类上，提供类的get、set、equals、hashCode、toString等方法
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
	// id
	private int id;
	// 名称
	private String name;
	// 年龄
	private int age;
	// 工资
	private double salary;
}

public class EmployeeData {
	public static List<Employee> getEmployees(){
		List<Employee> list = new ArrayList<>();
		list.add(new Employee(1001, "马化腾", 34, 6000.38));
		list.add(new Employee(1002, "马云", 2, 19876.12));
		list.add(new Employee(1003, "刘强东", 33, 3000.82));
		list.add(new Employee(1004, "雷军", 26, 7657.37));
		list.add(new Employee(1005, "李彦宏", 65, 5555.32));
		list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
		list.add(new Employee(1007, "任正非", 26, 4333.32));
		list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
		return list;
	}
}

1、筛选（filter）

查询员工表中薪资大于7000的员工信息

// 获取员工集合数据
List<Employee> employeeList = EmployeeData.getEmployees();
Stream<Employee> stream = employeeList.stream();
stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out::println);

2、截断（limit）

获取员工集合数据的前十个员工信息

employeeList.stream().limit(10).forEach(System.out::println);

3、跳过（skip）

返回一个删除前五个员工信息的数据，与limit(n)互补

employeeList.stream().skip(5).forEach(System.out::println);

手动分页（current：当前页 size：每页条数）

List<Employee> employeeList = employeeList.stream()
	.skip((long) (current - 1) * size).limit(size)
	.collect(Collectors.toList());

4、去重（distinct）

通过流所生成元素的hashCode()和equals()去除重复元素
需要重写hashCode和equals方法，否则不能去重

employeeList.add(new Employee(1009, "马斯克", 40, 12500.32));
employeeList.add(new Employee(1009, "马斯克", 40, 12500.32));
employeeList.add(new Employee(1009, "马斯克", 40, 12500.32));
employeeList.add(new Employee(1009, "马斯克", 40, 12500.32));

employeeList.stream().distinct().forEach(System.out::println);

5、映射（map/flatMap/mapToInt）

map：获取员工姓名长度大于3的员工的姓名

//方式1：Lambda表达式
employeeList.stream().map(emp -> emp.getName())
        .filter(name -> name.length() > 3).forEach(System.out::println);
//方式2：方法引用第三种 类 :: 实例方法名
employeeList.stream().map(Employee::getName)
        .filter(name -> name.length() > 3).forEach(System.out::println);

flatMap：当处理嵌套集合时，可以使用flatMap将嵌套集合展平成一个新的Stream

List<List<Integer>> nestedList = Arrays.asList(
        Arrays.asList(1, 2, 3),
        Arrays.asList(4, 5, 6),
        Arrays.asList(7, 8, 9)
);

nestedList.stream()
        .flatMap(item -> item.stream())
        .forEach(System.out::println);

mapToInt：将流中每个元素映射为int类型

// 获取名字长度的总和
List<String> list1 = Arrays.asList("Apple", "Banana", "Orange", "Grapes");
IntStream intstream = list1.stream().mapToInt(String::length);
int sum = intstream.sum();

mapToDouble：将流中每个元素映射为Double类型
mapToLong：将流中每个元素映射为Long类型

6、排序（sorted）

sorted()：自然排序(从小到大)，流中元素需实现Comparable接口，否则报错

//sorted() 自然排序-升序
Integer[] arr = new Integer[]{345,3,64,3,46,7,3,34,65,68};
String[] arr1 = new String[]{"GG","DD","MM","SS","JJ"};

Arrays.stream(arr).sorted().forEach(System.out::println);
Arrays.stream(arr1).sorted().forEach(System.out::println);

//sorted() 自然排序-降序
Arrays.stream(arr).sorted(Comparator.reverseOrder()).forEach(System.out::println);
Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);

//因为Employee没有实现Comparable接口，所以报错！
employeeList.stream().sorted().forEach(System.out::println);

sorted(Comparator com)：Comparator排序器自定义排序

// 根据工资自然排序（从小到大）
employeeList.stream().sorted(Comparator.comparing(Employee::getSalary))
                .forEach(System.out::println);
// 根据工资倒序（从大到小）  
employeeList.stream().sorted(Comparator.comparing(Employee::getSalary).reversed())
                .forEach(System.out::println);

7、peek 和 forEach

相同点：peek和forEach都是遍历流内对象并且对对象进行一定的操作
不同点：forEach返回void结束Stream操作，peek会继续返回Stream对象

employeeList.stream()
        .map(Employee::getName)
        .peek(System.out::println)
        .filter(name -> name.length() > 3)
        .forEach(System.out::println);

四、Stream终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void
流进行了终止操作后，不能再次使用

1、匹配（allMatch/anyMatch/noneMatch）

allMatch(Predicate p)：检查是否匹配所有元素
是否所有的员工的年龄都大于18

boolean allMatch = employeeList.stream().allMatch(emp -> emp.getAge() > 18);

anyMatch(Predicate p)：检查是否至少匹配一个元素
是否存在年龄大于18岁的员工

boolean anyMatch = employeeList.stream().anyMatch(emp -> emp.getAge() > 18);

noneMatch(Predicate p)：检查是否没有匹配所有元素
是不是没有年龄大于18岁的员工，没有返回true，存在返回false

boolean noneMatch = employeeList.stream().noneMatch(emp -> emp.getAge() > 18);

2、查找（findFirst/findAny）

findFirst()：返回第一个元素

Optional<Employee> first = employeeList.stream().findFirst();
Employee employee = first.get();

findAny()：返回当前流中的任意元素

Optional<Employee> any = employeeList.stream().findAny();
Employee employee = any.get();

ps：集合中数据为空，会抛异常No value present，后面会将Optional类的空值处理

3、聚合（max/min/count）

max(Comparator c)：返回流中最大值，入参与排序sorted的比较器一样，必须自然排序
返回最高工资的员工

Optional<Employee> max = employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary));
Employee employee = max.get();

min(Comparator c)：返回流中最小值，入参与排序sorted的比较器一样，必须自然排序
返回最低工资的员工

Optional<Employee> min = employeeList.stream().min(Comparator.comparingDouble(Employee::getSalary));
Employee employee = min.get();

count()：返回流中元素总数
返回所有工资大于7000的员工的个数

long count = employeeList.stream().filter(emp -> emp.getSalary() > 7000).count();

4、归约（reduce）

reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回 Optional<T>

// 计算1-10的自然数的和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Optional<Integer> reduce6 = list.stream().reduce(Integer::sum);
Integer sum = reduce6.get();

// 计算公司所有员工工资的总和
Optional<Double> reduce7 = employeeList.stream().map(Employee::getSalary).reduce(Double::sum);
Double aDouble = reduce7.get();

reduce(T identity, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回 T
T identity：累加函数的初始值
不需要先获取Optional再get()，直接可以获取结果，推荐使用

// 计算1-10的自然数的和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer reduce1 = list.stream().reduce(0, (x1, x2) -> x1 + x2);
Integer reduce2 = list.stream().reduce(0, (x1, x2) -> Integer.sum(x1, x2));
Integer reduce3 = list.stream().reduce(0, Integer::sum);
// 计算1-10的自然数的乘积
Integer reduce4 = list.stream().reduce(1, (x1, x2) -> x1 * x2);

// 计算公司所有员工工资的总和
Double reduce5 = employeeList.stream().map(Employee::getSalary).reduce(0.0, Double::sum);

5、收集(collect)

collect(Collector c)：将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)
Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，如下

5.1、归集（toList/toSet/toMap）

toList()：把流中元素收集到List
获取所有员工姓名集合

List<String> nameList1 = employeeList.stream().map(Employee::getName).collect(Collectors.toList());
// jdk16以后，collect(Collectors.toList())可以简写为.toList()
List<String> nameList2 = employeeList.stream().map(Employee::getName).toList();

toSet()：把流中元素收集到Set
获取所有员工年龄set集合，可以去重

Set<Integer> ageList = employeeList.stream().map(Employee::getAge).collect(Collectors.toSet());

toMap()：把流中元素收集到Map
Function.identity()：t -> t，相当于参数是什么，返回什么

如下如果key重复，会抛异常java.lang.IllegalStateException: Duplicate key xxx

// key-名称 value-员工对象
Map<String, Employee> employeeNameMap = employeeList.stream()
        .collect(Collectors.toMap(Employee::getName, Function.identity()));
// key-名称 value-工资
Map<String, Double> nameSalaryMap = employeeList.stream()
        .collect(Collectors.toMap(Employee::getName, Employee::getSalary));

toMap的第三个参数则是key重复后如何操作value的内容
key重复可以只要旧的value数据，也可以新的value+旧的value等等

// key-名称 value-员工对象
Map<String, Employee> employeeNameMap = employeeList.stream()
        .collect(Collectors.toMap(Employee::getName, Function.identity(),(oldValue,newValue) -> oldValue));
// key-名称 value-工资
Map<String, Double> nameSalaryMap = employeeList.stream()
        .collect(Collectors.toMap(Employee::getName, Employee::getSalary,(oldValue,newValue) -> oldValue + newValue));

5.2、统计（counting/averaging/summing/maxBy/minBy）

counting()：计算流中元素的个数

Long count = employeeList.stream().collect(Collectors.counting());
// 相当于
Long count2 = employeeList.stream().count();

averagingInt：计算流中元素Integer属性的平均值
averagingDouble：计算流中元素Double属性的平均值
averagingLong：计算流中元素Long属性的平均值
返回值都是Double

Double aDouble = employeeList.stream().collect(Collectors.averagingInt(Employee::getAge));
Double bDouble = employeeList.stream().collect(Collectors.averagingDouble(Employee::getSalary));

summingInt：计算流中元素Integer属性的总和
summingDouble：计算流中元素Double属性的总和
summingLong：计算流中元素Long属性的总和

Integer count = employeeList.stream().collect(Collectors.summingInt(Employee::getAge));
Double total = employeeList.stream().collect(Collectors.summingDouble(Employee::getSalary));

maxBy()：计算流最大值
minBy()：计算流最小值

// 最大值
Optional<Employee> employee = employeeList.stream()
       .collect(Collectors.maxBy(Comparator.comparingDouble(Employee::getSalary)));
// 最小值
Optional<Employee> employee = employeeList.stream()
        .collect(Collectors.minBy(Comparator.comparingDouble(Employee::getSalary)));

summarizingInt()：汇总统计包括总条数、总和、平均数、最大值、最小值

IntSummaryStatistics summaryStatistics = employeeList.stream().collect(Collectors.summarizingInt(Employee::getAge));
System.out.println(summaryStatistics);// IntSummaryStatistics{count=8, sum=263, min=2, average=32.875000, max=65}

5.3、分组（partitioningBy/groupingBy）

partitioningBy()：根据true或false进行分区
将员工按薪资是否高于6000分组

Map<Boolean, List<Employee>> listMap = employeeList.stream()
        .collect(Collectors.partitioningBy(emp -> emp.getSalary() > 6000));

groupingBy()：根据某属性值对流分组，属性为K，结果为V
将员工年龄分组

Map<Integer, List<Employee>> collect = employeeList.stream()
        .collect(Collectors.groupingBy(Employee::getAge));

字符串集合获取每个字符串出现次数（用于查重）

List<String> strings = Arrays.asList("apple", "banana", "apple", "cherry", "banana", "date", "apple");
Map<String, Long> stringCountMap = strings.stream()
        .collect(Collectors.groupingBy(t -> t, Collectors.counting()));

将员工年龄分组，并统计数量

Map<Integer, Long> collect = employeeList.stream()
        .collect(Collectors.groupingBy(Employee::getAge, Collectors.counting()));

将员工按年龄分组，再汇总不同年龄的总金额

Map<Integer, Double> collect = employeeList.stream()
        .collect(Collectors.groupingBy(Employee::getAge, Collectors.summingDouble(Employee::getSalary)));

将员工按年龄分组，获取工资集合

Map<Integer, List<Double>> integerListMap = employeeList.stream()
        .collect(Collectors.groupingBy(Employee::getAge, 
                Collectors.mapping(Employee::getSalary, Collectors.toList())));

先按员工年龄分组，再按工资分组

Map<Integer, Map<Double, List<Employee>>> collect = employeeList.stream()
        .collect(Collectors.groupingBy(Employee::getAge, Collectors.groupingBy(Employee::getSalary)));

5.4、接合（joining）

List<String> list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("-"));
// 结果：A-B-C

五、并行流parallelStream

1、并行流原理介绍

对于并行流，其在底层实现中，是沿用了Java7提供的fork/join分解合并框架进行实现
fork根据cpu核数进行数据分块，join对各个fork进行合并

实现过程如下所示：

2、并行流和串行流对比

执行顺序

@Test
public void test1() {
    List<Integer> list = Lists.newArrayList();
    for (int i = 0; i < 5; i++) {
        list.add(i);
    }

    System.out.println("*****************************************");

    List<Integer> collect = list.stream().map(item -> {
        System.out.println("串行数据:" + item + ",线程名称:" + Thread.currentThread().getName());
        return item * 2;
    }).collect(Collectors.toList());

    System.out.println("*****************************************");

    List<Integer> collect1 = list.parallelStream().map(item -> {
        System.out.println("并行数据:" + item + ",线程名称:" + Thread.currentThread().getName());
        return item * 2;
    }).collect(Collectors.toList());
}

输出结果：串行保证顺序，并行多线程不能保证顺序

*****************************************
串行数据:0,线程名称:main
串行数据:1,线程名称:main
串行数据:2,线程名称:main
串行数据:3,线程名称:main
串行数据:4,线程名称:main
*****************************************
并行数据:2,线程名称:main
并行数据:0,线程名称:ForkJoinPool.commonPool-worker-3
并行数据:3,线程名称:ForkJoinPool.commonPool-worker-3
并行数据:4,线程名称:ForkJoinPool.commonPool-worker-2
并行数据:1,线程名称:ForkJoinPool.commonPool-worker-1

forEachOrdered保证执行顺序

@Test
public void test2() {
    List<Integer> list = Lists.newArrayList();
    for (int i = 0; i < 5; i++) {
        list.add(i);
    }

    System.out.println("*****************************************");

    list.stream().map(item -> {
        return item + "｜";
    }).forEach(o -> {
        System.out.println("forEach循环数据:" + o + ",线程名称:" + Thread.currentThread().getName());
    });

    System.out.println("*****************************************");

    list.parallelStream().map(item -> {
        return item + "｜";
    }).forEachOrdered(o -> {
        System.out.println("forEachOrdered循环数据:" + o + ",线程名称:" + Thread.currentThread().getName());
    });
}

输出结果：并行流forEachOrdered可以保证执行顺序

*****************************************
forEach循环数据:0｜,线程名称:main
forEach循环数据:1｜,线程名称:main
forEach循环数据:2｜,线程名称:main
forEach循环数据:3｜,线程名称:main
forEach循环数据:4｜,线程名称:main
*****************************************
forEachOrdered循环数据:0｜,线程名称:ForkJoinPool.commonPool-worker-3
forEachOrdered循环数据:1｜,线程名称:ForkJoinPool.commonPool-worker-1
forEachOrdered循环数据:2｜,线程名称:ForkJoinPool.commonPool-worker-1
forEachOrdered循环数据:3｜,线程名称:ForkJoinPool.commonPool-worker-1
forEachOrdered循环数据:4｜,线程名称:ForkJoinPool.commonPool-worker-1

执行效率

@Test
public void test3() {
    List<Integer> list = Lists.newArrayList();
    for (int i = 0; i < 1000000; i++) {
        list.add(i);
    }

    long l1 = System.currentTimeMillis();

    List<Integer> collect = list.stream().map(item -> {
        return item * 2;
    }).collect(Collectors.toList());

    System.out.println("串行流耗时:" + (System.currentTimeMillis() - l1) + "ms");
    long l2 = System.currentTimeMillis();

    List<Integer> collect1 = list.parallelStream().map(item -> {
        return item * 2;
    }).collect(Collectors.toList());
    System.out.println("并行流流耗时:" + (System.currentTimeMillis() - l2) + "ms");
}

输出结果：并行流明显高于串行

串行流耗时:17ms
并行流流耗时:81ms

六、Optional 类

Optional类内部结构（value为实际存储的值）

public final class Optional<T> {
    // 空Optional对象，value为null
    private static final Optional<?> EMPTY = new Optional<>();

    // 实际存储的内容
    private final T value;

    // 私有的构造
    private Optional() {
        this.value = null;
    }
    
	...
}

1、构建Optional对象

@Test
public void optionalTest(){
    Integer value1 = null;
    Integer value2 = 10;
    // 允许传递为null参数
    Optional<Integer> a = Optional.ofNullable(value1);
    // 如果传递的参数是null，抛出异常NullPointerException
    Optional<Integer> b = Optional.of(value2);
    // 空对象，value为null
    Optional<Object> c = Optional.empty();
}

2、获取value值，空值的处理

@Test
public void optionalTest() {
    Integer value1 = null;
    Optional<Integer> a = Optional.ofNullable(value1);
    System.out.println("value值是否为null:" + a.isPresent());
    System.out.println("获取value值,空报错空指针:" + a.get());
    System.out.println("获取value值,空返回默认值0:" + a.orElse(0));
    System.out.println("获取value值,空返回Supplier返回值:" + a.orElseGet(() -> 100));
    System.out.println("获取value值,空抛出异常:" + a.orElseThrow(() -> new RuntimeException("value为空")));
}

3、处理value值，空值不处理不报错

ifPresent方法内会判断不为空才操作

@Test
public void optionalTest() {
    Integer value1 = 10;
    Optional<Integer> a = Optional.ofNullable(value1);
    // 空不处理，非空则根据Consumer消费接口处理
    a.ifPresent(o -> System.out.println("ifPresent value值:" + o)); // 10
    // 空不处理，filter过滤
    a.filter(o -> o > 1).ifPresent(o -> System.out.println("filter value值:" + o)); // 10
    // 空不处理，map映射
    a.map(o -> o + 10).ifPresent(o -> System.out.println("map value值:" + o)); // 20
    // 空不处理，flatMap映射
    a.flatMap(o -> Optional.of(o + 20)).ifPresent(o -> System.out.println("flatMap value值:" + o)); // 30
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-09-27，如有侵权请联系 cloudcommunity@tencent.com 删除

数据