Question

我有以下模式定义：

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中我有点迷失。任何人都可以向我展示一个代码示例，这将允许我提取日期并准确了解给定表达式中提到的范围和单日？

感谢。

EDIT1

好的，这是我检查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

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

BTW，匹配“周一，周五”给了我们这个：

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中的一些简单。公平，不是吗？

EDIT2

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

EDIT3

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

 (          // 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
   )
  )
 )*

它解释了“周一至周五”和“周一，周五”的群组价值。但是如何处理重复？例如，“周一，周三，周五”？还是想弄清楚。

EDIT4

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

匹配整个表达式以确保其有效
通过'，'

StringUtils.split

迭代分割部分，必要时按' - '分割。

感谢所有善良的撒玛利亚人在那里寻求帮助。

Answer 1

有关捕获组等的说明，请转到此处：http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html

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

((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))

找到每个部分的模式（即逗号之间的东西）。

Answer 2

使用索引访问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));

        }   
    }
}

Java：如何使用Pattern类提取表达式的片段？

2 个答案: