从C#转Java：如何实现类似Kotlin的Option类型？

嘿，作为从C#转Java的开发者，我太懂你想把熟悉的Option模式搬过来的心情了！毕竟在Kotlin、Scala甚至C#里，这都是处理空值、避免NullPointerException的利器。Java虽然没有原生内置Option，但实现起来并不复杂，而且能完美适配你在C#里的使用习惯。

先上核心实现：Java 17+ 密封类版本 #

Java 17引入的密封类（sealed class）能完美复刻你提到的Kotlin风格Option，限制子类数量，保证类型安全：

public sealed interface Option<T> permits Option.None, Option.Some {
    // 静态工厂方法：创建None实例（单例）
    static <T> Option<T> none() {
        return (Option<T>) None.INSTANCE;
    }

    // 静态工厂方法：创建Some实例，强制非空检查
    static <T> Option<T> some(T value) {
        if (value == null) {
            throw new IllegalArgumentException("Some cannot hold null value");
        }
        return new Some<>(value);
    }

    // 判断是否为有值状态
    boolean isSome();

    // 默认方法：判断是否为无值状态
    default boolean isNone() {
        return !isSome();
    }

    // 获取值（None状态下抛出异常）
    T get();

    // None时返回默认值，对应C#的GetValueOrDefault
    default T getOrElse(T defaultValue) {
        return isSome() ? get() : defaultValue;
    }

    // None时通过Supplier获取默认值，延迟加载
    default T getOrElseGet(Supplier<? extends T> supplier) {
        return isSome() ? get() : supplier.get();
    }

    // None时抛出指定异常
    default <X extends Throwable> T getOrElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (isSome()) {
            return get();
        } else {
            throw exceptionSupplier.get();
        }
    }

    // 映射值，对应C#的Select方法
    default <U> Option<U> map(Function<? super T, ? extends U> mapper) {
        return isSome() ? some(mapper.apply(get())) : none();
    }

    // 扁平化映射，对应C#的SelectMany方法
    default <U> Option<U> flatMap(Function<? super T, ? extends Option<? extends U>> mapper) {
        if (isSome()) {
            @SuppressWarnings("unchecked")
            Option<U> result = (Option<U>) mapper.apply(get());
            return result;
        }
        return none();
    }

    // None的单例实现
    final class None implements Option<Object> {
        private static final None INSTANCE = new None();

        private None() {} // 私有构造，禁止外部实例化

        @Override
        public boolean isSome() { return false; }

        @Override
        public Object get() {
            throw new NoSuchElementException("Cannot get value from None");
        }
    }

    // Some的有值实现
    final class Some<T> implements Option<T> {
        private final T value;

        private Some(T value) { this.value = value; }

        @Override
        public boolean isSome() { return true; }

        @Override
        public T get() { return value; }
    }
}

兼容Java 8/11的版本（无密封类） #

如果你的项目还在用Java 17之前的版本，用抽象类+私有构造也能达到同样的效果：

public abstract class Option<T> {
    // 私有构造，禁止外部继承
    private Option() {}

    public static <T> Option<T> none() {
        return (Option<T>) None.INSTANCE;
    }

    public static <T> Option<T> some(T value) {
        if (value == null) {
            throw new IllegalArgumentException("Some cannot hold null value");
        }
        return new Some<>(value);
    }

    public abstract boolean isSome();

    public default boolean isNone() {
        return !isSome();
    }

    public abstract T get();

    public default T getOrElse(T defaultValue) {
        return isSome() ? get() : defaultValue;
    }

    public default T getOrElseGet(Supplier<? extends T> supplier) {
        return isSome() ? get() : supplier.get();
    }

    public default <X extends Throwable> T getOrElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (isSome()) {
            return get();
        } else {
            throw exceptionSupplier.get();
        }
    }

    public default <U> Option<U> map(Function<? super T, ? extends U> mapper) {
        return isSome() ? some(mapper.apply(get())) : none();
    }

    public default <U> Option<U> flatMap(Function<? super T, ? extends Option<? extends U>> mapper) {
        if (isSome()) {
            @SuppressWarnings("unchecked")
            Option<U> result = (Option<U>) mapper.apply(get());
            return result;
        }
        return none();
    }

    // None的单例内部类
    private static final class None extends Option<Object> {
        private static final None INSTANCE = new None();

        private None() {}

        @Override
        public boolean isSome() { return false; }

        @Override
        public Object get() {
            throw new NoSuchElementException("Cannot get value from None");
        }
    }

    // Some的有值内部类
    private static final class Some<T> extends Option<T> {
        private final T value;

        private Some(T value) { this.value = value; }

        @Override
        public boolean isSome() { return true; }

        @Override
        public T get() { return value; }
    }
}

使用示例（和C#习惯对齐） #

public class OptionDemo {
    public static void main(String[] args) {
        // 创建有值和无值的Option
        Option<String> greeting = Option.some("Hello from Java Option");
        Option<String> empty = Option.none();

        // 获取值或默认值，对应C#的GetValueOrDefault
        String result1 = greeting.getOrElse("Default message"); // "Hello from Java Option"
        String result2 = empty.getOrElse("Default message"); // "Default message"

        // 映射操作，对应C#的Select
        Option<Integer> greetingLength = greeting.map(String::length); // Some(26)

        // 扁平化映射，对应C#的SelectMany
        Option<String> upperGreeting = greeting.flatMap(s -> Option.some(s.toUpperCase())); // Some("HELLO FROM JAVA OPTION")
    }
}

和.NET Option/Nullable的核心差异 #

1. 空值安全的强制程度：
   • .NET的Nullable<T>（值类型）和可空引用类型（NRT）是编译时检查，运行时还是可能出现null；而Java的Option是显式的运行时包装，完全避免了null的直接暴露，强制你处理无值情况。
2. 函数式API的适配：
   • C#的LINQ对Option的支持更成熟（比如Select、SelectMany的链式调用），但Java 8+的Lambda和Stream API也能完美配合我们实现的Option，风格一致。
3. 原生支持的时机：
   • C# 8.0+就有了NRT，而Java直到17才引入密封类让Option的实现更安全，之前的版本只能靠抽象类限制子类。

额外建议：用成熟第三方库（如果不想自己造轮子） #

如果不想自己实现Option，可以直接用Vavr（原Javaslang）这个函数式库，它的Option类型和C#的LanguageExt Option几乎一致，还附带了大量函数式工具类，能快速对齐你在C#里的开发习惯。

内容的提问来源于stack exchange，提问作者Michal Pawluk