Java正则表达式，以匹配由点分隔符分隔的特定整数值

Question

基本上，我正在尝试实现下面指定的三个正则表达式-

1. 第一个正则表达式应至少匹配文字字符串10.1或任何类似10.1.0.0、10.1.1.0、10.2.1.0或10.2.1.1的字符串，依此类推，但它至少应匹配10.1或任何更高版本。我尝试了以下正则表达式d+.d+(.d+.d+)*但这与更低的版本(如9.1.1.0或9.1等(相匹配

2. 第二个正则表达式应该匹配高于字符串文字10.1但不是10.1的任何字符串，但它应该匹配任何其他字符串，如10.2或10.3或10.1.0.0或10.1.1.0或10.2.1.0或10.2.1.1或10.2或10.3、11.1.1.0或11.1，依此类推。尝试了以下操作，但与预期的(\d+)\.(\d+)(.*)不匹配

3. 第三个正则表达式应该匹配低于字符串文字10.1但不是10.1的任何字符串，但它应该匹配任何其他字符串，如10.0、9.1、9.2、9.1.1.0、9.1或9.1.2.0。

基本上，我如何匹配像10.1这样的文字字符串，后面跟着任何用点分隔的可选数字，以及我如何匹配比文字字符串更高或更低的东西，比如在我的第一、第二和第三点？

我仍在尝试修改我的正则表达式以满足我的要求，任何帮助/指导都将非常有用。

Answer 1

作为"4〃<quot；10〃；等等。更好地处理int。

class Version implements Comparable<Version> {
final int[] parts;
Version(String vs) {
parts = Stream.of(vs.split("\.")).mapToInt(Integer::parseInt).toArray();
}
@Override
public String toString() {
return Arrays.stream(parts)
.map(Integer::toString)
.collect(Collectors.joining("."));
}
@Override
public int compareTo(Version other) {
return Arrays.compare(parts, other.parts);
}
...
}
Version version1 = new Version("10.0.1");
Version version2 = new Version("1.2.1");
if (version1.compareTo(version2) <= 0) {
System.out.printf("%s <= %s%n", version1, version2);
}

这种方法基于一个编码原理：

不要立即对特定数量/实体使用基元类型。将其包装在值类中。

Answer 2

还有另一种方法可以将每个"."分隔的数字转换为固定长度的字符串。例如，如果每个数字的最大位数为4，则"1.2.3.4"变为"0001000200030004"。如果没有数字，请使用"****"。("****"小于"0000"(例如，"11.2"变为"00110002********"。您可以将这样转换的字符串与String.compare()进行比较。

下面显示了按转换后的数字排序的示例。

static final int NUMBER_SIZE = 4;
static final String UNDEF_NUMBER = "*".repeat(NUMBER_SIZE);
static final Pattern VERSION_PAT = Pattern.compile(
"(\d+)\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?");
static String fixed(String s) {
return s == null ? UNDEF_NUMBER : "0".repeat(NUMBER_SIZE - s.length()) + s;
}
public static String normalize(String version) {
Matcher m = VERSION_PAT.matcher(version);
if (!m.matches())
throw new IllegalArgumentException("version");
return fixed(m.group(1)) + fixed(m.group(2))
+ fixed(m.group(3)) + fixed(m.group(4));
}
public static void main(String[] args) {
String[] versions = {
"10.1", "10.1.0", "10.2", "10.3", "10.1.0.0", "10.1.1.0",
"10.2.1.0", "10.2.1.1", "10.2.0", "10.3.0", "11.1.1.0",
"10.0", "9.1", "9.2", "9.1.1.0", "9.1.2.0"
};
record Pair(String version, String normalized) {}
Arrays.stream(versions)
.map(version -> new Pair(version, normalize(version)))
.sorted(Comparator.comparing(Pair::normalized))
.forEach(pair -> System.out.printf("%16s : %s%n", pair.version, pair.normalized));
}

输出：

9.1 : 00090001********
9.1.1.0 : 0009000100010000
9.1.2.0 : 0009000100020000
9.2 : 00090002********
10.0 : 00100000********
10.1 : 00100001********
10.1.0 : 001000010000****
10.1.0.0 : 0010000100000000
10.1.1.0 : 0010000100010000
10.2 : 00100002********
10.2.0 : 001000020000****
10.2.1.0 : 0010000200010000
10.2.1.1 : 0010000200010001
10.3 : 00100003********
10.3.0 : 001000030000****
11.1.1.0 : 0011000100010000