Optional容器

最新推荐文章于 2025-07-16 01:45:28 发布

原创最新推荐文章于 2025-07-16 01:45:28 发布 · 672 阅读

2 ·

CC 4.0 BY-SA版权

学习笔记专栏收录该内容

52 篇文章

订阅专栏

本文深入探讨了Java中的Optional类，一种避免空指针异常的有效手段。介绍了Optional的基本使用，包括创建实例、判断值是否存在、获取值及对值进行操作的方法。通过实例展示了Optional如何简化代码并提高程序的健壮性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用null 表示一个值不存在，现在Optional 可以更好的表达这个概念。并且可以避免空指针异常。
常用方法：
Optional.of(T t) : 创建一个Optional 实例
Optional.empty() : 创建一个空的Optional 实例
Optional.ofNullable(T t):若t 不为null,创建Optional 实例,否则创建空实例
isPresent() : 判断是否包含值
orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回s 获取的值
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
flatMap(Function mapper):与map 类似，要求返回值必须是Optional

package com.da;

import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

import org.junit.Test;
/*
 * 一、Optional 容器类：用于尽量避免空指针异常
 * 	Optional.of(T t) : 创建一个 Optional 实例
 * 	Optional.empty() : 创建一个空的 Optional 实例
 * 	Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 * 	isPresent() : 判断是否包含值
 * 	orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
 * 	orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 * 	map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 * 	flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 */
public class OptionalTest {

	@Test
	public void test1() {
		String value = null;
		System.out.println(Optional.ofNullable(value).map(String::toUpperCase).orElse("NONE"));

		value = "asdZXC";
		System.out.println(Optional.ofNullable(value).map(String::toUpperCase).map(String::toLowerCase).orElse("NONE"));
	}

	@Test
	public void test2() {
		String value = null;
		System.out.println(Optional.ofNullable(value).orElse("null"));

		System.out.println(Optional.ofNullable(value).orElse("ccc"));
	}

	private Optional<Double> squareRoot(Double x) {
		return x < 0 ? Optional.empty() : Optional.of(Math.sqrt(x));
	}

	public static Optional<Double> inverse(Double x) {
		return x == 0 ? Optional.empty() : Optional.of(1 / x);
	}

	// 那么我们可以这样计算反转值的平方根：
	@Test
	public void test3() {
		Optional.of(4.0).flatMap(OptionalTest::inverse).map(x -> this.squareRoot(x)).map(x -> {
			if (x.isPresent())
				return x.get() + 1;
			else
				return 0;
		}).ifPresent(System.out::println);

		Optional<Double> result = Optional.of(4.0).flatMap(OptionalTest::inverse).flatMap(x -> this.squareRoot(x));
		result.ifPresent(System.out::println);
	}

	@Test
	public void test4() {
		List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
		list.stream().filter(x -> x.compareTo("bcd") > 0).map(String::toUpperCase).forEach(System.out::println);
	}

	@Test
	public void test5() {
		List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
		
		long count = list.stream().filter(x -> x.compareTo("bcd") > 0).map(String::toUpperCase).count();
		System.out.println(count);
		ArrayList<String> collect = list.stream().filter(x -> x.compareTo("bcd") > 0).map(String::toUpperCase)
				.collect(Collectors.toCollection(ArrayList::new));
		collect.forEach(System.out::print);

	}

	@Test
	public void test6() {
		Instant start = Instant.now();

		int i = IntStream.rangeClosed(0, 100).reduce(0, (x, y) -> x - y);
		System.out.println(i);

		Long sum = LongStream.rangeClosed(0L, 500000000L).parallel().reduce(0L, Long::sum);

		System.out.println(sum);

		Instant end = Instant.now();

		System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());

	}
}