这种能有办法写出来吗?正则高手进啊

Question

如何用正则或者其他办法在字符串中,中获得123
name（任意一个符号或者没有符号）[123](空格或者没有符号)例如
test [adfa] name:[123] name[456]
返回 123，456test [adfa] name:a[123] name[456]
返回 456
test [adfa] name:[123]name[456]
返回  123，456

Answer 1

"name[\\s\\S]*(\\[\\d+\\])"取group(1)就是你要的

Answer 2

晕,[\\s\\S]*少了最小模式,应该是
"name[\\s\\S]*?(\\[\\d+\\])"

Answer 3

public static void main(String[] args) throws Exception{
Pattern p = Pattern.compile("name[\\s\\S]*?(\\[\\d+\\])");
Matcher m = p.matcher("test [adfa] name:a[123] name[456] ");
while(m.find())
System.out.println(m.group(1));

}结果:
123
456

Answer 4

name[\\p{ASCII}]?\\[([\\d]*)\\]同样取group

Answer 5

这个结果有点问题哦.  你匹配的这个式子跟 楼主要求的刚好不一样.   这个的结果只有456 . import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegWord { public static void main(String[] args) throws Exception {
Pattern p = Pattern.compile("name[\\p{ASCII}]?\\[([\\d]*)\\]");
Matcher m = p.matcher("test [adfa] name:a[123]name[456]");//第二个表达式.
while (m.find())
System.out.println(m.group(1)); }}结果:
456import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegWord { public static void main(String[] args) throws Exception {
Pattern p = Pattern.compile("name[\\p{ASCII}]?\\[([\\d]*)\\]");
Matcher m = p.matcher("test [adfa] name:[123] name[456] ");//第一个表达式.
while (m.find())
System.out.println(m.group(1)); }}结果:
123
456

Answer 6

String str = "test [adfa] name:[345] name[789]";
Pattern pattern = Pattern.compile("name[\\p{Punct}]?\\[([^\\]]*)\\]");
Matcher matcher = pattern.matcher(str);

while (matcher.find())
{
    System.out.println(matcher.group(1));
}
name后可以有任意一个或没有符号
name后面[]中的值可以不仅仅为数字

Answer 7

多了一个*
Pattern p = Pattern.compile("name[\\s\\S]?(\\[\\d+\\])"); 
代码：
public static void main(String[] args) throws Exception{ 
Pattern p = Pattern.compile("name[\\s\\S]?(\\[\\d+\\])"); 
Matcher m = p.matcher("test [adfa] name:a[123] name[456] "); 
while(m.find()) 
System.out.println(m.group(1)); } 

Answer 8

public static void main(String[] args) throws Exception{ 
Pattern p = Pattern.compile("name[\\s\\S]*?(\\[\\d+\\])"); 
Matcher m = p.matcher("test [adfa] name:a[123] name[456] "); 
while(m.find()) 
System.out.println(m.group(1)); } 结果: 
123 
456

Answer 9

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Test {
    
    public static void main(String[] args) {        String str = "test [adfa] name:[123] name[234] " +
                "test [adfa] name:a[345] name[456]\n" +
                "test [adfa] name:[567]name[678]";        String regex = "name[^\\[]?\\[([0-9]+)\\]";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            System.out.println(matcher.group(1));
        }        
    }
}还有一点不明白是：name（任意一个符号或者没有符号）[123](空格或者没有符号) test [adfa] name:[123]name[456]
返回  123，456既然“[xxx]”后面只允许空格或者是没有符号，但是这个 [123] 后面有东西啊？
可能我没理解“符号”表示的是啥，呵呵。不过按照你提供的示例，上面的代码可以用的。如果有问题的话，请回复说明。

Answer 10

谢谢啊可是好象不行啊!遇到中文就不行了啊!
name（任意一个符号或者没有符号）[123](空格或者没有符号) 的意思是:
"name" + "任意的一个符号(如:冒号\逗号\划线等)+ "中括号"+"任意字符" + "中括号" 后面的"(空格或者没有符号)"这句写的多余了!
String str1 = "name [adfa] name:[中] name[456] ";这个应该返回adf,中,456

Answer 11

嘿嘿，问正则的问题一直就是这样的，在帖子内容中不说清楚，等别人回复了 N 多的
东西之后，现在跑出个方括号里面出来汉字了！希望楼主能说得再详细一些，争取一次解决掉，不要像这个帖子
http://topic.csdn.net/u/20080610/17/15b8828c-43d5-43c5-803e-1f4d51ffb213.html
一样，全部写好后又提出新的东西！
任意的一个符号(如:冒号\逗号\划线等)请不要使用“等”之类的字眼，正则表达式不认识这个字！你得明确具体是些什么符号？
我认为是指除了字母、[、] 之外的其他字符。
题外话：希望提问正则表达式的帖子至少能达到下面的要求：1，正则表达式是一种模式匹配，是根据字符串的规律来操作的，因此需要详细地说明具体要做些什么；
2，对于查找的问题，详细说明寻找字符串的特征是什么，这些字符串的边界是什么，或者说有些什么规律；
3，对于替换的问题，详细说明原串是什么，替换后是什么，或者说有些什么规律；
4，对于验证的问题，详细说明验证的格式是什么；
4，举两三个覆盖范围尽可能广的示例。

Answer 12

如果name后面还能有空格的话就要稍微改一下
Pattern.compile("name[\\p{Punct}\\s]?\\[([^\\]]*)\\]");

Answer 13

[\\s\\S] 这是 JavaScript 中的写法，因为在 JavaScript 中没有 DOTALL 模式，
但在 Java 中一般不这么写，为了提高正则表达式引擎的匹配效率，可以使用 . 代
替，同时在表达式的前面加上内嵌标志 (?s)，或者在 Pattern 编译时加上
Pattern.DOTALL 参数，这时 . 就能匹配行结束符了。另外，量词使用也是不正确的，楼主需要“一个或者没有”，直接使用贪婪的 ? 就行
了，没有必要去使用懒惰的 * 量词。

Answer 14

对不起确实可以啊!只是我看 "怎么那么多人胡说八道呢" 有人这么说以为不能运行呢!对不起啊
不过我没看明白[\\p{Punct}]?\\[([^\\]]*)\\][\\p{Punct}]?是匹配 标点符号 0次或者1次接着你写\\是什么意思没需要匹配\啊然后匹配[然后又是
([^\\]]*)看不明白了能解释下吗?

Answer 15

后面的\\[ 表示name+任意符号或没有符号的后面必须+"["
再后面的([^\\]]*)就表示中括号里的内容但不包括"]"，有"]"就表示结束了

Answer 16

\\[([^\\]]*)\\]后面这段要这么看是吗?
\\[ 表示必须以"["开始?不能直接写"["吗?([^\\]]*) 这个什么意思?获取满足[^\\]]*的这一个匹配!这样写后面才可以用group获取?
那这句具体什么意思啊!一点没看明白\\] 表示必须以"]"开始?不能直接写"]"吗?

Answer 17

public static void main(String[] args) throws Exception{ 
Pattern p = Pattern.compile("name[\\s\\S]*?(\\[\\d+\\])"); 
Matcher m = p.matcher("test [adfa] name:a[123] name[456] "); 
while(m.find()) 
System.out.println(m.group(1)); } 

Answer 18

还有点问题啊!
如果是
name[test1[测试]test1]这样的数据
应该得到:test1[测试]test1
结果只能得到[test1[测试]

Answer 19

这样好象不是很好写啊
如果是 name[test1[测试]
那要匹配什么出来呢? 

Answer 20

name[test1[测试]test1]这样的数据 应该得到:test1[测试]test1 

Answer 21

怎么还是有人胡说八道呢?
楼主的例子"test [adfa] name:a[123] name[456] "你去掉*看看.
至于楼主说的多了[],这也太那个了吧,你把()放到[]里不就行了."name[\\s\\S]*?\\[(\\d+)\\]"
至于你说的[]中是中文就不行了,你开始提的都是数字,当然是\\d+,如果你还有其它字符改一下成\\S+

Answer 22

"name[\\s\\S]*?\\[(\\S+)\\]" 这个正则,下面这个就不行啊
name[555 测试]

Answer 23

我晕,你那个555和测试之间又加了空格,这和你原来说的一样?
改成
"name[\\s\\S]*?\\[([\\s\\S]+)\\]" 

Answer 24

这种嵌套格式的正则，在 Java 中做不到，除非有确定的层数。

Answer 25

允许嵌套一层的，可以这样：import java.util.regex.Matcher;
import java.util.regex.Pattern;public class JpaTest {    public static void main(String[] args) {
        String str = "test [adfa] name:[123] name[234] " +
                "test [adfa] name:a[345] name[456]\n" +
                "test [adfa] name:[567 中]name[678 [测试] 78]";
        
        String regex = "name[^\\[a-zA-Z0-9]?\\[((?:[^\\[\\]]|(?:\\[[^\\]]*\\]))+)\\]";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            System.out.println(matcher.group(1));
        }   
    }
}输出：123
234
456
567 中
678 [测试] 78

Answer 26

上面的那个有个小问题，改正一下，顺便在 * 后面加上 + 以提高效率：
String regex = "name[^\\[a-zA-Z0-9]?\\[((?:[^\\[\\]]|(?:\\[[^\\[\\]]*+\\]))*+)\\]";如果需要匹配 [] 中是空的，可以改成这样：
String regex = "name[^\\[a-zA-Z0-9]?\\[((?:[^\\[\\]]|(?:\\[[^\\[\\]]*+\\]))*+)\\]";如果需要嵌套两层的，得改成这样，嵌套层数越多，表达式越复杂。
.net 的正则表达式含有平衡组的语法，实现这种嵌套的处理就能很方便，可惜 Java 中不支持。
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class JpaTest {    public static void main(String[] args) {
        String str = "test [adfa] name:[123] name[234] " +
                "test [adfa] name:a[345] name[456]\n" +
                "test [adfa] name:[567[测试 [测试]] 中]name[678 [测试] 78]";
        String regex = "name[^\\[a-zA-Z0-9]?\\[((?:[^\\[\\]]|(?:\\[(?:[^\\[\\]]|(?:\\[[^\\[\\]]*+\\]))*+\\]))*+)\\]";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            System.out.println(matcher.group(1));
        }   
    }
}输出：123
234
456
567[测试 [测试]] 中
678 [测试] 78

Answer 27

 by jianghuxiaoxiami
尾随火龙果

Answer 28

把 31 楼的代码加上了注释，可以看得更清楚一些。import java.util.regex.Matcher;
import java.util.regex.Pattern;public class JpaTest {    public static void main(String[] args) {
        String str = "test [adfa] name:[123] name[234] " +
                "test [adfa] name:a[345] name[456]\n" +
                "test [adfa] name:[567[测试 [测试]] 中]name[678 [测试] 78]";
        
        // String regex = "name[^\\[a-zA-Z0-9]?\\[((?:[^\\[\\]]|(?:\\[[^\\]]*+\\]))*+)\\]";
        String regex = 
            "(?x:                               ## 启用行注释模式                   \n" +
            "    \\bname                        ## 以 name 开头                     \n" +
            "    [^\\[a-zA-Z0-9]?               ## 除了 [, 字母, 数字外的其他字符   \n" +
            "    \\[                            ## 以 [ 开头                        \n" +
            "    (                              ## 捕获组开始                       \n" +
            "     (?:                                                               \n" +
            "       [^\\[\\]]                   ## 非嵌套中的字符（除 [  ] 之外的） \n" +
            "       |                                                               \n" +
            "       (?:                         ## 开始处理第一层嵌套中的字符       \n" +
            "          \\[                      ## 第一层嵌套的开始字符 [           \n" +
            "             (?:                   ## 开始处理第二层嵌套中的字符       \n" +
            "                [^\\[\\]]          ## 第一层嵌套中的字符               \n" +
            "                |                                                      \n" +
            "                (?:                ## 开始处理第二层嵌套中的字符       \n" +
            "                   \\[             ## 第二层嵌套的开始字符 [           \n" +
            "                      [^\\[\\]]*+  ## 第二层嵌套中的字符               \n" +
            "                   \\]             ## 第二层嵌套的结束字符 ]           \n" +
            "                )                  ## 第二层嵌套结束                   \n" +
            "             )*+                   ## 第二层嵌套中的字符处理结束       \n" +
            "          \\]                      ## 第一层嵌套的结束字符 ]           \n" +
            "       )                           ## 第一层嵌套中的字符处理结束       \n" +
            "    )*+                            ## 指定 [ ] 中的字符的数量          \n" +
            "   )                               ## 捕获组结束                       \n" +
            "   \\]                                                                 \n" +
            ")";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            System.out.println(matcher.group(1));
        }   
    }
}