Java中如何获取第一个非空值？

Question

Java 中是否存在与 SQL 的 COALESCE 函数等效的函数？也就是说，有没有办法返回几个变量的第一个非空值？

例如，

Double a = null;
Double b = 4.4;
Double c = null;

我想以某种方式有一个语句返回 a、b 和 c 的第一个非空值 - 在这种情况下，它将返回b，或4.4。 （类似于 sql 方法 - 返回 COALESCE(a,b,c)）。我知道我可以通过以下方式明确地做到这一点：

return a != null ? a : (b != null ? b : c)

但我想知道是否有任何内置的、可接受的函数来完成此操作。

Answer 1

Apache Commons Lang 3

ObjectUtils.defaultIfNull(T, T)

或效率较低但具有更多潜在值：

ObjectUtils .firstNonNull(T...)

Java 8 Stream

Stream.of(T...).filter(Objects::nonNull).findFirst().orElse(null)

Answer 2

不，没有。

您可以获得的最接近结果是：

public static <T> T coalesce(T ...items) {
    for (T i : items) if (i != null) return i;
    return null;
}

出于高效原因，您可以按如下方式处理常见情况：

public static <T> T coalesce(T a, T b) {
    return a == null ? b : a;
}
public static <T> T coalesce(T a, T b, T c) {
    return a != null ? a : (b != null ? b : c);
}
public static <T> T coalesce(T a, T b, T c, T d) {
    return ...
}

高效原因是每次调用该方法的 ... 版本时都会发生数组分配。这对于一大堆物品来说可能会造成浪费，我怀疑这将是常见的用法。

Answer 3

如果只有两个要测试的引用并且您使用的是 Java 8，则可以使用

Object o = null;
Object p = "p";
Object r = Optional.ofNullable( o ).orElse( p );
System.out.println( r );   // p

如果导入 static 可选，则表达式还不错。

不幸的是，您的“几个变量”的情况不可能使用可选方法。相反，你可以使用：

Object o = null;
Object p = null;
Object q = "p";

Optional<Object> r = Stream.of( o, p, q ).filter( Objects::nonNull ).findFirst();
System.out.println( r.orElse(null) );   // p

Answer 4

如果只需要检查两个变量并且您使用的是 Guava，则可以使用 MoreObjects.firstNonNull(T 第一，T 第二)。

Answer 5

根据 LES2 的答案，您可以通过调用重载函数来消除高效版本中的一些重复：

public static <T> T coalesce(T a, T b) {
    return a != null ? a : b;
}
public static <T> T coalesce(T a, T b, T c) {
    return a != null ? a : coalesce(b,c);
}
public static <T> T coalesce(T a, T b, T c, T d) {
    return a != null ? a : coalesce(b,c,d);
}
public static <T> T coalesce(T a, T b, T c, T d, T e) {
    return a != null ? a : coalesce(b,c,d,e);
}

Answer 6

这种情况需要一些预处理器。因为如果您编写一个选择第一个非空值的函数（静态方法），它将评估所有项目。如果某些项目是方法调用（可能是耗时的方法调用），则会出现问题。即使这些方法之前的任何项不为空，也会调用该方法。

应该使用像这样的一些函数

public static <T> T coalesce(T ...items) …

，但在编译成字节代码之前，应该有一个预处理器来找到这个“合并函数”的用法，并将其替换为像

a != null ? a : (b != null ? b : c)

更新2014-09-02：

感谢Java 8 和 Lambda 有可能在 Java 中实现真正的合并！包括关键的功能：仅在需要时才评估特定表达式 - 如果前面的表达式不为空，则不会评估后面的表达式（不调用方法，不执行计算或磁盘/网络操作）。

我写了一篇关于它的文章 Java 8：合并 – hledáme neNULLové hodnoty – （用捷克语编写，但我希望每个人都能理解代码示例）。

Answer 7

从 Java 9 开始，有内置的 Objects.requireNonNullElse 方法用于两个参数合并。这对我来说是最有用的。

Answer 8

您可以尝试以下操作：

public static <T> T coalesce(T... t) {
    return Stream.of(t).filter(Objects::nonNull).findFirst().orElse(null);
}

基于此响应

Answer 9

使用 Guava，您可以执行以下操作：

Optional.fromNullable(a).or(b);

如果 a 和 b 都为 null，则不会抛出 NPE。

编辑：我错了，它确实抛出了 NPE。 Michal Čizmazia 评论的正确方法是：

Optional.fromNullable(a).or(Optional.fromNullable(b)).orNull();

Answer 10

当您想避免评估某些昂贵的方法时，使用供应商怎么样？

像这样：

public static <T> T coalesce(Supplier<T>... items) {
for (Supplier<T> item : items) {
    T value = item.get();
    if (value != null) {
        return value;
    }
    return null;
}

然后像这样使用它：

Double amount = coalesce(order::firstAmount, order::secondAmount, order::thirdAmount)

您还可以使用重载方法来进行带有两个、三个或四个参数的调用。

此外，您还可以使用流，如下所示：

public static <T> T coalesce2(Supplier<T>... s) {
    return Arrays.stream(s).map(Supplier::get).filter(Objects::nonNull).findFirst().orElse(null);
}

Answer 11

为了完整性，“多个变量”的情况确实是可能的，尽管一点也不优雅。例如，对于变量 o、p 和 q：

Optional.ofNullable( o ).orElseGet(()-> Optional.ofNullable( p ).orElseGet(()-> q ) )

请注意使用 orElseGet() 来处理o、p 和 q 不是变量，而是表达式，要么成本高昂，要么具有不良副作用。

在最一般的情况下，coalesce(e[1],e[2],e[3],...,e[N])

coalesce-expression(i) ==  e[i]  when i = N
coalesce-expression(i) ==  Optional.ofNullable( e[i] ).orElseGet(()-> coalesce-expression(i+1) )  when i < N

这可能会生成过长的表达式。然而，如果我们试图进入一个没有 null 的世界，那么 v[i] 很可能已经是 Optional 类型了，而不是简单的String。在这种情况下，

result= o.orElse(p.orElse(q.get())) ;

或者在表达式的情况下：

result= o.orElseGet(()-> p.orElseGet(()-> q.get() ) ) ;

此外，如果您还转向函数声明式样式，则 o、p 和 q 应该是 Supplier 类型，如下所示：

Supplier<String> q= ()-> q-expr ;
Supplier<String> p= ()-> Optional.ofNullable(p-expr).orElseGet( q ) ;
Supplier<String> o= ()-> Optional.ofNullable(o-expr).orElseGet( p ) ;

然后整个 coalesce 简单地简化为 o.get()。

更具体的示例：

Supplier<Integer> hardcodedDefaultAge= ()-> 99 ;
Supplier<Integer> defaultAge= ()-> defaultAgeFromDatabase().orElseGet( hardcodedDefaultAge ) ;
Supplier<Integer> ageInStore= ()-> ageFromDatabase(memberId).orElseGet( defaultAge ) ;
Supplier<Integer> effectiveAge= ()-> ageFromInput().orElseGet( ageInStore ) ;

defaultAgeFromDatabase()、ageFromDatabase() 和 ageFromInput() 已经返回 Optional< /代码>，自然。

然后，如果我们对 Supplier 感到满意，则 coalesce 变为 effectiveAge.get() 或简单地 effectiveAge >。

恕我直言，在 Java 8 中，我们将看到越来越多的这样结构的代码，因为它同时非常不言自明且高效，尤其是在更复杂的情况下。

我确实怀念一个类 Lazy，它只调用一次 Supplier，但很懒惰，以及 Optional< 定义的一致性。 T>（即Optional-Optional 运算符，甚至Supplier> ）。

Answer 12

（与其他答案类似，但我想更详尽地描述 Guava 的 MoreObjects.firstNonNull()、Apache Commons Lang 3 ObjectUtils.firstNonNull() 和 Java 9 中引入了 >java.util.Objects.requireNonNullElse() 和 requireNonNullElseGet() 方法。）

这个答案很长 - 如果您想了解，请参阅最后的 TL;DR只需跳至摘要即可。

Guava MoreObjects.firstNonNull(T, T)

Guava 的 MoreObjects.firstNonNull(T, T) 是这样描述的。重要的部分是如果 {@code first} 和 {@code secondary} 都为 null，则@throws NullPointerException。此方法要求其中一个对象为非空

公共静态; TfirstNonNull（@CheckForNull T 第一，@CheckForNull T 第二）

返回两个给定参数中不为 null 的第一个（如果其中一个为 null），否则抛出 NullPointerException。

要查找可迭代对象中的第一个非空元素，请使用Iterables.find(iterable, Predicates.notNull())。对于可变参数，请使用 Iterables.find(Arrays.asList(a, b, c, ...), Predicates.notNull())，必要时进行静态导入。

注意：如果first表示为可选，则可以使用first.or(second)来完成。该方法还允许使用first.or(supplier) 对后备实例进行惰性评估。

Java 9 用户：改用 java.util.Objects.requireNonNullElse(first, secondary)`。

退货：
first 如果它是非null；否则，如果它是非null

，则为第二个

抛出：
java.lang.NullPointerException - 如果 first 和 second 均为 null

自：
18.0（自 3.0 起为 Objects.firstNonNull()）。

Apache Commons Lang 3 ObjectUtils.firstNonNull() 和 defaultIfNull(T, T)

ObjectUtils.firstNonNull(T...) 另一方面，对空值的处理更加“宽松”。如果所有值都为 null，那么该方法将简单地返回 null。对于某些情况，这可能更好（只要调用代码正确处理 null 返回值）。

另请注意，这需要一个 T... 可变参数，因此它可以与两个以上的参数一起使用，这与其他选项不同。

公共静态; TfirstNonNull(T...值)

返回数组中第一个不为null的值。如果所有值均为 null 或数组为 null 或空，则返回 null。

ObjectUtils.firstNonNull(null, null) = null
ObjectUtils.firstNonNull(null, "") = ""
ObjectUtils.firstNonNull(null, null, "") = ""
ObjectUtils.firstNonNull(null, "zz") = "zz"
ObjectUtils.firstNonNull("abc", *) = "abc"
ObjectUtils.firstNonNull(null, "xyz", *) = "xyz"
ObjectUtils.firstNonNull(Boolean.TRUE, *) = Boolean.TRUE
ObjectUtils.firstNonNull() = null

类型参数：
T - 数组的组件类型

参数：
values - 要测试的值，可以为 null 或空

退货：
值中非 null 的第一个值，如果没有非 null 值，则为 null

自：
3.0

ObjectUtils.defaultIfNull(T, T) 方法也存在，并且具有类似的 null 语义，但针对两者进行了稍微优化-参数场景。

JDK java.util.Objects.requireNonNullElse 和 requireNonNullElseGet 方法

Objects.requireNonNullElse(T, T) 具有以下语义。它与 Guava MoreObjects.firstNonNull() 方法非常接近，它应该是该方法的直接替代品。

公共静态; T requireNonNullElse (T obj, T defaultObj)

如果第一个参数非 null，则返回它，否则返回非 null 第二个参数。

类型参数：
T - 引用的类型

参数：
obj - 一个对象
defaultObj - 如果第一个参数为 null

，则返回一个非 null 对象

退货：
如果第一个参数为非 null，则为第二个参数；如果为非 null

，则为第二个参数

抛出：
NullPointerException - 如果 obj 均为 null 且 defaultObj 为 null

自：
9

最后，Objects.requireNonNullElseGet(T obj,Suppliersupplier) 方法。如果创建回退值是一项较繁重的操作，而您希望在 obj 为非 null 时避免这种操作，那么它会很有用。

公共静态; T requireNonNullElseGet(T obj,Suppliersupplier)

如果第一个参数非 null，则返回该参数，否则返回 supplier.get() 的非 null 值。< /p>

类型参数：
T - 第一个参数的类型和返回类型

参数：
obj - 一个对象
supplier - 如果第一个参数为 null

，则返回非 null 对象

退货：
如果为非 null，则为第一个参数；如果为非 null

，则为 supplier.get() 的值

抛出：
NullPointerException - 如果 obj 均为 null 并且 supplier 为 null 或supplier.get() 值为 null

自：
9

TL;DR

• 如果其中一个参数不能为 null，请使用 Objects.requireNonNullElse(T, T)
• 如果其中一个参数不能为 null 并且您想要使用 Supplier 进行后备（出于性能/GC 原因），请使用 Objects.requireNonNullElseGet(T obj，Supplier ; 供应商）
• 如果一个或两个参数可以为 null 并且 Apache Commons Lang 3 是可接受的依赖项，请使用 ObjectUtils.defaultIfNull( T, T)
• 如果您使用两个以上参数并且 Apache Commons Lang 3 没问题，请使用 ObjectUtils.firstNonNull(T...) 但请注意，null 值可能会使用此方法潜入。您可能希望将结果包装在 Objects.requireNonNullElse() 调用或其他一些 null 保护中，以避免运行时出现 NPE。

Answer 13

怎么样：

firstNonNull = FluentIterable.from(
    Lists.newArrayList( a, b, c, ... ) )
        .firstMatch( Predicates.notNull() )
            .or( someKnownNonNullDefault );

Java ArrayList 方便地允许空条目，并且无论要考虑的对象数量如何，该表达式都是一致的。 （在这种形式中，考虑的所有对象都必须属于同一类型。）

Answer 14

Object coalesce(Object... objects)
{
    for(Object o : object)
        if(o != null)
            return o;
    return null;
}