java 随笔 java.util.Optional

java.util.Optional
java lambda 表达式的局部变量为什么必须是final修饰？

gitee中的simple code

不得不说,这一块guava做了不少有意思的事情…

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 {
    
	// 默认的、空白的、静态的 对象副本
    private static final Optional EMPTY = new Optional<>();
	// "主角"实例
    private final T value;

	

    // 俩 私有的构造
    private Optional() {this.value = null;}
	
    private Optional(T value) {this.value = Objects.requireNonNull(value);}
	
	// 可以看出：Optional 仅允许我们以静态的方式构建
    public static Optional empty() {
        @SuppressWarnings("unchecked")
        Optional t = (Optional) EMPTY;
        return t;
    }

	
    public static  Optional of(T value) {return new Optional<>(value);}

	// 该构造方式允许入参为null
    public static  Optional ofNullable(T value) {return value == null ? empty() : of(value);}
	
	

    
    public void ifPresent(Consumer consumer) {if (value != null)consumer.accept(value);}

    
    public Optional filter(Predicate predicate) {...}

    
    public Optional map(Function mapper) {...}

    
    public Optional flatMap(Function> mapper) {...}

    public T orElse(T other) {return value != null ? value : other;}

    
    public T orElseGet(Supplier other) {return value != null ? value : other.get();}

    
    public  T orElseThrow(Supplier exceptionSupplier) throws X {...}

	

    @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;}
	
	
    public T get() {...}
}

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;



public class TestOptional {

    private static List out;

    public static void main(String[] args) {

        final List 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 in){

        Optional
                .ofNullable(in)
                .ifPresent(
                        inTmp -> {
                            // 编译器不允许lambda表达中对线程私有变量赋值
                            // 这虽然不会有安全问题
                            // 这是为了防止语义混乱的考虑
                            out = inTmp
                                    .stream()
                                    .filter(Objects::nonNull)
                                    .map(Math::abs)
                                    .collect(
                                            Collectors.toList()
                                    )
                            ;
                        }
                )
        ;
    }

    private final static List obtainOut(){
        return Optional
                .ofNullable(out)
                .orElse(Lists.newArrayList())
        ;
    }


}