Optional源码阅读

2021-05-19

[toc]

Optional

Optional 是一个抽象类，其真正的实现类有两个Absent和Present

Imgur

其中Abseent代表的对象是空的，也就是null

Present代表的对象不是空的，也就是not null

在使用Optional.of()创建对象实例时，如果传入的对象为空，那么就会返回空指针异常，如果对象不为空就会创建一个Present对象

/*
 * Copyright (C) 2011 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.base;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.errorprone.annotations.DoNotMock;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;

import java.io.Serializable;
import java.util.Iterator;
import java.util.Set;

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * @param <T> the type of instance that can be contained. {@code Optional} is naturally covariant on
 *            this type, so it is safe to cast an {@code Optional<T>} to {@code Optional<S>} for any
 *            supertype {@code S} of {@code T}.
 * @author Kurt Alfred Kluever
 * @author Kevin Bourrillion
 * @since 10.0
 */


// Optional是一个抽象类,他的实现类有两个Absent和Present,其中Absent类代表null,Present类代表 not null
@DoNotMock("Use Optional.of(value) or Optional.absent()")
@GwtCompatible(serializable = true)
public abstract class Optional<T> implements Serializable {

    // Absent本身代表null,返回一个Absent对象也就是返回一个null
    public static <T> Optional<T> absent() {
        return Absent.withType();
    }

    /**
     * checkNotNull的实现如下，如果传入的对象为空，那么抛出空指针异常
     * 如果传入的对象不为空，返回原对象
     *
     * @CanIgnoreReturnValue public static <T extends @NonNull Object> T checkNotNull(T reference) {
     * if (reference == null) {
     * throw new NullPointerException();
     * }
     * return reference;
     * }
     */
    // 创建一个Present对象实例,如果对象为空直接抛出空指针异常
    public static <T> Optional<T> of(T reference) {
        return new Present<T>(checkNotNull(reference));
    }


    // Optional.fromNullable(T) 创建指定引用的Optional实例，若引用为null则返回Absent对象表示为null
    // 如果对象为空返回Absent对象，如果对象不为空，返回带有当前对象引用的Present对象
    public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
        return (nullableReference == null) ? Optional.<T>absent() : new Present<T>(nullableReference);
    }

    public static <T> @Nullable Optional<T> fromJavaUtil(
            java.util.@Nullable Optional<T> javaUtilOptional) {
        return (javaUtilOptional == null) ? null : fromNullable(javaUtilOptional.orElse(null));
    }

    public static <T> java.util.@Nullable Optional<T> toJavaUtil(
            @Nullable Optional<T> googleOptional) {
        return googleOptional == null ? null : googleOptional.toJavaUtil();
    }

    public java.util.Optional<T> toJavaUtil() {
        return java.util.Optional.ofNullable(orNull());
    }

    Optional() {
    }

    public abstract boolean isPresent();

    public abstract T get();

    public abstract T or(T defaultValue);

    public abstract Optional<T> or(Optional<? extends T> secondChoice);

    @Beta
    public abstract T or(Supplier<? extends T> supplier);

    public abstract @Nullable T orNull();

    public abstract Set<T> asSet();

    public abstract <V> Optional<V> transform(Function<? super T, V> function);

    @Override
    public abstract boolean equals(@Nullable Object object);

    @Override
    public abstract int hashCode();

    @Override
    public abstract String toString();

    @Beta
    public static <T> Iterable<T> presentInstances(
            final Iterable<? extends Optional<? extends T>> optionals) {
        checkNotNull(optionals);
        return new Iterable<T>() {
            @Override
            public Iterator<T> iterator() {
                return new AbstractIterator<T>() {
                    private final Iterator<? extends Optional<? extends T>> iterator =
                            checkNotNull(optionals.iterator());

                    @Override
                    protected T computeNext() {
                        while (iterator.hasNext()) {
                            Optional<? extends T> optional = iterator.next();
                            if (optional.isPresent()) {
                                return optional.get();
                            }
                        }
                        return endOfData();
                    }
                };
            }
        };
    }
    private static final long serialVersionUID = 0;
}

Absent实现类

Imgur


/*
 * Copyright (C) 2011 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.base;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.GwtCompatible;

import java.util.Collections;
import java.util.Set;

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of an {@link Optional} not containing a reference.
 */
@GwtCompatible
final class Absent<T> extends Optional<T> {
    static final Absent<Object> INSTANCE = new Absent<>();

    @SuppressWarnings("unchecked") // implementation is "fully variant"
    static <T> Optional<T> withType() {
        return (Optional<T>) INSTANCE;
    }

    private Absent() {
    }

    // 因为返回的是当前对象代表的是null,所以在判断对象是否不为空的时候返回的是false
    @Override
    public boolean isPresent() {
        return false;
    }

    // 因为当前的对象为空，所以get的时候返回非法状态异常
    @Override
    public T get() {
        throw new IllegalStateException("Optional.get() cannot be called on an absent value");
    }

    // 如果参数为空返回空指针异常,如果参数不为空返回参数值
    @Override
    public T or(T defaultValue) {
        return checkNotNull(defaultValue, "use Optional.orNull() instead of Optional.or(null)");
    }

    @SuppressWarnings("unchecked") // safe covariant cast
    @Override
    public Optional<T> or(Optional<? extends T> secondChoice) {
        return (Optional<T>) checkNotNull(secondChoice);
    }

    @Override
    public T or(Supplier<? extends T> supplier) {
        return checkNotNull(
                supplier.get(), "use Optional.orNull() instead of a Supplier that returns null");
    }

    // 返回Optional所包含的引用，若引用缺失，返回null,此处直接返回null
    @Override
    public @Nullable T orNull() {
        return null;
    }

    // 因为对象是空的所以直接返回空
    @Override
    public Set<T> asSet() {
        return Collections.emptySet();
    }

    @Override
    public <V> Optional<V> transform(Function<? super T, V> function) {
        checkNotNull(function);
        return Optional.absent();
    }

    @Override
    public boolean equals(@Nullable Object object) {
        return object == this;
    }

    @Override
    public int hashCode() {
        return 0x79a31aac;
    }

    @Override
    public String toString() {
        return "Optional.absent()";
    }

    private Object readResolve() {
        return INSTANCE;
    }

    private static final long serialVersionUID = 0;
}

Present实现类

Imgur

/*
 * Copyright (C) 2011 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.base;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.GwtCompatible;

import java.util.Collections;
import java.util.Set;

import org.checkerframework.checker.nullness.qual.Nullable;

// 这个是optional的实现类之一另一个是Absent

/**
 * Implementation of an {@link Optional} containing a reference.
 */
@GwtCompatible
final class Present<T> extends Optional<T> {
    private final T reference;

    Present(T reference) {
        this.reference = reference;
    }

    // 因为Present代表的对象不为空,所以返回true
    @Override
    public boolean isPresent() {
        return true;
    }

    // 因为Present代表的对象不为空,所以返回引用的对象
    @Override
    public T get() {
        return reference;
    }

    // 检查输入的参数是否为空,如果为空直接抛出空指针异常
    // 如果输入的参数不空,那么返回当前值的引用
    @Override
    public T or(T defaultValue) {
        checkNotNull(defaultValue, "use Optional.orNull() instead of Optional.or(null)");
        return reference;
    }

    @Override
    public Optional<T> or(Optional<? extends T> secondChoice) {
        checkNotNull(secondChoice);
        return this;
    }

    @Override
    public T or(Supplier<? extends T> supplier) {
        checkNotNull(supplier);
        return reference;
    }

    // 因为Present本身代表对象不空,所以直接返回引用的对象
    @Override
    public T orNull() {
        return reference;
    }

    // Set asSet() 返回Optional所包含引用的单例不可变集，
    // 如果引用存在，返回一个只有单一元素的集合，
    // 如果引用缺失，返回一个空集合。
    @Override
    public Set<T> asSet() {
        return Collections.singleton(reference);
    }

    @Override
    public <V> Optional<V> transform(Function<? super T, V> function) {
        return new Present<V>(
                checkNotNull(
                        function.apply(reference),
                        "the Function passed to Optional.transform() must not return null."));
    }

    @Override
    public boolean equals(@Nullable Object object) {
        if (object instanceof Present) {
            Present<?> other = (Present<?>) object;
            return reference.equals(other.reference);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return 0x598df91c + reference.hashCode();
    }

    @Override
    public String toString() {
        return "Optional.of(" + reference + ")";
    }

    private static final long serialVersionUID = 0;
}