Java不同的方法来处理如果为null则为new

Question

好的，我有一个有关处理null的问题。这个问题可能主要基于观点，因此我要问一下优缺点。

假设我有一个可以返回null或JSONArray的函数。我一直想要一个JSONArray，因此如果函数的结果为null，我希望它创建一个空的JSONArray。

目前，我有以下方法：

jsonArray = jsonArray==null?new JSONArray():jsonArray;

我喜欢这种方法，因为它只是一行，而且很清楚它的作用。但这确实引出我一个问题，这有效吗？我有一个想法，现在它可以jsonArray = jsonArray在不需要时执行。尽管这样做确实可以节省一跳，if (jsonArray == null)

不同方式处理null的优点是什么？

Answer 1

您是否看过Java 8的Optional课程？这是一个对象包装器，可让您以功能性方式处理null。

例如，如果您有一个public JSONArray getArray()始终要返回null以外的值的方法，则可以使用代码。使用Optional，它将变为：

public Optional<JSONArray> getArray() {
    // jsonArray comes from somewhere
    return Optional.ofNullable(jsonArray);
}

如果jsonArray为null，则可选参数为空；否则为null。在不为null的情况下，它将包含jsonArray。

然后，您可以将空检查替换为可选命令规定的行为。代替

JSONArray array = getArray();
if (array != null) {
    // do something
}

您将其替换为

getArray().ifPresent(array -> // do something);

这意味着您不需要创建空的JSONArrays，列表，集合，字符串或任何其他内容。如果包装的对象实际上为null，则从中返回singleton
Optional Optional.ofNullable，从而进一步减少了开销。

如果您仍然想采用经典方法，那也是可能的。由于if (option == null)应该始终求值为false（如果您返回null而不是Optional，那么您可能会遗漏要点！），您将使用if (option.isPresent())。

如果您未使用Java 8，则可以编写自己的Optional或使用第三方库（例如Guava）。

编辑：非Java 8解决方案

解决方案1

使用类似番石榴的东西-看一下http://docs.guava-
libraries.googlecode.com/git/javadoc/com/google/common/base/Optional.html

解决方案2

自己写！在此实现中Supplier，Consumer和Predicate是返回，接受或测试对象的接口。

public abstract class Option<T> implements Iterable<T> {

    private static final Option NONE = new None();

    private Option() {
        // no-op
    }

    public static <T> Option<T> of(T t) {
        return t == null ? NONE : new Some<T>(t);
    }

    public static <T> Option<T> empty() {
        return NONE;
    }

    public abstract T get();

    public abstract T orElse(T fallback);

    public abstract T orElse(Supplier<T> supplier);

    public abstract <E extends Exception> T orThrow(Supplier<E> exceptionSupplier) throws E;

    public abstract boolean isPresent();

    public abstract Option<T> filter(Predicate<T> predicate);

    public abstract void ifPresent(Consumer<T> consumer);

    public abstract <O> Option<O> ifPresent(Function<T, O> function);

    private static final class Some<T> extends Option<T> {

        private final T value;

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

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

        @Override
        public T orElse(final T fallback) {
            return value;
        }

        @Override
        public T orElse(final Supplier<T> supplier) {
            return value;
        }

        @Override
        public <E extends Exception> T orThrow(final Supplier<E> exceptionSupplier) throws E {
            return value;
        }

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

        @Override
        public Option<T> filter(final Predicate<T> predicate) {
            return predicate.test(value) ? this
                                         : NONE;
        }

        @Override
        public void ifPresent(final Consumer<T> consumer) {
            consumer.consume(value);
        }

        @Override
        public <O> Option<O> ifPresent(final Function<T, O> function) {
            return Option.of(function.apply(value));
        }

        @Override
        public Iterator<T> iterator() {
            return Collections.singletonList(value).iterator();
        }
    }

    private static final class None<T> extends Option<T> {
        @Override
        public T get() {
            throw new IllegalStateException("value not defined");
        }

        @Override
        public T orElse(final T fallback) {
            return fallback;
        }

        @Override
        public T orElse(final Supplier<T> supplier) {
            return supplier.get();
        }

        @Override
        public <E extends Exception> T orThrow(final Supplier<E> exceptionSupplier) throws E {
            throw exceptionSupplier.get();
        }

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

        @Override
        public Option<T> filter(final Predicate<T> predicate) {
            return this;
        }

        @Override
        public void ifPresent(final Consumer<T> consumer) {
            // no-op
        }

        @Override
        public <O> Option<O> ifPresent(final Function<T, O> function) {
            return NONE;
        }

        @Override
        public Iterator<T> iterator() {
            return Collections.<T>emptyList().iterator();
        }
    }
}