4

我有以下模式定义：

private static final String D = "(Mon|Tue|Wed|Thu|Fri|Sat|Sun)";
private static final String DD = "(" + D + "-" + D + ")";
private static final String m_daysPattern = "(" + D + "|" + DD + ")(?:,(" + D + "|" + DD + "))*";
private static final Pattern m_daysRegex = Pattern.compile(m_daysPattern);

此正则表达式应匹配如下表达式：

  • “周一至周五”
  • “周二至周五，周日”
  • “周一至周三，周五至周日”

我在 .NET 中使用命名组很容易做到这一点，但在 Java 6 中我有点迷茫。谁能给我看一个代码示例，它可以让我提取日期并准确理解给定表达式中提到的范围和单日？

谢谢。

编辑1

好的，这是我检查以下组的结果m_daysRegex.matcher("Mon-Fri")：

matchDays.groupCount() = 10
matchDays.groups = [0,7,0,7,-1,-1,0,7,0,3,4,7,-1,...,-1] (22 values)
matchDays.group(0) = "Mon-Fri"
matchDays.group(1) = "Mon-Fri"
matchDays.group(2) = null
matchDays.group(3) = "Mon-Fri"
matchDays.group(4) = "Mon"
matchDays.group(5) = "Fri"
matchDays.group(6) = null
matchDays.group(7) = null
matchDays.group(8) = null
matchDays.group(9) = null
matchDays.group(10) = null

有人可以向我解释这一切的逻辑吗？我的意思是我不仅应该得到“Mon”和“Fri”，而且我还必须知道它们是范围子表达式“Mon-Fri”的一部分，而不仅仅是“Mon,Fri”。

顺便说一句，匹配 "Mon,Fri" 给了我们这个：

matchDays.groupCount() = 10
matchDays.groups = [0,7,0,3,0,3,-1,-1,-1,-1,-1,-1,4,7,4,7,-1,...,-1] (22 values)
matchDays.group(0) = "Mon,Fri"
matchDays.group(1) = "Mon"
matchDays.group(2) = "Mon"
matchDays.group(3) = null
matchDays.group(4) = null
matchDays.group(5) = null
matchDays.group(6) = "Fri"
matchDays.group(7) = "Fri"
matchDays.group(8) = null
matchDays.group(9) = null
matchDays.group(10) = null

这是不同的，这很好。我仍然觉得很难理解这个算法。

这在 .NET 中很容易，所以我期待在 Java 中也能做到这一点。公平，不是吗？

编辑2

是否有解释这些内容的 Java 正则表达式指南？到目前为止，我看到的所有指南都检查了非常简单的正则表达式。

编辑3

好的，我开始明白了。我的正则表达式可以这样描述：

 (          // 1 = D1|D2-D3
  (D1)|     // 2 = D1
  (         // 3 = D2-D3
   (D2)-    // 4 = D2
   (D3)     // 5 = D3
  )
 )
 (?:,
  (         // 6 = D4|D5-D6
   (D4)|    // 7 = D4
   (        // 8 = D5-D6
    (D5)-   // 9 = D5
    (D6)    // 10 = D6
   )
  )
 )*

它解释了“Mon-Fri”和“Mon,Fri”的组值。但是如何处理重复？例如，“周一、周三、周五”？仍在试图弄清楚。

编辑4

我现在明白了。我可以将复杂的正则表达式与重复匹配，但我无法轻松提取相应的匹配项 - 必须使用该find()方法和更简单的子正则表达式进行迭代。所以，就我而言，我决定：

  1. 匹配整个表达式以确保它有效
  2. 用'，'分割它（StringUtils.split来自apache）
  3. 迭代拆分部分，必要时用“-”拆分。

感谢所有善良的撒玛利亚人提供的所有帮助。

4

2 回答 2

1

有关捕获组等的描述，请访问此处：http ://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html

至于你的模式，如果你写出所有的括号，你会得到：

((d)|((d)-(d)))(?:,((d)|((d)-(d))))*

其中 d 是

Mon|Tue|...

列出组，使用 M 显示属于给定组的部分：

 0 - the matching string, if there is one
 1 - ((M)|((M)-(M)))(?:,((d)|((d)-(d))))*
 2 - ((M)|((d)-(d)))(?:,((d)|((d)-(d))))*
 3 - ((d)|((M)-(M)))(?:,((d)|((d)-(d))))*
 4 - ((d)|((M)-(d)))(?:,((d)|((d)-(d))))*
 5 - ((d)|((d)-(M)))(?:,((d)|((d)-(d))))*
 6 - ((d)|((d)-(d)))(?:,((M)|((M)-(M))))*
 7 - ((d)|((d)-(d)))(?:,((M)|((d)-(d))))*
 8 - ((d)|((d)-(d)))(?:,((d)|((M)-(M))))*
 9 - ((d)|((d)-(d)))(?:,((d)|((M)-(d))))*
10 - ((d)|((d)-(d)))(?:,((d)|((d)-(M))))*

给定字符串“Mon-Fri”，您将获得在输出中看到的字符串，即

 0 - Mon-Fri i.e. the full match
 1 - Mon-Fri i.e. ((M)|((M)-(M)))
 2 - null i.e. not matched by (M)
 3 - Mon-Fri i.e. ((M)-(M))
 4 - Mon i.e. the first (M) in group 3
 5 - Fri i.e. the second (M) in group 3
 6 - and so on...

对于多场比赛，你会做类似的事情

Matcher m = pattern.matcher(input);
while (m.find()) {
    // extract groups from m
}

编辑：想想看，你可能不需要最后一部分，即

(?:,((d)|((d)-(d))))*

在你的模式中。只需将 while 循环与

(d)|((d)-(d))

模式来查找每个部分（即逗号之间的内容）。

于 2012-08-10T11:14:44.457 回答
0

java 正则表达式中的组是使用索引访问的，索引是左括号的计数器。

这是一个适用于 java 组的示例（我之前做过的一些事情）。希望这可以帮助。

/**
 * <li>range={0,2} -&gt; 0 to 2 
 * <li>range={3,n} -&gt; 3 to Integer.MAX_VALUE
 * <li>range={7} -&gt; 0 to 7
 * <li>range={n} -&gt; 0 to Integer.MAX_VALUE
 * <li>range={-n} -&gt; Integer.MIN_VALUE to 0
 */
@Test
public void getRange() {
    Pattern p = Pattern.compile(
        "\\{" +
        "([+-]?(n|[0-9])){1}" + // group 1
        "(" +
        "(,){1}" +
        "([+-]?(n|[0-9])){1}" + // group 5
        "){0,1}" +
        "\\}");

    Matcher m = null;
    String range = null;

    logger.debug("pattern: " + p.pattern());

    range = "{0,2}";
    m = p.matcher(range);
    logger.debug(range + " -> groupCout: " + m.groupCount());
    printGroups(m);
    Assert.assertEquals("0", m.group(1));
    Assert.assertEquals("2", m.group(5));

    range = "{3,n}";
    m = p.matcher(range);
    logger.debug(range + " -> groupCout: " + m.groupCount());
    printGroups(m);
    Assert.assertEquals("3", m.group(1));
    Assert.assertEquals("n", m.group(5));

    range = "{7}";
    m = p.matcher(range);
    logger.debug(range + " -> groupCout: " + m.groupCount());
    printGroups(m);
    Assert.assertEquals("7", m.group(1));
    Assert.assertEquals(null, m.group(5));

    range = "{n}";
    m = p.matcher(range);
    logger.debug(range + " -> groupCout: " + m.groupCount());
    printGroups(m);
    Assert.assertEquals("n", m.group(1));
    Assert.assertEquals(null, m.group(5));

    range = "{-3,-7}";
    m = p.matcher(range);
    logger.debug(range + " -> groupCout: " + m.groupCount());
    printGroups(m);
    Assert.assertEquals("-3", m.group(1));
    Assert.assertEquals("-7", m.group(5));
}

private void printGroups(Matcher m) {
    if(m != null && m.matches()) {
        for(int i = 0; i < m.groupCount()+1; i++) {
            logger.debug("group " + i + ": " + m.group(i));

        }   
    }
}
于 2012-08-09T22:40:06.907 回答