Java 有没有更好的方法从多字符串数组中查找任何字符串

在下面的示例中，有一些预定义的字符串数组，我在下面的示例中提到过，现在我的要求是，如果每个数组中的boName prensents需要调用为特定自定义文件定义的方法。有没有其他方法可以避免多个for循环

public class MyClass {

    private static final String[] OTHER_CUSTOM_FIELD_RELATED_BO_NAME = { "A", "B", "C", "D", "E", "F", "G", "H" };
    private static final String[] TRANSACTION_CUSTOM_FIELD_RELATED_BO_NAME = { "A", "AB", "CD", "DE", "EG" };
    private static final String[] CRM_CUSTOM_FIELD_RELATED_BO_NAME = { "I", "J", "K", "L", "M" };
    private static final String[] ITEM_CUSTOM_FIELD_RELATED_BO_NAME = { "N", "O", "P", "Q" };
    private static final String[] ENTITY_CUSTOM_FIELD_RELATED_BO_NAME = { "AN", "ZY", "X", "P" };

    public static List<String> BusinessObjectDescribe(String boName) {
        List<String> fields = new ArrayList<String>();
        if (boName != null && !boName.isEmpty()) {
            for (String string : OTHER_CUSTOM_FIELD_RELATED_BO_NAME) {
                if (boName.equals(string)) {
                    fields.addAll(getOtherCustomFields());
                    break;
                }
            }

            for (String string : TRANSACTION_CUSTOM_FIELD_RELATED_BO_NAME) {
                if (boName.equals(string)) {
                    fields.addAll(getTransactionCustomFields());
                    break;
                }
            }

            for (String string : CRM_CUSTOM_FIELD_RELATED_BO_NAME) {
                if (boName.equals(string)) {
                    fields.addAll(getCRMCustomFields());
                    break;
                }
            }

            for (String string : ITEM_CUSTOM_FIELD_RELATED_BO_NAME) {
                if (boName.equals(string)) {
                    fields.addAll(getITEMCustomFields());
                    break;
                }
            }

            for (String string : ENTITY_CUSTOM_FIELD_RELATED_BO_NAME) {
                if (boName.equals(string)) {
                    fields.addAll(getEntityCustomFields());
                    break;
                }
            }

        }

        return fields;

    }

}

公共类MyClass{
私有静态最终字符串[]其他自定义字段相关名称={“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”}；
私有静态最终字符串[]事务\自定义\字段\相关\ BO \名称={“A”、“AB”、“CD”、“DE”、“EG”}；
私有静态最终字符串[]CRM_自定义_字段_相关_BO_名称={“I”、“J”、“K”、“L”、“M”}；
私有静态最终字符串[]项\自定义\字段\相关\ BO \名称={“N”、“O”、“P”、“Q”}；
私有静态最终字符串[]实体\自定义\字段\相关\ BO \名称={“AN”、“ZY”、“X”、“P”}；
公共静态列表BusinessObjectDescripte（字符串名称）{
列表字段=新的ArrayList（）；
if（boName！=null&！boName.isEmpty（））{
for（字符串字符串：其他\u自定义\u字段\u相关\u BO\u名称）{
if（boName.equals（string））{
addAll（getOtherCustomFields（））；
打破
}
}
for（字符串字符串：事务\自定义\字段\相关\ BO\名称）{
if（boName.equals（string））{
addAll（getTransactionCustomFields（））；
打破
}
}
for（字符串字符串：CRM\自定义\字段\相关\ BO\名称）{
if（boName.equals（string））{
addAll（getCRMCustomFields（））；
打破
}
}
for（字符串字符串：项目\自定义\字段\相关\ BO\名称）{
if（boName.equals（string））{
addAll（getITEMCustomFields（））；
打破
}
}
for（字符串字符串：实体\自定义\字段\相关\ BO\名称）{
if（boName.equals（string））{
addAll（getEntityCustomFields（））；
打破
}
}
}
返回字段；
}
}

如果您使用的是Java8，则可以利用功能接口的优势。只需创建一个新函数，将数组作为第一个参数，将suplier函数作为第二个参数。在suplier中，您可以传递有关add的逻辑。您需要多次调用该函数，而不是重复代码。

要进行搜索，可以在java-8中使用以下命令：

Arrays.stream(OTHER_CUSTOM_FIELD_RELATED_BO_NAME)
    .filter(e -> e.contains("A"))
    .findFirst();

这里我们将数组转换为流，然后应用过滤器。如果找到匹配项，它将返回元素，否则它将返回

null

。此外，

.findFirst（）

将在找到匹配项后立即停止搜索流

---

您可以使用相同的语法并根据需要搜索其他数组。

我将创建一个类来封装您在循环中执行的行为

class MyClass {
    class BoNameHandler {
        private Collection<String> applicableNames;
        private Supplier<Collection<String>> getter;
        BoNameHandler(String[] names, Supplier<Collection<String>> g) {
            applicableNames = Arrays.asList(names);
            getter = g;
        }
        void addIfApplicable(String boName, List<String> addTo) {
            if (applicableNames.stream().filter(boName::equals).findFirst().isPresent()) {
                addTo.addAll(getter.get());
            }
        }
    }
    List<BoNameHandler> handlers = new ArrayList<>();
    MyClass() {
        handlers.add(new BoNameHandler(OTHER_CUSTOM_FIELD_RELATED_BO_NAME, this::getOtherCustomFields));
        handlers.add(new BoNameHandler(TRANSACTION_CUSTOM_FIELD_RELATED_BO_NAME, this::getTransactionCustomFields));
        // and the others
    }
}

class-MyClass{
类BoNameHandler{
私人收藏申请表；
私人供应商getter；
BoNameHandler（字符串[]名称，供应商g）{
applicatablenames=Arrays.asList（名称）；
getter=g；
}
无效添加适用（字符串名称、列表添加到）{
if（applicatableNames.stream（）.filter（boName:：equals）.findFirst（）.isPresent（））{
addTo.addAll（getter.get（））；
}
}
}
列表处理程序=新的ArrayList（）；
MyClass（）{
add（新的BoNameHandler（其他自定义字段相关的BO名称，this:：getOtherCustomFields））；
add（新的BoNameHandler（事务\自定义\字段\相关\ BO \名称，this:：getTransactionCustomFields））；
//还有其他的
}
}

这将使您的代码减少到

public static List<String> BusinessObjectDescribe(String boName) {
    List<String> fields = new ArrayList<String>();
    for (BoNameHandler handler : handlers) {
        handler.addIfApplicable(boName, fields);
    }
    return fields;
}

公共静态列表BusinessObjectDescripte（字符串名称）{
列表字段=新的ArrayList（）；
for（BoNameHandler:handler）{
处理程序。可添加（boName，字段）；
}
返回字段；
}

---

我不知道你的方法是什么样子的，但是如果它们像bou名称一样固定，你也可以把它们放在一个

枚举中。
作为
集合，数学集合
{a，b，c}
，实际上是最逻辑的数据结构，用它吧

private static final Set<String> OTHER_CUSTOM_FIELD_RELATED_BO_NAME =
    Set.of( "A", "B", "C", "D", "E", "F", "G", "H" );
private static final Set<String> TRANSACTION_CUSTOM_FIELD_RELATED_BO_NAME =
    Set.of( "A", "AB", "CD", "DE", "EG" );
private static final Set<String> CRM_CUSTOM_FIELD_RELATED_BO_NAME =
    Set.of( "I", "J", "K", "L", "M" );
private static final Set<String> ITEM_CUSTOM_FIELD_RELATED_BO_NAME =
    Set.of( "N", "O", "P", "Q" );
private static final Set<String> ENTITY_CUSTOM_FIELD_RELATED_BO_NAME =
    Set.of( "AN", "ZY", "X", "P" );


public static List<String> BusinessObjectDescribe(String boName) {
    List<String> fields = new ArrayList<>();
    if (boName != null && !boName.isEmpty()) {
        if (OTHER_CUSTOM_FIELD_RELATED_BO_NAME.contains(boName)) {
            fields.addAll(getOtherCustomFields());
        }
        if (TRANSACTION_CUSTOM_FIELD_RELATED_BO_NAME.contains(boName)) {
            fields.addAll(getTransactionCustomFields());
        }
        if (CRM_CUSTOM_FIELD_RELATED_BO_NAME.contains(boName)) {
            fields.addAll(getCRMCustomFields());
        }
        if (ITEM_CUSTOM_FIELD_RELATED_BO_NAME.contains(boName)) {
            fields.addAll(getITEMCustomFields());
        }
        if (ENTITY_CUSTOM_FIELD_RELATED_BO_NAME.contains(boName)) {
            fields.addAll(getEntityCustomFields());
        }
    }
    return fields;
}

Set
是最快的数据结构。所以为什么不采取最好的方法呢。
我也会考虑将所有这些数组放在一个映射或映射中，然后再进行处理。
最好解释一下这段代码的作用。OP可能不熟悉Java8功能。同意并编辑。（实际上是在您的注释之前编辑的：-），然后您可以使用map收集结果，并将id传递给addAll:fields.addAll（Arrays.stream（OTHER_CUSTOM_FIELD_RELATED_BO_NAME）。filter（e->e.contains（“A”）.findFirst（）.map（s->getOtherCustomFields（））.orElse（集合.空列表））；有很多方法可以有效地进行字符串搜索。需要指出的是，这将适用于java 9+@NicholasK在下面添加了一个9之前的解决方案：“如果您的java版本仍然…”，但是谢谢；我会添加版本号。谢谢回复，你能解释一下供应商getter吗？？这是来自jjava.util.function.Supplier吗？？？@AmrendraKumar是的，这是一个
java.util.function.Supplier
。这意味着它是一个不接受任何参数并返回
String
s集合的方法（正如您的
getXXX（）
方法所做的那样）。我在这个处理程序上遇到错误。添加（新的Bonameholder（其他自定义字段相关的BO\u名称，this:：getOtherCustomFields））；是否需要将构造函数的第二个参数更改为Object？？？@AmrendraKumar，这取决于您得到的错误。您可能需要将getter成员和构造函数更改为
BoNameHandler（字符串[]na）
private static final Set<String> OTHER_CUSTOM_FIELD_RELATED_BO_NAME = new HashSet<>();
static {
    Collections.addAll(OTHER_CUSTOM_FIELD_RELATED_BO_NAME,
        "A", "B", "C", "D", "E", "F", "G", "H" );
}