[求助]确保字符串是1-100的数，怎么写正则？

Question

确保字符串是1-100的数，怎么写正则？
可以是001,098。

Answer 1

int a = nextInt(99)+1;
String s = a;
记住调用包java.util.Random

Answer 2

String s = "0*\\d*[1-9]|100";
String s1 = "099";
if(s1.matches(s)) {
System.out.println("ok");
}

Answer 3

String s = "(0{1,2})?((?!\\d{2})|((?<!0)|(?<=^0)))([1-9]\\d?)|100";
        System.out.println("1".matches(s));//true
System.out.println("12".matches(s));//true
System.out.println("01".matches(s));//true
System.out.println("001".matches(s));//true
System.out.println("013".matches(s));//true
System.out.println("0014".matches(s));//false
System.out.println("100".matches(s));//true
System.out.println("0100".matches(s));//false
System.out.println("0".matches(s));//false

Answer 4

借用 joejoe1991 的数据测试一下public class Test {
    public static void main(String[] args) {
        String regex = "(?!^0?0?0$)[01]?[0-9]?[0-9]";
        System.out.println("1".matches(regex));
        System.out.println("12".matches(regex));
        System.out.println("01".matches(regex));
        System.out.println("001".matches(regex));
        System.out.println("013".matches(regex));
        System.out.println("0014".matches(regex));
        System.out.println("100".matches(regex));
        System.out.println("0100".matches(regex));
        System.out.println("0".matches(regex));
    }
}

Answer 5

sorry
String s ="0?\\d?[1-9]|100";

Answer 6

我在 6 楼的写错了，不好意思，改一下哈：String regex = "(?!^0?0?0$)(?:0?[0-9]?[0-9]|100)";否则得匹配 101～199 了。
(?!^0?0?0$)：lookahead 后视功能，不允许后面出现的字符。这里 后面不允许出现 0，00，000，
这样可以把 0 给排除掉，必须加 ^ $ 让其作用于整个字符串。(?:0?[0-9]?[0-9]|100)：(?:) 非捕获组，用于选择结构（|）的分隔，数字后的 ? 表示可有可无，
以满足百位和十位上的数字，最后一个 [0-9] 即个位数字，必须存在。

Answer 7

(?!^0?0?0$)也是非捕获组吧,(?:X) X，作为非捕获组 
(?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on - off 
(?idmsux-idmsux:X)   X，作为带有给定标志 i d m s u x on - off 
的非捕获组  (?=X) X，通过零宽度的正 lookahead 
(?!X) X，通过零宽度的负 lookahead 
(?<=X) X，通过零宽度的正 lookbehind 
(?<!X) X，通过零宽度的负 lookbehind 
(?>X) X，作为独立的非捕获组 看完这个之后,没明白

Answer 8

谢谢!
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
String a = i + "";
String b = "0" + i;
String c = "00" + i;
isMatch(a);
isMatch(b);
isMatch(c);
}
} public static void isMatch(String s) {
String regex = "(?!^0?0?0$)(?:0?[0-9]?[0-9]|100)";
if (!s.matches(regex)) {
System.out.println(s + "失败");
}
}

Answer 9

(?:X) X，作为非捕获组  
这个我不太理解它的意图和下面的写法有区别吗?请教各位. public static void main(String[] args) {
for (int i = 0; i <= 100; i++) {
String a = i + "";
String b = "0" + i;
String c = "00" + i;
isMatch(a);
isMatch(b);
isMatch(c);
}
} public static void isMatch(String s) {
String regex = "(?!^0?0?0$)((0?[0-9]?[0-9])|100)";
if (!s.matches(regex)) {
System.out.println(s + "失败");
}
}

Answer 10

以 (? 开头，) 结尾的都称为非捕获组，在匹配完成后在内存中不保留匹配到的字符。非捕获组的应用比较复杂，这里只能简单地说一下它们的意思。(?:X) X，作为非捕获组
与捕获组 ( ) 的意思一样也是将其作为一组进行处理，与捕获组的区别在于不捕获匹配的文本，
仅仅作为分组。
比如：要匹配 123123 这个，就可以写为 (123)\1 使用反向引用，这时只能用捕获组，在匹配
123 后会保留在内存中，便于反向引用，而 (?:123) 在匹配完后则不会保留，区别仅在于此。(?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on - off
用于标志匹配，比如：表达式 (?i)abc(?-i)def 这时，(?i) 打开不区分大小写开关，abc 匹配
不区分大小地进行匹配，(?-i) 关闭标志，恢复不区分大小写，这时的 def 只能匹配 def(?idmsux-idmsux:X)   X，作为带有给定标志 i d m s u x on - off 
与上面的类似，上面的表达式，可以改写成为：(?i:abc)def，或者 (?i)abc(?-i:def)(?=X) X，通过零宽度的正 lookahead 
(?!X) X，通过零宽度的负 lookahead
(?=X) 表示当前位置（即字符的缝隙）后面允许出现的字符，比如：表示式 a(?=b)，在字符串为
ab 时，可能匹配 a，后面的 (?=b) 表示，a 后面的缝隙，可以看作是零宽度。
(?!X) 表示当前位置后面不允许出现的字符(?<=X) X，通过零宽度的正 lookbehind 
(?<!X) X，通过零宽度的负 lookbehind
这两个与上面两个类似，上面两个是向后看，这个是向前看(?>X) X，作为独立的非捕获组
匹配成功不进行回溯，这个比较复杂，也侵占量词“+”可以通用，比如：\d++ 可以写为 (?>\d+)。

Answer 11

从匹配结果上来看完全一样。String regex = "(?!^0?0?0$)((0?[0-9]?[0-9])|100)";逐个来看，(0?[0-9]?[0-9]) 可以改成 (0?[0-9]?[0-9]|100)，| 在一组里面
进行分隔，所以 (0?[0-9]?[0-9]) 这一对括号可以去掉，举几个例子。ab|c     这样匹配 ab 或者 c
a(b|c)   这样匹配 ab 或者 ac
a(bb|c)  这样匹配 abb 或者 ac
a(bb|cc) 这样匹配 abb 或者 acc再有，由于所匹配的东西并不需要在内存中保留，为了效率起见，可以改为 
(?:0?[0-9]?[0-9]|100) 这样(0?[0-9]?[0-9]|100) 这个使用了捕获组的方式，表示在匹配完成后，在内存中会保留匹配
到的东西，便于后面的反向引用（就像 \1 这样的反向引用）。而 (?: 在匹配完后并不会在内存中保留，由于这里没有反向引用，只是一个简单的匹配，所以说
没有必要保留起来，节省几个字节的内存 ：）

Answer 12

有这个帖子里有一些正则表达式的资源，有兴趣的话可以去看看http://topic.csdn.net/u/20080306/17/f37a1818-3968-49b4-8f79-e5564486d63e.html

Answer 13

(?>X) X，作为独立的非捕获组 
匹配成功不进行回溯，这个比较复杂，也侵占量词“+”可以通用，比如：\d++ 可以写为 (?>\d+)。这个我没有明白啊 。。

Answer 14

包括0，00，000：String reg = "^(0?[\d]{1,2})|(100)$";不包括0，00，000的写法会复杂些~

Answer 15

String reg = "^(0?[\d]{1,2})|(100)$";这个改成String reg = "0?[\d]{1,2}|100";这样效果是一样的，在未指定 multiline 模式时，^ $ 的作用与 \A \Z 的作用完全一致，
表示输入的开头和结束，在启用 multiline 时，^ $ 表示一行的开始和结束。如果用于单行的 matches 匹配，^ $ 写与不写是一个样的。String regex = "(?!^0?0?0$)(?:0?[0-9]?[0-9]|100)";
但是，上面的 (?!^0?0?0$) 中的 ^ $ 就必须写了，以限定整个字符串的匹配，如果
写成(?!0?0?0$) 这样，像 10（最后一个为“0”）也会匹配失败的，如果写成
(?!^0?0?0) 这样，像 015（以“0”开始的）也将匹配失败。

Answer 16

String reg = "0?[\d]{1,2}|100";而且这个也不对，应为 String reg = "0?[\\d]{1,2}|100";在只有一种情况下时不应使用 [\\d] 的字符类，应该直接写成 \\d{1,2} 或者 [0-9]{1,2}

Answer 17

大多数情况下不需要使用 ^ $，除非你需要限定开头或结束，像 JavaScript 中为 String 增加一个 trim 方法，就要用到 ^ 和 $，表示把开头
所有的空格和结束处所有的空格都替换去掉。String.prototype.trim = function() {
    return this.replace(/^\s+/, "").replace(/\s+$/, "");
}

Answer 18

这样的话不是可以匹配'0'啊,这样就不满足这个题目需求了吧,我觉得还是String regex = "(?!^0?0?0$)(?:0?[0-9]?[0-9]|100)";比较好!之前我写的也有不少漏洞!

Answer 19

javascript 貌似和java有一点点不同吧有些人写出的表达式里面全是/ 写js的表达式时在/上有点迷糊,我一直这么干比你多个/g不知道何解
function trim(str) {
     return str.replace(/(^\s*)|(\s*$)/g,"");
}

Answer 20

JavaScript 中的标志共有 m g i 三个，可以混合着使用g 表示全局替换，否则只替换一次m 表示多行模式，有这个标志时 ^ $ 可以匹配一行的开头和一行的结束，否则只匹配输入的开头和结束i 表示不区分大小写进行匹配

Answer 21

bao110908  太热心了,十分感谢,今天学习了不少正则知识,嘿嘿,睡觉了,明天就要上班了,噢噢噢噢.

Answer 22

直接转成Integer 比比大小 就ok了

Answer 23

请教一下：
1、(?=) (?!) 可以限制后面的？怎么有时候也看到(?=) (?!) 放在正则表达式的末尾呢？
如果这样写，是什么意思呢？
String regex = "(?!^0?0?0$)(?:0?[0-9]?[0-9]|100)";
2、lookbehind和lookahead区别是什么？是不是指限制前面或者后面的字符？

Answer 24

学习正则有段时间了，但是今天看了火龙果兄的好几个帖子，才发现自己对正则的理解还远远不够。
其实对于正则的描述，Java API上都有。不过自己没有过多深入地去理解分析，加上没有代码示例，增加了理解上的困难。
几乎所有的火龙果兄的回帖里，都会针对对应的概念举出对应的例子，让我理解起来快上很多。
今天看了好多帖子了，不回都不好意思了。
非常感谢！

Answer 25

\b[0]*(100|[0-9][0-9]|[1-9])\b
JavaString s = "\\b[0]*(100|[0-9][0-9]|[1-9])\\b"

Answer 26

如果不需要定界，
[0]*(100|[0-9][0-9]|[1-9])String s = "[0]*(100|[0-9][0-9]|[1-9])";

Answer 27

String regex = "00\\d||0\\d{1,2}||100||\\d{1,2}";
String s = "001";
System.out.println(s.matches(regex));

Answer 28

(?!^0?0?0$)(?:0?[0-9]?[0-9]|100)
会匹配到0，50楼也是。试试这个String s = "0*(100|[1-9][0-9]|[1-9])";