Java 迭代方法列表并获取第一个非空响应

我有三个功能。所有三个功能的输入和输出参数相同

比方说

public void String function1(String abc, String xyz);
public void String function2(String abc, String xyz);
public void String function3(String abc, String xyz);

我有一个调用函数，它的实现方式如下

public void String callerFunction(String abc, String xyz) {
     String output = function1(String abc, String xyz);
     if(output == null) { 
          output = function2(String abc, String xyz);
     } 
     
     if(output == null) { 
          output = function3(String abc, String xyz);
     } 
     return output;
}

虽然这段代码有效，但编写这种逻辑的最佳方法是什么，我可能还想在将来添加一个新函数4

我想到的一个方法是

public interface functionInterface {
      public String fetchValue(String abc, String xyz);
} 

public class function1Class {
      public String fetchValue(String abc, String xyz) {
         // return some string.
      }
} 

public class function2Class {
      public String fetchValue(String abc, String xyz) {
         // return some string.
      }
} 

public class function3Class {
      public String fetchValue(String abc, String xyz) {
         // return some string.
      }
}


public void String callerFunction(String abc, String xyz) {
     List<functionInterface> flist = new Arraylist<>();
     functionInterface f1 = new function1Class();
     functionInterface f2 = new function1Class();
     functionInterface f3 = new function1Class();
     flist.add(f1);
     flist.add(f2);
     flist.add(f3);
     
     String output = null;
     for(functionInterface f : flist) { 
         output = f.fetchValue(abc, xyz);
         if(f.fetchValue(abc, xyz) != null) {
            return output;
         }
     }
     return output;
}

公共接口函数接口{
公共字符串获取值（字符串abc、字符串xyz）；
} 
公共类函数1类{
公共字符串获取值（字符串abc、字符串xyz）{
//返回一些字符串。
}
} 
公共类函数2类{
公共字符串获取值（字符串abc、字符串xyz）{
//返回一些字符串。
}
} 
公共类函数3类{
公共字符串获取值（字符串abc、字符串xyz）{
//返回一些字符串。
}
}
公共无效字符串调用函数（字符串abc、字符串xyz）{
List flist=new Arraylist（）；
functionInterface f1=新的function1Class（）；
functionInterface f2=新的function1Class（）；
functionInterface f3=新的function1Class（）；
flist.add（f1）；
flist.add（f2）；
flist.add（f3）；
字符串输出=null；
对于（函数接口f:flist）{
输出=f.fetchValue（abc，xyz）；
如果（f.fetchValue（abc，xyz）！=null）{
返回输出；
}
}
返回输出；
}

• 这是工程吗
• 有更好的方法来处理这个用例吗

coalesce（）函数是一个公共函数，它将计算所有传递这两个参数的函数

evaluateFunctions

迭代所有传递的函数并返回第一个非空结果。如果明天您有一个新函数4，只需将其添加到方法调用中即可

import java.util.function.BinaryOperator;

private String function1(String abc, String xyz) { return null;};
private String function2(String abc, String xyz) { return "2";};
private String function3(String abc, String xyz) {return "3";};

private String evaluateFunctions(String param1, String param2, BinaryOperator<String>... functions)
{
    for(BinaryOperator<String> fun:functions)
    {
        String value=fun.apply(param1, param2);
        if (value!=null)
            return value;
    }
    return null;
}

public String coalesce(String param1,String param2)
{
    return evaluateFunctions(param1,param2,
            (p1,p2)->function1(p1,p2),
            (p1,p2)->function2(p1,p2),
            (p1,p2)->function3(p1,p2));
}

---

BinaryOperator=BiFunction：两个参数和返回值都属于同一类型的函数。（谢谢@jaco0646）

您可以利用Java流的惰性来实现这一点。在以下情况下，当其中一个函数已返回NOTNULL结果时，不会调用所有函数：

导入java.util.array；
导入java.util.function.BinaryOperator；
班长{
公共静态void main（字符串[]args）{
二进制运算符f1、f2、f3；
f1=（a，b）->{
System.out.println（“调用f1”）；
//你的逻辑在这里
返回null；
};
f2=（a，b）->{
System.out.println（“调用f2”）；
//你的逻辑在这里
返回“222”；
};
f3=（a，b）->{
System.out.println（“调用f3”）；
//你的逻辑在这里
返回“333”；
};
字符串a=“aaa”；
字符串b=“bbb”；
String ret=Arrays.asList（f1、f2、f3）
.stream（）
.map（f->f.apply（a，b））
.filter（v->v！=null）
.findFirst（）
.get（）
系统输出打印项次（ret）；
}
}

通过将函数作为数组提供，您可以随时添加新函数

---

在上玩Java小提琴

谢谢分享，函数1（p1，p2）的含义是什么？我可以在谷歌上搜索什么来了解更多关于这个语法的信息，你可以用它来代替

BiFunction

@saurabhagarwal

（p1，p2）->function1（p1，p2）

，这是一个很好的例子。

private <T> T evaluateFunctions(T param1, T param2, BinaryOperator<T>... functions)
{
    for(BinaryOperator<T> fun:functions)
    {
        T value=fun.apply(param1, param2);
        if (value!=null)
            return value;
    }
    return null;
}