带有制表符的java模式

Question

我有一个文件，其中包含以下行：

string1 (tab) sting2 (tab) string3 (tab) string4

我想从每一行中获取 string3... 我现在从这些行中获取的是 string3 位于第二个和第三个制表符之间。 是否可以采用类似的模式

Pattern pat = Pattern.compile(".\t.\t.\t.");

Answer 1

String string3 = tempValue.split("\\t")[2];

Answer 2

听起来你只是想要：（

foreach (String line in lines) {
    String[] bits = line.split("\t");
    if (bits.length != 4) {
        // Handle appropriately, probably throwing an exception
        // or at least logging and then ignoring the line (using a continue
        // statement)
    }
    String third = bits[2];
    // Use...
}

你可以转义字符串，以便正则表达式引擎必须将反斜杠-t解析为制表符，但你不必这样做。上面的工作正常。）

另一个使用正则表达式的内置 String.split 方法的替代方法是 Guava 分割器< /code>类。这里可能没有必要，但值得注意。

编辑：如评论中所述，如果您要重复使用相同的模式，则编译单个 Pattern 并使用 Pattern.split 会更有效：

private static final Pattern TAB_SPLITTER = Pattern.compile("\t");

...

String[] bits = TAB_SPLITTER.split(line);

Answer 3

如果您想要一个仅捕获第三个字段而没有其他字段的正则表达式，您可以使用以下内容：

String regex = "(?:[^\\t]*)\\t(?:[^\\t]*)\\t([^\\t]*)\\t(?:[^\\t]*)";
Pattern pattern = Pattern.compile(regex);

Matcher matcher = pattern.matcher(input);
if (matcher.matches()) {
  System.err.println(matcher.group(1));
}

我不知道这是否会比 split("\\t" 执行得更好) 用于解析大文件。

更新

我很好奇简单的分割与更明确的正则表达式将如何执行，因此我测试了三种不同的解析器实现。

/** Simple split parser */
static class SplitParser implements Parser {
    public String parse(String line) {
        String[] fields = line.split("\\t");
        if (fields.length == 4) {
            return fields[2];
        }
        return null;
    }
}

/** Split parser, but with compiled pattern */
static class CompiledSplitParser implements Parser {
    private static final String regex = "\\t";
    private static final Pattern pattern = Pattern.compile(regex);

    public String parse(String line) {
        String[] fields = pattern.split(line);
        if (fields.length == 4) {
            return fields[2];
        }
        return null;
    }
}

/** Regex group parser */
static class RegexParser implements Parser {
    private static final String regex = "(?:[^\\t]*)\\t(?:[^\\t]*)\\t([^\\t]*)\\t(?:[^\\t]*)";
    private static final Pattern pattern = Pattern.compile(regex);

    public String parse(String line) {
        Matcher m = pattern.matcher(line);
        if (m.matches()) {
            return m.group(1);
        }
        return null;
    }
}

我针对同一个百万行文件运行了十次。以下是平均结果：

• split: 2768.8 ms
• 已编译 split: 1041.5 ms
• group regex: 1015.5 ms

明确的结论是编译非常重要你的模式，而不是依赖String.split< /a>，如果您要重复使用它。

根据此测试，编译的拆分与组正则表达式的结果并不是结论性的。也许可以进一步调整正则表达式以提高性能。

更新

另一种简单的优化是重用匹配器，而不是为每个循环迭代创建一个匹配器。

static class RegexParser implements Parser {
    private static final String regex = "(?:[^\\t]*)\\t(?:[^\\t]*)\\t([^\\t]*)\\t(?:[^\\t]*)";
    private static final Pattern pattern = Pattern.compile(regex);

    // Matcher is not thread-safe...
    private Matcher matcher = pattern.matcher("");

    // ... so this method is no-longer thread-safe
    public String parse(String line) {
        matcher = matcher.reset(line);
        if (matcher.matches()) {
            return matcher.group(1);
        }
        return null;
    }
}