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());
}
}