首页 > 文章 > java教程

Java中List元素部分匹配与模式检测：告别contains()的局限

时间：2025-10-16 22:09:15 482浏览收藏

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Java中List元素部分匹配与模式检测：告别contains()的局限》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

List.contains()方法仅支持精确匹配，这在需要进行模糊或部分匹配时会遇到限制。本文将深入探讨如何在Java中实现列表元素的灵活匹配，特别是当需要检查字符串是否包含列表中的某个子串，或根据复杂模式进行匹配时，通过迭代、`String.contains()`方法以及正则表达式（`Pattern`和`Matcher`）提供高效且灵活的解决方案。

在Java开发中，java.util.List接口的contains()方法是判断列表中是否存在指定元素的基础工具。然而，许多开发者在使用时会发现，contains()方法执行的是严格的精确匹配。这意味着，如果列表中存储的是字符串"Halle 1"，那么list.contains("Halle 1, Außerhalb")或list.contains("Vor Halle 1")都将返回false，即使从语义上讲，这些字符串确实包含了"Halle 1"。这种行为与实际应用中常见的“部分匹配”或“模式匹配”需求相悖。

考虑以下示例，它清晰地展示了List.contains()的局限性：

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<String> analyzeTypeList = new LinkedList<>();
        analyzeTypeList.add("Halle 1");

        System.out.println(analyzeTypeList.contains("Halle 1"));           // true (精确匹配)
        System.out.println(analyzeTypeList.contains("Halle 1, Außerhalb")); // false (非精确匹配)
        System.out.println(analyzeTypeList.contains("Vor Halle 1"));      // false (非精确匹配)
    }
}

上述代码的输出结果会是true、false、false。这表明List.contains()无法满足“如果列表中包含‘Halle 1’，那么‘Halle 1, Außerhalb’也应视为匹配”这样的需求。

解决方案一：基于循环和String.contains()的简单子串匹配

当需求相对简单，仅需判断一个目标字符串是否包含列表中 任何一个 元素作为子串时，可以通过遍历列表并结合String.contains()方法来实现。这种方法直观且易于理解。

假设我们有一个参考列表analyzeTypeList，其中包含一系列我们关心的关键词（例如，"Halle 1", "Halle 2", "Gebäude 14"）。现在，我们有一个数据字符串（例如，"Vor Halle 1, Parkplatz"），我们希望检查这个数据字符串是否包含了analyzeTypeList中的任何一个关键词。

import java.util.Arrays;
import java.util.List;

public class SubstringMatcher {

    /**
     * 检查目标字符串是否包含参考列表中任意一个元素作为子串。
     *
     * @param searchList   包含待匹配子串的参考列表。
     * @param targetString 待检查的目标字符串。
     * @return 如果目标字符串包含searchList中任何一个元素，则返回true；否则返回false。
     */
    public static boolean containsAnySubstring(List<String> searchList, String targetString) {
        if (targetString == null || searchList == null || searchList.isEmpty()) {
            return false;
        }
        for (String item : searchList) {
            if (targetString.contains(item)) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        List<String> analyzeTypeList = Arrays.asList("Halle 1", "Halle 2", "Gebäude 14");

        String dataString1 = "Vor Halle 1, Parkplatz";
        String dataString2 = "Halle 13, Lager";
        String dataString3 = "Gebäude 14, Eingang";
        String dataString4 = "停车场";

        System.out.println("'" + dataString1 + "' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ " + containsAnySubstring(analyzeTypeList, dataString1));
        System.out.println("'" + dataString2 + "' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ " + containsAnySubstring(analyzeTypeList, dataString2));
        System.out.println("'" + dataString3 + "' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ " + containsAnySubstring(analyzeTypeList, dataString3));
        System.out.println("'" + dataString4 + "' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ " + containsAnySubstring(analyzeTypeList, dataString4));
    }
}

输出结果：

'Vor Halle 1, Parkplatz' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ true
'Halle 13, Lager' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ false
'Gebäude 14, Eingang' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ true
'停车场' 包含 'Halle 1' 或 'Halle 2' 或 'Gebäude 14' 吗？ false

注意事项：

这种方法适用于简单的子串匹配，但无法处理复杂的模式（如“以某个词开头但不包含特定后缀”）。
性能方面，如果searchList非常大或在循环中频繁调用，可能会有性能开销，因为每次String.contains()调用都会进行一次子串搜索。

解决方案二：利用正则表达式进行灵活模式匹配

对于更复杂、更灵活的匹配需求，例如需要忽略前后缀、匹配多个模式中的任意一个、或者需要更精确的边界控制，Java的正则表达式（java.util.regex.Pattern和java.util.regex.Matcher）是更强大且高效的工具。

核心思想是将参考列表中的所有关键词组合成一个正则表达式，然后使用这个正则表达式去匹配目标字符串。

步骤1：构建正则表达式

将analyzeTypeList中的所有元素组合成一个正则表达式字符串。通常，我们会使用|（OR操作符）来连接这些元素，表示匹配其中任意一个。为了避免列表中元素中可能包含的正则表达式特殊字符被错误解析，需要使用Pattern.quote()方法对每个元素进行转义。

import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class RegexMatcher {

    /**
     * 根据参考列表构建一个正则表达式，并检查目标字符串是否匹配该模式。
     *
     * @param searchList   包含待匹配模式的参考列表。
     * @param targetString 待检查的目标字符串。
     * @param pattern      预编译的正则表达式Pattern对象。
     * @return 如果目标字符串包含与模式匹配的子序列，则返回true；否则返回false。
     */
    public static boolean matchesAnyPattern(Pattern pattern, String targetString) {
        if (targetString == null || pattern == null) {
            return false;
        }
        Matcher matcher = pattern.matcher(targetString);
        return matcher.find(); // 使用 find() 查找是否存在匹配的子序列
    }

    public static void main(String[] args) {
        // 假设 analyzeTypeList 是你的参考列表，包含 "Halle 1", "Halle 2" 等
        List<String> analyzeTypeList = Arrays.asList(
            "Außerhalb", "Halle 1", "Halle 2", "Halle 3", "Halle 4", "Halle 5",
            "Halle 6", "Halle 7", "Halle 8", "Halle 9", "Halle 10", "Halle 11",
            "Halle 12", "Halle 13", "Gebäude 14"
        );

        // 构建正则表达式字符串
        // 使用 Pattern::quote 转义特殊字符，并用 | 连接
        String regexPatternString = analyzeTypeList.stream()
                                            .map(Pattern::quote)
                                            .collect(Collectors.joining("|"));

        // 编译正则表达式。建议将 Pattern 对象作为常量或在外部初始化一次，避免在循环中重复编译。
        final Pattern combinedPattern = Pattern.compile(regexPatternString);

        // 模拟详细事故数据 (ac.get(databaseName) 返回的值)
        List<String> detailedAccidentData = Arrays.asList(
            "Vor Halle 4",
            "Halle 1, Montage",
            "Halle 13, Lager",
            "Halle 13, CNC-Maschine",
            "Halle 13",
            "Vor Halle 1, Parkplatz",
            "Halle 4",
            "Halle 7",
            "Außerhalb",
            "Gebäude 14",
            "未知区域"
        );

        System.out.println("--- 使用正则表达式进行匹配 ---");
        for (String dataEntry : detailedAccidentData) {
            if (matchesAnyPattern(combinedPattern, dataEntry)) {
                // 如果需要知道具体匹配了 analyzeTypeList 中的哪个元素，可以进一步处理
                // 例如，通过 matcher.group() 获取匹配到的文本
                Matcher matcher = combinedPattern.matcher(dataEntry);
                if (matcher.find()) { // 再次调用 find() 来获取匹配组
                    String matchedText = matcher.group();
                    System.out.println("数据: '" + dataEntry + "' 匹配到模式: '" + matchedText + "'");
                }
            } else {
                System.out.println("数据: '" + dataEntry + "' 未匹配到任何已知模式。");
            }
        }
    }
}

输出结果：

--- 使用正则表达式进行匹配 ---
数据: 'Vor Halle 4' 匹配到模式: 'Halle 4'
数据: 'Halle 1, Montage' 匹配到模式: 'Halle 1'
数据: 'Halle 13, Lager' 匹配到模式: 'Halle 13'
数据: 'Halle 13, CNC-Maschine' 匹配到模式: 'Halle 13'
数据: 'Halle 13' 匹配到模式: 'Halle 13'
数据: 'Vor Halle 1, Parkplatz' 匹配到模式: 'Halle 1'
数据: 'Halle 4' 匹配到模式: 'Halle 4'
数据: 'Halle 7' 匹配到模式: 'Halle 7'
数据: 'Außerhalb' 匹配到模式: 'Außerhalb'
数据: 'Gebäude 14' 匹配到模式: 'Gebäude 14'
数据: '未知区域' 未匹配到任何已知模式。

今天关于《Java中List元素部分匹配与模式检测：告别contains()的局限》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！