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

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

您是否看过Java 8的

Optional

课程？这是一个对象包装器，可让您以功能性方式处理null。

例如，如果您有一个

public JSonArraygetArray()

始终要返回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.googlepre.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();        }    }}