返回第一个非空值

Question

我有很多功能：

String first(){}
String second(){}
...
String default(){}

每个都可以返回一个空值，默认值除外。 每个函数可以采用不同的参数。例如，第一个可以不带参数，第二个可以带一个字符串，第三个可以带三个参数，等等。我想做的是这样的：

ObjectUtils.firstNonNull(first(), second(), ..., default());

问题在于，由于函数调用，this 会进行急切评估。在第二个函数之后说，我想提前退出哪里（因为函数调用可能很昂贵，想想 API 调用等）。在其他语言中，您可以执行类似的操作：

return first() || second() || ... || default()

在 Java 中，我知道我可以执行以下操作：

String value;
if (value = first()) == null || (value = second()) == null ...
return value;

由于所有 == null 检查，IMO 的可读性不太好。ObjectUtils.firstNonNull() 首先创建一个集合，然后进行迭代，只要函数被延迟评估就可以了。

建议？ （除了做一堆ifs）

Answer 1

上面的例子似乎太长了，不能只在 2 个变量之间进行选择，我会选择这样的东西（除非你有更长的变量列表可供选择）：

Optional.ofNullable(first).orElse(Optional.ofNullable(second).orElse(default));

Answer 2

如果你想把它打包成一个实用方法，你必须把每个函数打包成一个延迟执行的东西。也许是这样的：

public interface Wrapper<T> {
    T call();
}

public static <T> T firstNonNull(Wrapper<T> defaultFunction, Wrapper<T>... funcs) {
    T val;
    for (Wrapper<T> func : funcs) {
       if ((val = func.call()) != null) {
           return val;
       }
    }
    return defaultFunction.call();
}

您可以使用java.util.concurrent.Callable 而不是定义自己的Wrapper 类，但是您必须处理声明Callable.call() 抛出的异常。

然后可以调用：

String value = firstNonNull(
    new Wrapper<>() { @Override public String call() { return defaultFunc(); },
    new Wrapper<>() { @Override public String call() { return first(); },
    new Wrapper<>() { @Override public String call() { return second(); },
    ...
);

在 Java 8 中，正如@dorukayhan 指出的那样，您可以不用定义自己的 Wrapper 类，而只需使用 Supplier 接口。此外，使用 lambda 可以更干净地完成调用：

String value = firstNonNull(
    () -> defaultFunc(),
    () -> first(),
    () -> second(),
    ...
);

您还可以（正如@Oliver Charlesworth 建议的那样）使用方法引用作为 lambda 表达式的简写：

String value = firstNonNull(
    MyClass::defaultFunc,
    MyClass::first,
    MyClass::second,
    ...
);

对于哪个更具可读性，我有两种看法。

或者，您可以使用许多其他答案提出的流式解决方案之一。

Answer 3

只需创建一个具有这样一个函数的类：

class ValueCollector {
  String value;
  boolean v(String val) { this.value = val; return val == null; }
}

ValueCollector c = new ValueCollector();
if c.v(first()) || c.v(second()) ...
return c.value;

Answer 4

这可以通过Suppliers 流非常干净地完成。

Optional<String> result = Stream.<Supplier<String>> of(
     () -> first(), 
     () -> second(),
     () -> third() )
  .map( x -> x.get() )
  .filter( s -> s != null)
  .findFirst(); 

这样做的原因是尽管看起来，整个执行是由findFirst() 驱动的，它从filter() 中拉取一个项目，它懒惰地从map() 中拉取项目，它调用get() 来处理每个拉取。当一项通过过滤器时，findFirst() 将停止从流中拉取，因此后续供应商将不会调用get()。

虽然我个人发现声明式 Stream 风格更简洁、更具表现力，但如果你不这样做，你就必须使用 Stream 来处理 Suppliers喜欢的风格：

Optional<String> firstNonNull(List<Supplier<String>> suppliers {
    for(Supplier<String> supplier : suppliers) {
        String s = supplier.get();
        if(s != null) {
            return Optional.of(s);
        }
    }
    return Optional.empty();
}

应该很明显，如果您用尽列表中的选项，您可以同样返回 String，而不是返回 String，或者返回 null (yuk)、默认字符串，或者抛出异常。

Answer 5

String s = Stream.<Supplier<String>>of(this::first, this::second /*, ... */)
                 .map(Supplier::get)
                 .filter(Objects::nonNull)
                 .findFirst()
                 .orElseGet(this::defaultOne);

它在第一个非空值上停止，否则设置从defaultOne 返回的值。只要你保持顺序，你就是安全的。当然这需要 Java 8 或更高版本。

它在第一次出现非空值时停止的原因是Stream 处理每个步骤的方式。 map 是 intermediate operation，filter 也是。另一边的findFirst 是short-circuiting terminal operation。所以它继续下一个元素，直到一个匹配过滤器。如果没有元素匹配，则返回一个空的可选项，因此调用orElseGet-supplier。

this::first 等只是方法引用。如果它们是静态的，请将其替换为 YourClassName::first 等。

如果您的方法的签名不同，以下是一个示例：

String s = Stream.<Supplier<String>>of(() -> first("takesOneArgument"),
                                       () -> second("takes", 3, "arguments")
                                   /*, ... */)
                 .map(Supplier::get)
                 .filter(Objects::nonNull)
                 .findFirst()
                 .orElseGet(this::defaultOne);

请注意，Supplier 仅在您对其调用 get 时进行评估。这样你就会得到你的惰性评估行为。您的供应商 lambda 表达式中的方法参数必须是最终的或有效的最终。

Answer 6

如果您使用的是 java 8，则可以将这些函数调用转换为 lambda。

public static<T> T firstNonNull(Supplier<T> defaultSupplier, Supplier<T>... funcs){
    return Arrays.stream(funcs).filter(p -> p.get() != null).findFirst().orElse(defaultSupplier).get();
}

如果您不想要通用实现并且仅将其用于Strings，请继续将T 替换为String：

public static String firstNonNull(Supplier<String> defaultSupplier, Supplier<String>... funcs){
    return Arrays.stream(funcs).filter(p -> p.get() != null).findFirst().orElse(defaultSupplier).get();
}

然后这样称呼它：

firstNonNull(() -> getDefault(), () -> first(arg1, arg2), () -> second(arg3));

附： btw default 是保留关键字，因此不能将其用作方法名称:)

编辑：好的，最好的方法是返回 Optional，然后你不需要单独传递默认供应商：

@SafeVarargs
public static<T> Optional<T> firstNonNull(Supplier<T>... funcs){
    return Arrays.stream(funcs).filter(p -> p.get() != null).map(s -> s.get()).findFirst();
}

Answer 7

它不可读，因为您正在处理一堆单独的函数，这些函数彼此之间没有任何形式的联系。当您尝试将它们放在一起时，显然缺乏方向。

不如试试

 public String getFirstValue() {
      String value;
      value = first();
      if (value != null) return value;
      value = second();
      if (value != null) return value;
      value = third();
      if (value != null) return value;
      ...
      return value;
 }

会很长吗？大概。但是您在对您的方法不友好的界面上应用代码。

现在，如果您可以更改界面，您可能会使界面更友好。一个可能的示例是将步骤设置为“ValueProvider”对象。

public interface ValueProvider {
    public String getValue();
}

然后你可以像这样使用它

public String getFirstValue(List<ValueProvider> providers) {
    String value;
    for (ValueProvider provider : providers) {
       value = provider.getValue();
       if (value != null) return value;
    }
    return null;
}

还有其他各种方法，但它们需要重组代码以更加面向对象。请记住，仅仅因为 Java 是一种面向对象的编程语言，这并不意味着它将始终以面向对象的方式使用。 first()...last() 方法列表非常不面向对象，因为它没有模拟List。即使方法名称具有表达性，List 上的方法也可以轻松与for 循环和Iterators 等工具集成。

Answer 8

您可以通过反射来完成此操作：

public Object getFirstNonNull(Object target, Method... methods) {
    Object value = null;
    for (Method m : methods) {
        if ( (value = m.invoke(target)) != null) {
            break;
        }
    }
    return value;
}