在Java中，有没有一种有效的方法可以在同一个字符串值中搜索多个（不相邻）单词？

Question

我们在环境中从权威来源提取大量数据，并将其填充到各种属性中。其中一个属性是"jobTitle"，顾名思义，它代表了组织内身份所对应的职位。

我的主要工作之一是为组织创建角色分配规则，目前遇到了一个问题，我认为可以更高效地解决，但我缺乏必要的Java知识。

问题如下：

我们使用以下Java语句来获取组织中任何包含"Nurse"的特定jobTitle：identity.getAttribute("jobTitle").contains("Nurse");

我想请教Java专家们，是否有办法使用通配符来获取所有包含"%Nursing%Specialist%"或"%Nursing%Coordinator%"的jobTitle？

例如，如果我想为所有具有如“Nursing Professional Development Specialist”或“Nursing Resource Coordinator”这样jobTitle的用户授权一个角色，其中“Coordinator”和“Specialist”可能被其他字符串分隔开。

在Java中，是否存在一种有效的方式来应对这个挑战？

目前我们的做法是这样的：

return "Nursing Care Coordinator".equalsIgnoreCase(identity.getAttribute("jobTitle"))
    || "Nursing Resource Coordinator".equalsIgnoreCase(identity.getAttribute("jobTitle"))
    || "Nursing Practice Specialist".equalsIgnoreCase(identity.getAttribute("jobTitle"))
    || "Nursing Professional Development Specialist".equalsIgnoreCase(identity.getAttribute("jobTitle"));

这里想要表达的是类似"%Nursing%Specialist%"这样的匹配模式，其中%可以代表其他字符串，比如“Professional Nursing Development Specialist”。我希望能够确保所有必要的jobTitle都能正确地获得相应角色，而不必逐一列出每一个具体的职位名称。

Eugene Yokota · Answer

在字符串中搜索不相邻的多个单词可以使用正则表达式来处理。你可以利用Java中的java.util.regex包下的Pattern和Matcher类来实现这一功能。你可以在https://regexr.com" rel="nofollow noreferrer">regexr网站上帮助你构建和测试正则表达式。

以下是一个使用正则表达式进行多词搜索的Java示例：

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class MultiWordSearch {
    public static boolean containsWords(String input, String[] words) {
        // 构建一个类似于"(?=.*word1)(?=.*word2)(?=.*word3).*"的正则表达式模式
        StringBuilder regex = new StringBuilder();
        for (String word : words) {
            regex.append("(?=.*").append(Pattern.quote(word)).append(")");
        }
        regex.append(".*");

        Pattern pattern = Pattern.compile(regex.toString(), Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(input);

        return matcher.matches();
    }

    public static void main(String[] args) {
        String input = "这是一个用于搜索的示例字符串";
        String[] words = {"示例", "搜索"};

        System.out.println("包含指定单词: " + containsWords(input, words));
    }
}

LazyOne · Answer

正如@Dave Newton指出的那样，“高效”这一术语在很大程度上取决于个人理解。

一种方法是简单地计算给定jobTitle中包含的关键字数量，并基于这个数量进行操作。例如：

public static boolean containsMultipleKeywords(String jobTitle) {
  // 为了进行不区分大小写的比较
  jobTitle = jobTitle.toLowerCase();

  // 设置要检查的关键字集合
  Set keywords = new HashSet<>(Arrays.asList("nurse", "coordinator", "director"));

  // 计算关键字出现次数
  int count = 0;
  for (String keyword : keywords) {
    if (jobTitle.contains(keyword)) {
      count++;
    }
  }

  // 如果找到至少两个关键字，则返回true
  return count >= 2;
}

另外，你也可以使用正则表达式来实现：

  Pattern pattern = Pattern.compile("\b(nurse|coordinator|director)\b");

  // 创建匹配器以查找jobTitle中的匹配项
  Matcher matcher = pattern.matcher(jobTitle);

  // 统计匹配次数
  int count = 0;
  while (matcher.find()) {
    count++;
  }

Eran Galperin · Answer

你可以使用正则表达式以一种对程序员来说高效（单个表达式）的方式来实现。要匹配“Nurse”或“Nursing 开头，后面跟任意字符再接 Specialist”或“Nursing 开头，后面跟任意字符再接 Coordinator”：

identity.getAttribute("jobTitle")
  .matches("^(?=Nurse$|Nursing.*(Coordinator|Specialist)$).*")

这种方法对于计算机执行也是相对高效的。

点击此处查看在线演示，获取关于该正则表达式的完整解释。

如果你只是想确保这些词不论顺序如何都出现，则可以使用两个前瞻断言——一个用于每个词：

matches("^(?=.*Nurs(e|ing))(?=.*.*(Coordinator|Specialist)).*")

John Boker · Answer

你可以构建一个谓词来检查完全匹配项，然后将它应用到职位标题上。参数越多，则匹配的可能性越小。

String[] titles = {"obstetrics nurse admin", "Nurse Admin obstetrics",
        "obstetrics admin nurse", "obstetrics nurse"};

String[] traits = {"nurse", "admin", "obstetrics"};

Predicate check = buildPredicate(traits);
for (String title : titles) {
    System.out.println(title + " -> " + check.test(title.toLowerCase()));
}

static Predicate buildPredicate(String[] info) {
    Predicate pred = s -> s.contains(info[0]);
    for (int i = 1; i < info.length; i++) {
        final int k = i;
        pred = pred.and(s -> s.contains(info[k]));
    }
    return pred;
}

这段代码会输出：

obstetrics nurse admin -> true
Nurse Admin obstetrics -> true
obstetrics admin nurse -> true
obstetrics nurse -> false

dfsq · Answer

总结

筛选一个字符串列表，查找那些（a）包含单词“Nursing”，并且（b）同时包含单词“Specialist”或“Coordinator”的字符串。

Stream.of (
        "Nursing Professional Development Specialist",  // 匹配项
        "Accountant",  // 不匹配项
        "Nursing Manager",  // 不匹配项
        "Nursing Resource Coordinator"  // 匹配项
)
.filter (
        ( String job ) -> 
                Arrays.stream(job.split(" ")).anyMatch(Set.of("Nursing")::contains) &&
                Arrays.stream(job.split(" ")).anyMatch(Set.of("Specialist", "Coordinator")::contains)
)
.toList();

输出结果为：[Nursing Professional Development Specialist, Nursing Resource Coordinator]

流过滤操作

可以将每个职位标题中的单词转换成一个流。使用String#split方法会生成一个数组，将该数组传递给Arrays.stream就可以得到一个字符串流，即职位标题中的单词流。

Arrays.stream(job.split(" "))

示例数据：

List jobs = List.of(
        "Nursing Professional Development Specialist",  // 匹配项
        "Accountant",  // 不匹配项
        "Nursing Manager",  // 不匹配项
        "Nursing Resource Coordinator"  // 匹配项
);

定义目标关键词集合：

Set x = Set.of("Nursing");
Set y = Set.of("Specialist", "Coordinator");

在职位标题的流上应用这些目标关键词集合作为过滤器的谓词，并收集通过测试的职位标题。

List hits = jobs.stream()
        .filter((String job) ->
                Arrays.stream(job.split(" ")).anyMatch(x::contains))
        .filter((String job) ->
                Arrays.stream(job.split(" ")).anyMatch(y::contains))
        .toList();

打印到控制台：

System.out.println("hits = " + hits);

输出结果为：hits = [Nursing Professional Development Specialist, Nursing Resource Coordinator]

我们也可以组合我们的谓词语句测试。但我可能更倾向于使用两个单独的filter调用的原始长版本。

List hits = jobs.stream()
        .filter((String job) ->
                Arrays.stream(job.split(" ")).anyMatch(x::contains) &&
                Arrays.stream(job.split(" ")).anyMatch(y::contains)
        )
        .toList();