java - 正则表达式可选组捕获 JAVA

Question

我有一个用户指定的模式:

1998-2010:Make:model:trim:engine

trim 和 engine 是可选的，如果存在我应该捕获它们；如果不是，匹配器至少应该验证 YMM。

([0-9]+-*[0-9]+):(.*):(.*):(.*):(.*)

如果所有三个字段都存在，则匹配，但我如何使最后两个字段和只有两个字段可选？

Answer 1

使用正则表达式和? , “零或一个量词”

您可以使用 ?匹配零个或一个，这是你想要对最后一位做的。但是，您的模式需要稍作修改才能更像 [^:]*。而不是 .* .下面是一些示例代码及其输出。我最终得到的正则表达式是:

([^:]*):([^:]*):([^:]*)(?::([^:]*))?(?::([^:]*))?
|-----| |-----| |-----|    |-----|      |-----|
   a       a       a          a            a

                       |-----------||-----------|
                             b            b

每个a匹配一系列非冒号(尽管您想要修改第一个以匹配年份)，并且 b是一个 非捕获 组(所以它以 ?: 开头)并且匹配零次或一次(因为它有最后的 ? 量词)。这意味着第四和第五个字段是可选的。示例代码表明，此模式在存在三个、四个或五个字段的情况下匹配，如果字段多于五个或少于三个则不匹配。

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

public class QuestionMarkQuantifier {
    public static void main(String[] args) {
        final String input = "a:b:c:d:e:f:g:h";
        final Pattern p = Pattern.compile( "([^:]*):([^:]*):([^:]*)(?::([^:]*))?(?::([^:]*))?" );
        for ( int i = 1; i <= input.length(); i += 2 ) {
            final String string = input.substring( 0, i );
            final Matcher m = p.matcher( string );
            if ( m.matches() ) {
                System.out.println( "\n=== Matches for: "+string+" ===" );
                final int count = m.groupCount();
                for ( int j = 0; j <= count; j++ ) {
                    System.out.println( j + ": "+ m.group( j ));
                }
            }
            else {
                System.out.println( "\n=== No matches for: "+string+" ===" );
            }
        }
    }
}

=== No matches for: a ===

=== No matches for: a:b ===

=== Matches for: a:b:c ===
0: a:b:c
1: a
2: b
3: c
4: null
5: null

=== Matches for: a:b:c:d ===
0: a:b:c:d
1: a
2: b
3: c
4: d
5: null

=== Matches for: a:b:c:d:e ===
0: a:b:c:d:e
1: a
2: b
3: c
4: d
5: e

=== No matches for: a:b:c:d:e:f ===

=== No matches for: a:b:c:d:e:f:g ===

=== No matches for: a:b:c:d:e:f:g:h ===

虽然使用正则表达式当然可以匹配这种字符串，但似乎只在 : 上拆分字符串可能更容易。并检查你得到了多少值。这不一定会进行其他类型的检查(例如，每个字段中的字符)，因此在激发此操作的任何非最小情况下，拆分可能都不是很有用。

使用 String.split 和限制参数

我注意到了 your comment在另一篇推荐使用 String.split(String) 的帖子中(强调):

Yes I know this function, but it work for me cause I have a string which is a:b:c:d:e:f:g:h.. but I just want to group the data as a:b:c:d:e if any as one and the rest of the string as another group

值得注意的是，split 的一个版本还需要一个参数，String.split(String,int) .第二个参数是一个限制，描述为:

The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array. If the limit n is greater than zero then the pattern will be applied at most n - 1 times, the array's length will be no greater than n, and the array's last entry will contain all input beyond the last matched delimiter. If n is non-positive then the pattern will be applied as many times as possible and the array can have any length. If n is zero then the pattern will be applied as many times as possible, the array can have any length, and trailing empty strings will be discarded.

这意味着您可以使用 split 和 limit 6 从您的输入中获取最多五个字段，并且您会将剩余的输入作为最后一个字符串。您仍然需要检查您是否有至少 3 个元素，以确保有足够的输入，但总而言之，这似乎更简单一些。

import java.util.Arrays;

public class QuestionMarkQuantifier {
    public static void main(String[] args) {
        final String input = "a:b:c:d:e:f:g:h";
        for ( int i = 1; i <= input.length(); i += 2 ) {
            final String string = input.substring( 0, i );
            System.out.println( "\n== Splits for "+string+" ===" );
            System.out.println( Arrays.toString( string.split( ":", 6 )));
        }
    }
}

== Splits for a ===
[a]

== Splits for a:b ===
[a, b]

== Splits for a:b:c ===
[a, b, c]

== Splits for a:b:c:d ===
[a, b, c, d]

== Splits for a:b:c:d:e ===
[a, b, c, d, e]

== Splits for a:b:c:d:e:f ===
[a, b, c, d, e, f]

== Splits for a:b:c:d:e:f:g ===
[a, b, c, d, e, f:g]

== Splits for a:b:c:d:e:f:g:h ===
[a, b, c, d, e, f:g:h]