Java中利用正则表达式从混合文本中提取数字：区分空白符与非空白符的处理策略-java教程-PHP中文网

Java中利用正则表达式从混合文本中提取数字：区分空白符与非空白符的处理策略

本文探讨了在Java中如何使用正则表达式从包含数字、字母和特殊字符的混合文本中提取数字序列。核心挑战在于，相邻数字若由非空白字符分隔，应被视为一个整体数字；若由空白字符分隔，则应被视为独立的数字。文章详细介绍了两种基于Java 8/9+ Stream API的解决方案：利用Matcher.results()直接匹配包含数字的非空白块，以及通过Pattern.splitAsStream()先按空白符分割再处理每个片段，并提供了相应的代码示例和注意事项。

1. 问题背景与需求分析

在数据处理和文本分析中，经常需要从复杂的字符串中提取特定模式的数据。本教程关注一个具体场景：从一个混合了数字、字母、特殊字符甚至空白符的文本中，精确地提取所有数字。其特殊要求在于：

非空白字符连接的数字视为一个整体： 例如，字符串 ds[44]%6c 应该提取出 446。这里的 44 和 6 之间虽然有 % 字符，但由于 % 不是空白符，它们被视为同一个数字序列的一部分。
空白字符分隔的数字视为独立个体： 例如，字符串 2021 ds[44]%6c 应该提取出 2021 和 446。这里的 2021 和 ds[44]%6c 之间有空白符，因此它们被视为两个独立的数字序列。

传统的 -?d+ 正则表达式可以捕获独立的数字，但无法处理数字之间夹杂非空白字符的情况，也无法有效区分空白符和非空白符对数字分组的影响。

2. 解决方案一：利用 Matcher.results() 匹配非空白数字块

Java 9 引入的 Matcher.results() 方法能够返回一个 Stream<MatchResult>，这为处理多个匹配项提供了极大的便利。我们可以构造一个正则表达式来匹配包含至少一个数字且前后被零个或多个非空白字符包围的序列。

2.1 核心正则表达式

我们使用的正则表达式是 [^\s]*\d+[^\s]*。其含义如下：

[^\s]*：匹配零个或多个非空白字符。
\d+：匹配一个或多个数字。
[^\s]*：再次匹配零个或多个非空白字符。

这个正则表达式的目的是捕获一个“块”，这个块内部可能包含数字和非空白字符，但它的边界是由空白字符定义的（或者字符串的开始/结束）。

立即学习“Java免费学习笔记（深入）”；

2.2 实现代码

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class NumberExtractor {

    // 匹配包含至少一个数字，且前后被零个或多个非空白字符包围的序列
    public static final Pattern TEXT_WITH_DIGITS = Pattern.compile("[^\s]*\d+[^\s]*");

    /**
     * 从字符串中提取符合特定规则的整数列表。
     * 数字之间若有非空白字符则合并，若有空白字符则分离。
     *
     * @param str 待处理的输入字符串
     * @return 提取出的整数列表
     */
    public static List<Integer> getIntsUsingMatcherResults(String str) {
        return TEXT_WITH_DIGITS.matcher(str).results() // 获取所有匹配结果的流 (Stream<MatchResult>)
            .map(MatchResult::group)                   // 提取每个匹配结果的完整字符串 (Stream<String>)
            .map(s -> s.replaceAll("\D+", ""))        // 移除字符串中的所有非数字字符，只保留数字
            .map(Integer::valueOf)                     // 将纯数字字符串转换为Integer (Stream<Integer>)
            .toList();                                 // 收集结果到List
    }

    // 主方法用于测试
    public static void main(String[] args) {
        System.out.println("使用 Matcher.results() 方法:");
        System.out.println("ds[44]%6c -> " + getIntsUsingMatcherResults("ds[44]%6c"));
        System.out.println("2021 ds[44]%6c -> " + getIntsUsingMatcherResults("2021 ds[44]%6c"));
        System.out.println("  123 test 456-abc-789  -> " + getIntsUsingMatcherResults("  123 test 456-abc-789  "));
    }
}

登录后复制

2.3 工作原理详解

TEXT_WITH_DIGITS.matcher(str).results(): 创建一个 Matcher 对象并调用其 results() 方法。这个方法返回一个 Stream<MatchResult>，其中每个 MatchResult 代表一个符合 TEXT_WITH_DIGITS 模式的匹配项。
.map(MatchResult::group): 从每个 MatchResult 中提取出实际匹配到的字符串。此时，我们得到的是像 "ds[44]%6c" 或 "2021" 这样的字符串。
.map(s -> s.replaceAll("\D+", "")): 这是关键一步。对于每个匹配到的字符串，我们使用 replaceAll("\D+", "") 来移除所有非数字字符（\D 匹配任何非数字字符，+ 表示一个或多个）。例如，"ds[44]%6c" 会变成 "446"，"2021" 仍然是 "2021"。
.map(Integer::valueOf): 将清理后的纯数字字符串转换为 Integer 类型。
.toList(): 将最终的 Integer 流收集成一个 List。

3. 解决方案二：利用 Pattern.splitAsStream() 先分割再处理

另一种方法是首先根据空白符将整个字符串分割成多个部分，然后对每个部分进行数字提取和清理。Java 8 引入的 Pattern.splitAsStream() 方法非常适合此场景，它直接返回一个 Stream<String>，避免了创建中间数组。

boardmix博思白板

boardmix博思白板，一个点燃团队协作和激发创意的空间，集aigc，一键PPT，思维导图，笔记文档多种创意表达能力于一体，将团队工作效率提升到新的层次。

查看详情

3.1 核心正则表达式与分割策略

我们使用 \s+ 作为分隔符，它匹配一个或多个空白字符。这意味着字符串将根据空白字符被拆分成多个片段。

3.2 实现代码

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

public class NumberExtractor {

    // 匹配一个或多个空白字符
    public static final Pattern WHITE_SPACES = Pattern.compile("\s+");

    /**
     * 从字符串中提取符合特定规则的整数列表。
     * 先按空白符分割，再处理每个片段。
     *
     * @param str 待处理的输入字符串
     * @return 提取出的整数列表
     */
    public static List<Integer> getIntsUsingSplitAsStream(String str) {
        return WHITE_SPACES.splitAsStream(str)      // 按空白符分割字符串，得到一个字符串流 (Stream<String>)
            .dropWhile(String::isEmpty)             // 移除开头的空字符串（处理字符串以空白符开头的情况）
            .map(s -> s.replaceAll("\D+", ""))    // 移除每个片段中的所有非数字字符
            .map(Integer::valueOf)                  // 将纯数字字符串转换为Integer
            .toList();                              // 收集结果到List
    }

    // 主方法用于测试
    public static void main(String[] args) {
        System.out.println("使用 Pattern.splitAsStream() 方法:");
        System.out.println("ds[44]%6c -> " + getIntsUsingSplitAsStream("ds[44]%6c"));
        System.out.println("2021 ds[44]%6c -> " + getIntsUsingSplitAsStream("2021 ds[44]%6c"));
        System.out.println("  123 test 456-abc-789  -> " + getIntsUsingSplitAsStream("  123 test 456-abc-789  "));
    }
}

登录后复制

3.3 工作原理详解

WHITE_SPACES.splitAsStream(str): 使用 \s+ 正则表达式作为分隔符，将输入字符串分割成一个 Stream<String>。例如，"2021 ds[44]%6c" 会被分割成 "2021" 和 "ds[44]%6c"。如果字符串以空白符开头，例如 " 123"，splitAsStream 可能会在流的开头产生一个空字符串。
.dropWhile(String::isEmpty): 这是一个重要的步骤，尤其当输入字符串以一个或多个空白字符开头时。splitAsStream 可能会在流的开始生成一个空字符串。dropWhile 会丢弃流中满足给定条件的连续前缀元素。在这里，它会丢弃所有开头的空字符串，确保我们只处理有效的非空片段。
.map(s -> s.replaceAll("\D+", "")): 对每个分割后的片段，同样使用 replaceAll("\D+", "") 移除所有非数字字符，只保留数字。
.map(Integer::valueOf): 将清理后的纯数字字符串转换为 Integer 类型。
.toList(): 将最终的 Integer 流收集成一个 List。

4. 示例与输出

为了更清晰地展示两种方法的实际效果，我们将两种方法集成到一个 main 方法中进行测试，并输出结果。

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class NumberExtractor {

    // 匹配包含至少一个数字，且前后被零个或多个非空白字符包围的序列
    public static final Pattern TEXT_WITH_DIGITS = Pattern.compile("[^\s]*\d+[^\s]*");

    // 匹配一个或多个空白字符
    public static final Pattern WHITE_SPACES = Pattern.compile("\s+");

    public static List<Integer> getIntsUsingMatcherResults(String str) {
        return TEXT_WITH_DIGITS.matcher(str).results()
            .map(MatchResult::group)
            .map(s -> s.replaceAll("\D+", ""))
            .map(Integer::valueOf)
            .toList();
    }

    public static List<Integer> getIntsUsingSplitAsStream(String str) {
        return WHITE_SPACES.splitAsStream(str)
            .dropWhile(String::isEmpty)
            .map(s -> s.replaceAll("\D+", ""))
            .map(Integer::valueOf)
            .toList();
    }

    public static void main(String[] args) {
        String test1 = "ds[44]%6c";
        String test2 = "2021 ds[44]%6c";
        String test3 = "  123 test 456-abc-789  ";
        String test4 = "no_digits_here";
        String test5 = "only_1_digit";

        System.out.println("--- 使用 Matcher.results() 方法 ---");
        System.out.println("输入: "" + test1 + "" -> 输出: " + getIntsUsingMatcherResults(test1));
        System.out.println("输入: "" + test2 + "" -> 输出: " + getIntsUsingMatcherResults(test2));
        System.out.println("输入: "" + test3 + "" -> 输出: " + getIntsUsingMatcherResults(test3));
        System.out.println("输入: "" + test4 + "" -> 输出: " + getIntsUsingMatcherResults(test4));
        System.out.println("输入: "" + test5 + "" -> 输出: " + getIntsUsingMatcherResults(test5));


        System.out.println("
--- 使用 Pattern.splitAsStream() 方法 ---");
        System.out.println("输入: "" + test1 + "" -> 输出: " + getIntsUsingSplitAsStream(test1));
        System.out.println("输入: "" + test2 + "" -> 输出: " + getIntsUsingSplitAsStream(test2));
        System.out.println("输入: "" + test3 + "" -> 输出: " + getIntsUsingSplitAsStream(test3));
        System.out.println("输入: "" + test4 + "" -> 输出: " + getIntsUsingSplitAsStream(test4));
        System.out.println("输入: "" + test5 + "" -> 输出: " + getIntsUsingSplitAsStream(test5));
    }
}

登录后复制

输出结果:

--- 使用 Matcher.results() 方法 ---
输入: "ds[44]%6c" -> 输出: [446]
输入: "2021 ds[44]%6c" -> 输出: [2021, 446]
输入: "  123 test 456-abc-789  " -> 输出: [123, 456789]
输入: "no_digits_here" -> 输出: []
输入: "only_1_digit" -> 输出: [1]

--- 使用 Pattern.splitAsStream() 方法 ---
输入: "ds[44]%6c" -> 输出: [446]
输入: "2021 ds[44]%6c" -> 输出: [2021, 446]
输入: "  123 test 456-abc-789  " -> 输出: [123, 456789]
输入: "no_digits_here" -> 输出: []
输入: "only_1_digit" -> 输出: [1]

登录后复制

从输出可以看出，两种方法都成功实现了预期的数字提取逻辑。

5. 注意事项与总结

Java 版本要求：
- Matcher.results() 方法自 Java 9 起可用。
- Pattern.splitAsStream() 和 Stream.dropWhile() 方法自 Java 9 起可用（splitAsStream 在 Java 8 引入，但 dropWhile 是 Java 9）。如果使用 Java 8，dropWhile 需要替换为其他过滤逻辑，例如 filter(s -> !s.isEmpty())，但这可能无法完全等效于 dropWhile 在处理连续空字符串时的行为。
正则表达式的预编译： 在示例中，Pattern 对象是作为 public static final 成员变量声明的。这意味着正则表达式只会被编译一次，提高了性能，尤其是在多次调用提取方法时。
错误处理： 示例代码中直接将清理后的字符串转换为 Integer。如果 replaceAll("\D+", "") 的结果是一个空字符串（例如，如果某个匹配块中根本没有数字，但在本例中，\d+ 保证了至少有一个数字），或者是一个无法解析为整数的字符串，Integer.valueOf() 将抛出 NumberFormatException。在实际应用中，可能需要添加 try-catch 块或额外的 filter 步骤来处理这些潜在异常，例如 filter(s -> !s.isEmpty())。
选择哪种方法：
- Matcher.results() 方法更直接地匹配了我们定义的“数字块”模式。如果你的需求是直接识别和处理这些复合模式，它可能更直观。
- Pattern.splitAsStream() 方法则采用“分而治之”的策略：先根据主要分隔符（空白符）将问题分解，再处理每个子问题。这种方法在分隔符清晰且需要对每个片段独立操作时非常有效。
- 两种方法在本特定问题中表现相似，选择哪种取决于个人偏好和对代码可读性的考量。