0. 强调‘面对对象编程’的封装类
java.util.Optional
java lambda 表达式的局部变量为什么必须是final修饰？
不得不说,这一块guava做了不少有意思的事情…
1. 走读源码的同时也会领悟到其中的用心
/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.util;
// 可以猜想到Optional 将接受来自 jdk8新特性的 lambda + stream api 的"馈赠"
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
// 总的来说,源码比较简单易懂,重点还是恰到好处的应用到项目中
// 可以帮助我们,更加轻易的摆脱"面对过程"的逻辑代码
// 这也是为什么guava将旧版本的Objects工具类的api基本上都给拿掉
public final class Optional<T> {
// 默认的、空白的、静态的 对象副本
private static final Optional<?> EMPTY = new Optional<>();
// "主角"实例
private final T value;
/********************** 实例构造的方式 **********************/
// 俩 私有的构造
private Optional() {this.value = null;}
/**
* @throws NullPointerException if value is null
*/
private Optional(T value) {this.value = Objects.requireNonNull(value);}
// 可以看出：Optional 仅允许我们以静态的方式构建
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
/**
* @throws NullPointerException if value is null
*/
public static <T> Optional<T> of(T value) {return new Optional<>(value);}
// 该构造方式允许入参为null
public static <T> Optional<T> ofNullable(T value) {return value == null ? empty() : of(value);}
/********************** 如果是null的话,采取的下一步？ **********************/
/**
* @throws NullPointerException if value is present and {@code consumer} is null
*/
public void ifPresent(Consumer<? super T> consumer) {if (value != null)consumer.accept(value);}
/**
* @throws NullPointerException if the predicate is null
*/
public Optional<T> filter(Predicate<? super T> predicate) {...}
/**
* @throws NullPointerException if the mapping function is null
*/
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {...}
/**
* @throws NullPointerException if the mapping function is null or returns a null result
*/
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {...}
public T orElse(T other) {return value != null ? value : other;}
/**
* @throws NullPointerException if value is not present and {@code other} is null
*/
public T orElseGet(Supplier<? extends T> other) {return value != null ? value : other.get();}
/**
* @throws X if there is no value present
* @throws NullPointerException if no value is present and {@code exceptionSupplier} is null
*/
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {...}
/********************** 三个重写自java.lang.Object的方法 **********************/
@Override
public boolean equals(Object obj) {...}
@Override
public int hashCode() {return Objects.hashCode(value);}
@Override
public String toString() {return value != null ? String.format("Optional[%s]", value) : "Optional.empty";}
/********************** 其他的一些不那么显眼的方法 **********************/
// 判断null的方法
public boolean isPresent() {return value != null;}
/**
* @throws NoSuchElementException if there is no value present
*/
public T get() {...}
}
2. simple code
import com.google.common.collect.Lists;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Collectors;
/**
* @Author: weng
* @Date: 2022/5/8
* @Description:
* 怎么说呢？
* 这个东西比较适合规范对象的构造吧
* 要贯彻到整个项目中的话,需得要看个人习惯吧,毕竟代码不可能是一个人写完的吧
*
* @see <a href="https://blog.csdn.net/qq_40794973/article/details/105182689">java.util.Optional</a>
* @see <a href="https://blog.csdn.net/u010741112/article/details/123135112">java lambda 表达式的局部变量为什么必须是final修饰？</a>
*/
public class TestOptional {
private static List<Integer> out;
public static void main(String[] args) {
final List<Integer> in = Arrays.asList(1,-6,null,218,23,1,null,-33);
// 我们需要做到：
// 如果out不为null -> 每个不为null的元素做一次绝对值运算
// 如果out为null -> 返回一个size=0的空集合
dealProblem(in);
Consumer c = list -> System.err.println(list);
c.accept(obtainOut());
}
private final static void dealProblem(final List<Integer> in){
Optional
.ofNullable(in)
.ifPresent(
inTmp -> {
// 编译器不允许lambda表达中对线程私有变量赋值
// 这虽然不会有安全问题
// 这是为了防止语义混乱的考虑
out = inTmp
.stream()
.filter(Objects::nonNull)
.map(Math::abs)
.collect(
Collectors.toList()
)
;
}
)
;
}
private final static List<Integer> obtainOut(){
return Optional
.ofNullable(out)
.orElse(Lists.newArrayList())
;
}
/*
out >
{"no":3,"name":"lorry"}
{"no":3,"name":"lorry"}
conclusion >
引用类型的传递的是其实是地址
实质是创建一个新的局部变量
并指向作为参数传递到方法的地址
public static void main(String[] args) {
Person p = new Person(3,"lorry");
System.out.println(p);
testProp(p);
System.err.println(p);
}
private static void testProp(Person p){
p = Person.builder().name("beal").no(3).build();
}
*/
}
