使用模式匹配器的Java正则表达式没有正确返回？

我必须从以下字符串中获取索引值：

Home.number[12].parent. 

我想得到12的值

以下是我尝试过的：

//escape . / [ ]
 private static final String pattern = "Home\\.number\\[([0-9]*)\\]*";
 private static final Pattern addressPattern = Pattern.compile(pattern);

   private static int getIndex(String input, Pattern pattern){

        Matcher m = pattern.matcher(input);
        if (m.matches()){
        return Integer.valueOf(m.group(2));
        }
        return -1;
    }

    public static void main(String[] args){

    System.out.println(getIndex("Home.number[123].parent", addressPattern);
    System.out.println(getIndex("Home.number[456].child", addressPattern);   
}

我返回了两个的

-1

，这意味着找不到匹配项

使用调试器，我发现

m.matches（）

返回

false

。 我不知道为什么

附言：我还尝试使用

Pattern.quote（“Home.number[（[0-9]*]）*”

和

StringUtils.EscapeJava（“Home.number[（[0-9]*）]）*”

。两者都没有返回任何匹配结果

将模式从：

“Home\\.number\\[（[0-9]*）\]*”

更改为

“Home\\.number\\[（[0-9]+）\].*”

（在最后一个

*

之前添加点）

将组更改为#1:

返回Integer.valueOf（m.group（1））

将右括号添加到

System.out.println（）调用中

像这样：

private static final String pattern = "Home\\.number\\[([0-9]*)\\].*";
private static final Pattern addressPattern = Pattern.compile(pattern);

private static int getIndex(String input, Pattern pattern){
  Matcher m = pattern.matcher(input);
  if (m.matches()){
    return Integer.valueOf(m.group(1));
  }
  return -1;
}

public static void main( String[] args ){
  System.out.println(getIndex("Home.number[123].parent", addressPattern));
  System.out.println(getIndex("Home.number[456].child", addressPattern));   
}

将模式从：

“Home\\.number\\[（[0-9]*）\]*”

更改为

“Home\\.number\\[（[0-9]+）\].*”

（在最后一个

*

之前添加点）

将组更改为#1:

返回Integer.valueOf（m.group（1））

将右括号添加到

System.out.println（）调用中

像这样：

private static final String pattern = "Home\\.number\\[([0-9]*)\\].*";
private static final Pattern addressPattern = Pattern.compile(pattern);

private static int getIndex(String input, Pattern pattern){
  Matcher m = pattern.matcher(input);
  if (m.matches()){
    return Integer.valueOf(m.group(1));
  }
  return -1;
}

public static void main( String[] args ){
  System.out.println(getIndex("Home.number[123].parent", addressPattern));
  System.out.println(getIndex("Home.number[456].child", addressPattern));   
}

你的头发应该看起来像

private static final String pattern = "Home\\.number\\[(\\d+)\\]\\..*";
private static final Pattern addressPattern = Pattern.compile(pattern);

public static void main(String[] args) {
    System.out.println(getIndex("Home.number[123].parent", addressPattern));
    System.out.println(getIndex("Home.number[456].child", addressPattern));
}

您的配对者只有

1

组

private static int getIndex(String input, Pattern pattern) {
    Matcher m = pattern.matcher(input);
    if (m.matches()) {
        return Integer.parseInt(m.group(1));
    }
    return -1;
}

您需要在

main

中关闭调用中的第二个参数。差不多

private static final String pattern = "Home\\.number\\[(\\d+)\\]\\..*";
private static final Pattern addressPattern = Pattern.compile(pattern);

public static void main(String[] args) {
    System.out.println(getIndex("Home.number[123].parent", addressPattern));
    System.out.println(getIndex("Home.number[456].child", addressPattern));
}

当我做出这些改变时，我得到了预期的结果

123
456

你的头发应该看起来像

private static final String pattern = "Home\\.number\\[(\\d+)\\]\\..*";
private static final Pattern addressPattern = Pattern.compile(pattern);

public static void main(String[] args) {
    System.out.println(getIndex("Home.number[123].parent", addressPattern));
    System.out.println(getIndex("Home.number[456].child", addressPattern));
}

您的配对者只有

1

组

private static int getIndex(String input, Pattern pattern) {
    Matcher m = pattern.matcher(input);
    if (m.matches()) {
        return Integer.parseInt(m.group(1));
    }
    return -1;
}

您需要在

main

中关闭调用中的第二个参数。差不多

private static final String pattern = "Home\\.number\\[(\\d+)\\]\\..*";
private static final Pattern addressPattern = Pattern.compile(pattern);

public static void main(String[] args) {
    System.out.println(getIndex("Home.number[123].parent", addressPattern));
    System.out.println(getIndex("Home.number[456].child", addressPattern));
}

当我做出这些改变时，我得到了预期的结果

123
456

---

如果删除除方括号之间的内容以外的所有内容，可以在一行中完成：

private static int getIndex(String input) {
    return input.matches(".*\\[\\d+].*") ? -1 : Integer.parseInt(input.replaceAll(".*\\[|].*", ""));
}

---

如果删除除方括号之间的内容以外的所有内容，可以在一行中完成：

private static int getIndex(String input) {
    return input.matches(".*\\[\\d+].*") ? -1 : Integer.parseInt(input.replaceAll(".*\\[|].*", ""));
}

---

我将作为方法参数传递。因此，如果出现

Home.number[].parent

，则此代码将失败<代码>[0-9]*->

[0-9]+

或

\\d+

我作为方法参数传递。因此，如果出现

Home.number[].parent

，则此代码将失败<代码>[0-9]*->

[0-9]+

或

\\d+

是否不需要在“Home.number”中转义圆点？转义圆点确实有效-如果不转义，则可以匹配

HomeXnumber[123]。表兄

您建议的方法很有效。我有两个问题。一种是在

“].*.

的末尾替换点和缺少的点。感谢Tony，您希望最后一个点不被转义（因为它需要匹配字符串的其余部分），但第一个点需要转义（因为您希望匹配句号而不是任何字符）。

Home\\\\\\\[（\\d+\\\].*

或

Home\\\\\[（\\d+\\\]\\\\\\\\\\\.*

将匹配。是否不需要在“Home.number”中转义圆点？转义圆点确实有效-如果不转义，则可以匹配

HomeXnumber[123]。堂兄

您建议的效果很好。我有两个问题。一种是在

“].*.

的末尾替换点和缺少的点。感谢Tony，您希望最后一个点不被转义（因为它需要匹配字符串的其余部分），但第一个点需要转义（因为您希望匹配句号而不是任何字符）。

Home\\\\\\\[（\\d+\\\].*

或

Home\\\\\\\[（\\d+\\\]\\\\\\\\\\.*

将匹配。@MTO-hmmm.很好。我已经替换了正则表达式，只保留了括号之间的内容，并且我还检查了括号之间是否只有数字。@MTO-hmmm。说得好。我已经替换了正则表达式，只保留了括号之间的内容，我还检查了括号之间是否只有数字。