精华内容
下载资源
问答
  • Java正则表达式

    2021-07-10 20:21:28
    Java正则表达式

    正则表达式原理

    底层是使用有限状态自动机,又分确定型有限状态自动机(DFA)和非确定型有限状态自动机(NFA),这两种状态机的能力是一样的,都能识别正则语言。正则表达式的识别引擎,都是基于DFA或NFA构造的。好像了解了编译原理之后才能理解得更加透彻!

    正则表达式简单使用

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory
    {
        public static void main(String[] args) {
            String content="1950年7月10日";
    
            // 目标:匹配所有四个数字
            // 1、\\d 表示一个任意的数字
            String reg="\\d\\d\\d\\d";
            // 2、创建一个模式对象,即正则表达式对象
            Pattern pattern=Pattern.compile(reg);
            // 3、创建匹配器,按照正则表达式规则去匹配content字符串
            Matcher matcher= pattern.matcher(content);
            //4、开始匹配
            while (matcher.find())
            {
                System.out.println("找到了"+matcher.group(0));
            }
    
        }
    }
    
    

    group方法的源码

    public String group(int group) {
            if (first < 0)
                throw new IllegalStateException("No match found");
            if (group < 0 || group > groupCount())
                throw new IndexOutOfBoundsException("No group " + group);
            if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
                return null;
            return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
        }
    

    匹配过程中没有分组

    matcher.find() 完成的任务:
    (1).根据指定的规则,定位满足规则的子字符串(比如一开始的1950)
    (2).找到后,将 子字符串的开始索引 (即0)记录到matcher对象属性的group数组的group[0]位置
    把该子字符串的结束的索引+1 (即4) 存放到 group[1]的位置
    (3).同时记录oldLast的值为子字符串结束的索引+1 的值(即4),即下次开始执行find方法时,就从4开始匹配!
    在这里插入图片描述

    匹配过程中分组

    matcher.find() 完成的任务:
    (1).根据指定的规则,定位满足规则的子字符串(比如一开始的1950)
    (2).找到后,将 子字符串的开始索引 (即0)记录到matcher对象属性的group数组的group[0]位置
    把该子字符串的结束的索引+1 (即4) 存放到 group[1]的位置
    如果有分组,比如匹配规则是这样子的:(\d\d)(\d\d)
    (2.1) 将成功匹配的子字符串的第一个子字符串的开始索引(即0)存放到group[2]当中;
    将成功匹配的子字符串的第一个子字符串的结束索引+1(即2)存放到group[3]当中;
    (2.2)将成功匹配的子字符串的第二个子字符串的开始索引(即2)存放到group[4]当中;
    将成功匹配的子字符串的第二个子字符串的结束索引(即4)存放到group[5]当中
    (3).同时记录oldLast的值为子字符串结束的索引+1 的值(即4),即下次开始执行find方法时,就从4开始匹配!
    在这里插入图片描述

    正则表达式语法

    正则表达式——元字符

    一般可以有如下分类
    1、限定符
    2、选择匹配符
    3、分组组合和反向引用符
    4、特殊字符
    5、字符匹配符
    6、定位符

    正则表达式中——转义字符

    \ 转义符号:在我们使用正则表达式去检索某些特殊字符的时候,需要用到转义字符,否则会报错。比如,要匹配的字符规则为 abc$(。如果这时候,不对等待匹配的字符串进行转义,那么就会出错!
    在java中,需要用\代表其他语言中的\。
    在java中,需要用到转义字符的有如下:
    . * + \ / ( ) $ ? [ ] ^ { }

    正则表达式——字符匹配符

    符号符号示例解释
    [ ]可接收的字符列表[efgh]e、f、g、h其中的任意一个字符
    [^]不可接收的字符列表[^abc]除a、b、c以外的任意一个字符
    -连字符A-Z任意单个大写字母
    .匹配除\n以外的任意一个字符a…b以a为开头,以b为结尾,中间包括两个任意字符
    \\d匹配任意一个数字字符\\d{3}(\\d)?匹配三个数字或者四个数字的字符串
    \\D匹配任意一个非数字字符,相当于[^0-9]\\D(\\d)*以单个非数字字符开头,后面接任意个数字字符的字符串
    \\w匹配单个数字,大写字母,小写字母,相当于[0-9A-Za-z]\\d{3}\\w{4}以3个数字字符开头的长度为7的数字字母字符串
    \\W匹配单个非数字,非大写字母,非小写字母字符,相当于[^0-9a-zA0-z]\\W+\d{2}以至少一个非数字字母开头的,2个数字字符结尾的字符串
    +表示至少有一个字符
    ?表示0到1个字符
    *表示任意数目的字符
    (?i)匹配字母,并且字母忽略大小写(?i)abc匹配abc,ABC,aBc…
    \\s匹配任意的空白字符
    \\S匹配任意的非空白字符,和\\s相反

    正则表达式——匹配案例

    匹配忽略大小写的abc

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory
    {
        public static void main(String[] args) {
            String content="abc1212AbcAbC";
    
            // 1、匹配忽略大小写的abc
            String reg="(?i)abc";
            // 2、创建一个模式对象,即正则表达式对象
            Pattern pattern=Pattern.compile(reg);
            // 3、创建匹配器,按照正则表达式规则去匹配content字符串
            Matcher matcher= pattern.matcher(content);
            //4、开始匹配
            while (matcher.find())
            {
                System.out.println("找到了"+matcher.group(0));
            }
        }
    }
    
    找到了abc
    找到了Abc
    找到了AbC
    

    匹配只忽略B的大小写的abc字符

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    
    public class RegTheory
    {
        public static void main(String[] args) {
            String content="abc1212AbcaBc";
    
            // 1、匹配一个忽略b的大小写字符
            String reg="a((?i)b)c";
            // 2、创建一个模式对象,即正则表达式对象
            Pattern pattern=Pattern.compile(reg);
            // 3、创建匹配器,按照正则表达式规则去匹配content字符串
            Matcher matcher= pattern.matcher(content);
            //4、开始匹配
            while (matcher.find())
            {
                System.out.println("找到了"+matcher.group(0));
            }
        }
    }
    
    找到了abc
    找到了aBc
    

    正则表达式——选择匹配符

    符号符号实例解释
    |匹配 | 前面 或者后面的内容ab| cd匹配ab 或者 cd
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory
    {
        public static void main(String[] args) {
            String content="abc1212AbcaBc长度cdcqdascnjjoiqdqw";
    
            String reg="ab|cd";
            Pattern pattern= Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println("找到了"+matcher.group(0));
            }
        }
    }
    找到了ab
    找到了cd
    

    正则表达式——限定符

    符号含义示例说明
    *指定字符重复0次到n次(无要求)零到多(abc)*说明包含任意个abc的字符串
    +指定字符重复1次到n次(至少一次)一到多m+(abc)*至少以1个m字母开头的后面跟着任意个abc的字符串
    ?指定字符重复0次或者1次(最多一次)零到一m+(abc)?至少以一个m开头,后接ab或者abc的字符串
    {n}只能输入n个字符[abc]{3}由abcd这四个字母中组成的任意长度为3的字符串
    {n,}指定至少n个匹配[abcd]{3,}由abcd这四个字母组成的至少长度为3的字符串
    {n,m}指定至少n个但不多于m个匹配[abcd]{3,5}由abcd组成的任意长度的不小于3,不大于5的字符串

    正则表达式——定位符

    符号含义实例说明
    ^指定起始字符^ [0-9]+[a-z]*以至少一个数字字符开头,后面接任意个小写字母的字符串
    $指定结尾字符^ [0-9]\\-[a-z]+$以至少一个数字字符开头,后面连接 - 字符,并且至少以一个小写字母结尾的字符串
    \\b匹配目标字符的边界han\\b这里说的有边界是指子字符串有空格,或者目标字符串的结束位置
    \\B匹配目标字符的非边界han\\B和\b的含义相反
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory
    {
        public static void main(String[] args) {
            String content="zidu 112321c zidu12231";
    
            // 以至少一个数字开头,以任意个小写字母结尾的字符串
            //String reg="^[0-9]+[a-z]*";
            //以至少一个数字开头,至少一个小写字母结尾的字符串
            //String reg="^[0-9]+[a-z]+$";
            // 匹配边界的zidu
    //        String reg="zidu\\b";
    
            // 匹配非边界的zidu
            String reg="zidu\\B";
    
            Pattern pattern= Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println("找到了"+matcher.group(0));
            }
        }
    }
    
    

    正则表达式——捕获分组

    可以给分组取名,后来获取数据的时候,不用那么麻烦去计算第几个分组,直接利用组名来获取就ok了!
    在这里插入图片描述

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory01 {
        public static void main(String[] args) {
            String content="1996年4月23日,1999年6月28日";
            String reg="(?<zidu1>\\d\\d)(?<zidu2>\\d\\d)";
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println(matcher.group(0));
                System.out.println("第一组"+matcher.group(1));
                System.out.println("第一组【通过组名来取】"+matcher.group("zidu1"));
                System.out.println("第二组"+matcher.group(2));
                System.out.println("第二组【通过组名来取】"+matcher.group("zidu2"));
            }
        }
    }
    
    1996
    第一组19
    第一组【通过组名来取】19
    第二组96
    第二组【通过组名来取】96
    1999
    第一组19
    第一组【通过组名来取】19
    第二组99
    第二组【通过组名来取】99
    
    

    正则表达式——非捕获分组

    在这里插入图片描述
    ?: 这种写法就是非捕获分组,也就是看起来是分组,但实际上不是分组,不能使用matcher.group(1)来获取.匹配的内容是自渡一号,自渡二号,自渡三号这三个子字符串

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory01 {
        public static void main(String[] args) {
            String content="自渡一号自渡二号自渡三号";
    //        String reg="自渡一号|自渡二号|自渡三号";
            // 下面这种写法就是非捕获分组,也就是看起来是分组,但实际上不是分组,不能使用matcher.group(1)来获取
            String reg="自渡(?:一号|二号|三号)";
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println(matcher.group(0));
            }
        }
    }
    
    自渡一号
    自渡二号
    自渡三号
    
    

    ?=表示匹配的内容是在后面这些字符串中有的关键字的子字符串,比如,我只想找有关于自渡一号和自渡二号中的自渡关键字,如果不是这两个子字符串中的“自渡”,我是不要的。
    这里只会输出自渡一号和自渡二号中的自渡,即只有两个结果!

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory01 {
        public static void main(String[] args) {
            String content="自渡一号自渡二号自渡三号";
    //        String reg="自渡一号|自渡二号|自渡三号";
            String reg="自渡(?=一号|二号)";
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println(matcher.group(0));
            }
        }
    }
    
    自渡
    自渡
    

    ?!,寻找的内容不在后面所跟着内容的字符串的子字符串里面。找到不在自渡一号,自渡二号中的“自渡关键字”
    这里只会输出自渡三号中的自渡,即只有一个结果,作用跟上面的相反!

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory01 {
        public static void main(String[] args) {
            String content="自渡一号自渡二号自渡三号";
    //        String reg="自渡一号|自渡二号|自渡三号";
            String reg="自渡(?!一号|二号)";
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println(matcher.group(0));
            }
        }
    }
    
    自渡
    
    

    正则表达式——非贪婪匹配

    Java中的正则表达式默认是一个贪婪匹配!

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory01 {
        public static void main(String[] args) {
            String content="12343";
    //        String reg="\\d+"; //默认是贪婪匹配
            String reg="\\d+?";  // 将 ? 附带在 * . + 之后,就可以修改为非贪婪匹配
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher= pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println(matcher.group(0));
            }
        }
    }
    
    1
    2
    3
    4
    3
    

    正则表达式——案例(核心是匹配规则)

    1.验证输入的字符串是否为汉字字符串

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory02
    {
        public static void main(String[] args) {
            // 1、等待校验的字符串
            String content="要好好加油";
            // 2、定义匹配规则
            String reg="^[\u0391-\uffe5]+$";
            // 3、定义一个匹配器对象
            Pattern pattern=Pattern.compile(reg);
            // 4、利用匹配器对象进行匹配
            Matcher matcher= pattern.matcher(content);
            // 5、获取匹配结果
            if(matcher.find())
            {
                System.out.println("满足格式");
            }
            else
                System.out.println("不满足格式");
        }
    }
    
    

    2.验证该数字是否是1-9开头的6位数字

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory02
    {
        public static void main(String[] args) {
            // 1、等待校验的字符串
            String content="123125";
            // 2、定义匹配规则
            String reg="^[1-9]\\d{5}$";
            // 3、定义一个匹配器对象
            Pattern pattern=Pattern.compile(reg);
            // 4、利用匹配器对象进行匹配
            Matcher matcher= pattern.matcher(content);
            // 5、获取匹配结果
            if(matcher.find())
            {
                System.out.println("满足格式");
            }
            else
                System.out.println("不满足格式");
    
        }
    }
    
    

    3.验证QQ号码

    1-9开头的5到10位数字

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegTheory02
    {
        public static void main(String[] args) {
            // 1、等待校验的字符串
            String content="1194801234";
            // 2、定义匹配规则
            String reg="^[1-9]\\d{4,9}$";
            // 3、定义一个匹配器对象
            Pattern pattern=Pattern.compile(reg);
            // 4、利用匹配器对象进行匹配
            Matcher matcher= pattern.matcher(content);
            // 5、获取匹配结果
            if(matcher.find())
            {
                System.out.println("满足格式");
            }
            else
                System.out.println("不满足格式");
    
        }
    }
    
    

    4、验证手机号码

    必须是以13,14,15,18开头的11位数字

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    
    public class RegTheory02
    {
        public static void main(String[] args) {
            // 1、等待校验的字符串
            String content="13948012341";
            // 2、定义匹配规则
            String reg="^1(3|4|5|8)\\d{9}$";
            // 3、定义一个匹配器对象
            Pattern pattern=Pattern.compile(reg);
            // 4、利用匹配器对象进行匹配
            Matcher matcher= pattern.matcher(content);
            // 5、获取匹配结果
            if(matcher.find())
            {
                System.out.println("满足格式");
            }
            else
                System.out.println("不满足格式");
    
        }
    }
    
    

    正则表达式——三个常用类

    Pattern类

    验证某个字符串是否整体匹配所定义的规则!

    public class PatternMethod {
        public static void main(String[] args) {
            String content="hello,I am gaolinhui!";
            String reg="hello";
            // 验证某个字符串是否整体匹配某种效果
            boolean matches= Pattern.matches(reg,content);
            System.out.println(matches);
        }
    }
    

    Matcher类

    在这里插入图片描述

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Main
    {
        public static void main(String[] args) {
            String content="hello edu jack tom hello smith hello";
            String reg="hello.*";
            reg="hello";
    
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher = pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println("=============");
                // 输出匹配的子字符串第一个索引位置
                System.out.println(matcher.start());
                // 输出匹配的子字符串的最后一个索引的位置+1
                System.out.println(matcher.end());
                // 输出,截取到的子字符串
                System.out.println("找到"+content.substring(matcher.start(), matcher.end()));
            }
    
            // 常用于,去检验某个字符串是否符合整体某个规则
            System.out.println(matcher.matches());
    
            // 完成如果content,有edu则替换为zidu
            reg="edu";
            pattern=Pattern.compile(reg);
            matcher=pattern.matcher(content);
            // 返回新的字符串才会改变,
            String newString =matcher.replaceAll("zidu");
            // 原先的不变
            System.out.println(content);
            System.out.println(newString);
    
        }
    }
    
    

    正则表达式——分组、捕获,反向引用

    正则表达式——分组

    我们可以使用圆括号组成一个比较复杂的匹配模式,那么一个圆括号我们可以看做是一个子表达式/一个分组!

    正则表达式——捕获

    把正则表达式中子表达式/分组匹配的内容,保存到内存中一数字编号或者显式命名的组里,方便以后引用,从左向右,以分组的左括号为标志,第一个出现的分组的组合为1,第二个为2,以此类推。组0代表的是整个表达式!

    反向引用

    圆括号的内容被捕获后,可以在这个括号后被使用,从而写出一个比较实用的匹配模式,这个我们称之为反向引用,这种引用既可以是在正则表达式内部,也可以是在正则表达式外部,内部反向引用 \\分组号,外部反向引用 $分组号

    反向引用案例

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Main
    {
        public static void main(String[] args) {
            String content="155555214146644849522346113354";
            // 寻找两个连续相同的数字
            String reg="(\\d)\\1";
    
            // 匹配五个连续相同的数字
            reg="(\\d)\\1{4}";
    
            // 匹配个位与千位相同,十位与百位相同的数字
            reg="(\\d)(\\d)\\2\\1";
    
            Pattern pattern=Pattern.compile(reg);
            Matcher matcher = pattern.matcher(content);
            while (matcher.find())
            {
                System.out.println(matcher.group(0));
            }
        }
    }
    
    

    商品码案例

    匹配一个商品码,前五位是数字,后面一个横杠-,然后后面九位数字,并且三位数字连续且相同。

    String reg="(\\d){5}-(\\d)\\2{2}(\\d)\\3{2}(\\d)\\4{2}";
    

    结巴程序

    import org.bouncycastle.tsp.TSPUtil;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /*
    *
    * 结巴程序
    *
    * */
    public class Main
    {
        public static void main(String[] args) {
            String content="我...我要....学学学学...编程Java!";
    
            System.out.println(content);
            System.out.println("====>");
            //1.把.去掉
            Pattern pattern = Pattern.compile("\\.");
            Matcher matcher = pattern.matcher(content);
            content=matcher.replaceAll("");
    //        System.out.println(content);
    
            // 2.去掉重复的字符
            pattern=Pattern.compile("(.)\\1+");
            matcher=pattern.matcher(content);
    //        while (matcher.find()) System.out.println(matcher.group(0));
    
            // 外部替换,将重复的字符,用找到的第一个分组去替换
            content=matcher.replaceAll("$1");
            System.out.println(content);
    
        }
    }...我要....学学学学...编程Java!
    ====>
    我要学编程Java!
    
    
    // 最后的几个部分也可以用这个方法!就节省代码
     content=Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
    

    正则表达式——在String类中使用

    public class Main
    {
        public static void main(String[] args) {
            String content="2000年5月,JDK1.3、JDK1.4和J2SE1.3相继发布," +
                    "几周后其获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日," +
                    "J2EE1.3发布。2002年2月26日,J2SE1.4发布。自此Java的计算能力有了大幅提升,与J2SE1.3相比," +
                    "其多了近62%的类和接口。在这些新特性当中,还提供了广泛的XML支持、安全套接字(Socket)支持" +
                    "(通过SSL与TLS协议)、全新的I/OAPI、正则表达式、日志与断言。" +
                    "2004年9月30日,J2SE1.5发布,成为Java语言发展史上的又一里程碑。" +
                    "为了表示该版本的重要性,J2SE 1.5更名为Java SE 5.0(内部版本号1.5.0)," +
                    "代号为“Tiger”,Tiger包含了从1996年发布1.0版本以来的最重大的更新,其中包括泛型支持、" +
                    "基本类型的自动装箱、改进的循环、枚举类型、格式化I/O及可变参数。";
            content=content.replaceAll("JDK1\\.3|JDK1\\.4","JDK");
            System.out.println(content);
    
            String conten1="13921414648";
    
            boolean isPhoneNumber = conten1.matches("(138|139)[0-9]{8}");
            if (isPhoneNumber)
                System.out.println("正确手机号码");
            else
                System.out.println("错误手机号码");
    
            // 按照 # 或者 - 或者 ~ 或者数字 来进行分割
            String content2="hello#daqewq-wedfwe~wedw1cds";
            String[] split = content2.split("#|-|~|\\d");
            for (String s : split) {
                System.out.println(s);
            }
    
        }
    }
    
    

    正则表达式——常用表达式

    1.校验数字的表达式

    数字:^[0-9]*$
    
    n位的数字:^\d{n}$
    
    至少n位的数字:^\d{n,}$
    
    m-n位的数字:^\d{m,n}$
    
    零和非零开头的数字:^(0|[1-9][0-9]*)$
    
    非零开头的最多带两位小数的数字:^([1-9][0-9]*)+(.[0-9]{1,2})?$
    
    带1-2位小数的正数或负数:^(\-)?\d+(\.\d{1,2})?$
    
    正数、负数、和小数:^(\-|\+)?\d+(\.\d+)?$
    
    有两位小数的正实数:^[0-9]+(.[0-9]{2})?$
    
    有1~3位小数的正实数:^[0-9]+(.[0-9]{1,3})?$
    
    非零的正整数:^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
    
    非零的负整数:^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
    
    非负整数:^\d+$ 或 ^[1-9]\d*|0$
    
    非正整数:^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
    
    非负浮点数:^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
    
    非正浮点数:^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
    
    正浮点数:^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
    
    负浮点数:^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
    
    浮点数:^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
    

    校验字符的表达式

    汉字:^[\u4e00-\u9fa5]{0,}$
    
    英文和数字:^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
    
    长度为3-20的所有字符:^.{3,20}$
    
    由26个英文字母组成的字符串:^[A-Za-z]+$
    
    由26个大写英文字母组成的字符串:^[A-Z]+$
    
    由26个小写英文字母组成的字符串:^[a-z]+$
    
    由数字和26个英文字母组成的字符串:^[A-Za-z0-9]+$
    
    由数字、26个英文字母或者下划线组成的字符串:^\w+$ 或 ^\w{3,20}
    
    中文、英文、数字包括下划线:^[\u4E00-\u9FA5A-Za-z0-9_]+$
    
    中文、英文、数字但不包括下划线等符号:^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
    
    可以输入含有^%&',;=?$\"等字符:[^%&',;=?$\x22]+
    
    禁止输入含有~的字符[^~\x22]+
    
    ================================================= 特殊使用========================================
    
    .*匹配除 \n 以外的任何字符。
    
    /[\u4E00-\u9FA5]/ 汉字
    
    /[\uFF00-\uFFFF]/ 全角符号
    
    /[\u0000-\u00FF]/ 半角符号
    
    

    特殊需求表达式

    Email地址:^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
    
    域名:[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
    
    InternetURL:[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
    
    手机号码:^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
    
    电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX):^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
    
    国内电话号码(0511-4405222、021-87888822):\d{3}-\d{8}|\d{4}-\d{7}
    
    身份证号(15位、18位数字):^\d{15}|\d{18}$
    
    短身份证号码(数字、字母x结尾):^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
    
    帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$
    
    密码(以字母开头,长度在6~18之间,只能包含字母、数字和下划线):^[a-zA-Z]\w{5,17}$
    
    强密码(必须包含大小写字母和数字的组合,不能使用特殊字符,长度在8-10之间):^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
    
    日期格式:^\d{4}-\d{1,2}-\d{1,2}
    
    一年的12个月(01~09和1~12):^(0?[1-9]|1[0-2])$
    
    一个月的31天(01~09和1~31):^((0?[1-9])|((1|2)[0-9])|30|31)$
    
    

    钱的输入格式

    1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000":^[1-9][0-9]*$
    
    2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式:^(0|[1-9][0-9]*)$
    
    3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号:^(0|-?[1-9][0-9]*)$
    
    4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分:^[0-9]+(.[0-9]+)?$
    
    5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的:^[0-9]+(.[0-9]{2})?$
    
    6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样:^[0-9]+(.[0-9]{1,2})?$
    
    7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样:^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
    
    8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须:^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
    
    9.xml文件:^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
    
    10.中文字符的正则表达式:[\u4e00-\u9fa5]
    
    11.双字节字符:[^\x00-\xff] (包括汉字在内,可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1))
    
    12.空白行的正则表达式:\n\s*\r (可以用来删除空白行)
    
    13.HTML标记的正则表达式:<(\S*?)[^>]*>.*?</\1>|<.*? /> (网上流传的版本太糟糕,上面这个也仅仅能部分,对于复杂的嵌套标记依旧无能为力)
    
    14.首尾空白字符的正则表达式:^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等),非常有用的表达式)
    
    15.腾讯QQ号:[1-9][0-9]{4,} (腾讯QQ号从10000开始)
    
    16.中国邮政编码:[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
    
    17.IP地址:\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)
    
    18.IP地址:((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
    
    19.IP-v4地址:\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b (提取IP地址时有用)
    
    20.校验IP-v6地址:(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))
    
    21.子网掩码:((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
    
    22.校验日期:^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$(“yyyy-mm-dd“ 格式的日期校验,已考虑平闰年。)
    
    23.抽取注释:<!--(.*?)-->
    
    24.查找CSS属性:^\\s*[a-zA-Z\\-]+\\s*[:]{1}\\s[a-zA-Z0-9\\s.#]+[;]{1}
    
    25.提取页面超链接:(<a\\s*(?!.*\\brel=)[^>]*)(href="https?:\\/\\/)((?!(?:(?:www\\.)?'.implode('|(?:www\\.)?', $follow_list).'))[^" rel="external nofollow" ]+)"((?!.*\\brel=)[^>]*)(?:[^>]*)>
    
    26.提取网页图片:\\< *[img][^\\\\>]*[src] *= *[\\"\\']{0,1}([^\\"\\'\\ >]*)
    
    27.提取网页颜色代码:^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
    
    28.文件扩展名效验:^([a-zA-Z]\\:|\\\\)\\\\([^\\\\]+\\\\)*[^\\/:*?"<>|]+\\.txt(l)?$
    
    29.判断IE版本:^.*MSIE [5-8](?:\\.[0-9]+)?(?!.*Trident\\/[5-9]\\.0).*$
    
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    正则表达式——总结

    正则表达式很强大,可以帮助我们快速处理文本!只能是根据我们自己的实际业务需求来编写正则表达式的规则,希望能有所提升!

    展开全文
  • java正则表达式校验是否为正整数

    千次阅读 2021-05-06 19:34:36
    正则表达式 正则表达式常用方法 代码如下(示例): 校验是否为正整数 public static Boolean checkStringPositiveNum(String val) { if (StringUtils.isBlank(val)) { return false; } Pattern pattern = ...

    正则表达式

    正则表达式常用方法

    代码如下(示例): 校验是否为正整数

        public static Boolean checkStringPositiveNum(String val) {
            if (StringUtils.isBlank(val)) {
                return false;
            }
            Pattern pattern = compile("[0-9]*");
            return !pattern.matcher(val).matches();
        }
    
    

    总结

    提示:正则表达式有很多校验数据类型的方式很常用,这里就提供一种 。

    展开全文
  • 目标:通过设计一个简单的数学...标注数字为正数还是负数,同时,假设操作数是整数,运算符只有四种类型:+、-、和/,例如如下 表达式:-2+3(-5)/3-29。 (2)有效表达式校验 在对表达式求值运算之前,必须先...

    关于用java正则表达式检索简易数学表达式并计算结果

    目标:通过设计一个简单的数学表达式计算器,要求设计者以面向对象程序的设计方式来实现计算器的具体功能。

    程序规则:
    (1)表达式定义
    本程序表达式设定为可由多个运算符和数字组成,可以含括号,为了降低题目难度,括号只用于
    标注数字为正数还是负数,同时,假设操作数是整数,运算符只有四种类型:+、-、和/,例如如下
    表达式:-2+3
    (-5)/3-29。
    (2)有效表达式校验
    在对表达式求值运算之前,必须先对表达式的正确性进行校验。例如:空字符串、运算符连续、 空括号、括号不配对、右括号前是运算符、“(”不为第一个字符且前面不是运算符、“)”不为最后
    一个字符且后面不是运算符、表达式内含非法字符等。
    (3)运算规则
    为简单起见,如果表达式格式正确,表达式计算不考虑运算符的优先级,即加减乘除是相同优先
    级,则从左到右依次计算,最终得出结果(例:1+3
    6=24)。此外,除法运算遵从 C 语言中整数除法的运算规则(即取整),另外,一旦出现除零操作,程序要给出相应错误提示。

    我的思路

    <1.表达式正确性验证>

    (1)对于这个任务要求输入的数学表达式的格式十分简单,只需检索是否满足"数字 运算符 数字 运算符…数字"的格式就可以判断其是否是一个正确的数学表达式。而仔细观察此格式就可以发现,除去第一个数字以外,后面都满足"运算符+数字"的格式,即后面可以是一个"运算符+数字"的重复出现,如果用正则表达式模拟的话应该是"数字[运算符 数字]*"的格式。

    (2)对于运算符,此题给出了+ ,- ,** ,/ 四种符号,分别代表了加,减,乘,除四种数学上的基本运算形式。并且,此题的四种运算无优先顺序,而是直接从左向右依次计算结果。 尤其要注意的是,在用java的正则表达式检索运算符的时候,是一个含有特殊意义的字符,不能直接使用,需要用双斜杠"\\"来对*号进行转译。 如果要用正则表达式来模拟的话应该是"[+ - \\* /]"的格式。

    (3)对于数字,本题设置了含有括号的负数的形式,即除在第一个位置的数字以外,其余地方如果要是有负数,则必须用 “(” 和 “)” 括起来,并且 “(” 和 “)” 之间只能有负数,不能有其他东西。
    另外,对于一个合法的数字,其开头第一个数字不能为0(除数字0与-0以外),如果用正则表达式来模拟的话应该是"( [1-9]\\d* | \\(-[1-9]\d*\\) | 0 | \\(-0\\) )“的格式。 ( 注: 开头数字的正则表达式会比此正则表达式多出”-[1-9]\d*","-0"两种情况,只需要用"|"把他们加入到上面的正则表达式中即可)。

    (4)综上,本题用于验证数学表达式正确性的正则表达式为:"(\\(-[1-9]\\d*\\) | -[1-9]\\d* | [1-9]\\d* | 0 | -0 | \\(-0\\)) ([+ - / \\* ] (\\(-[1-9]\\d\\) | [1-9]\\d* | \\(-0\\) | 0))*"。以下是图片:这是检验表达式的正则表达式截图
    <2.计算表达式的值>

    (1)拆分表达式
    检验完数学表达式并且表达式正确之后,则需要对表达式进行拆分,提取出有效的数据以及运算符。为了把数字完整的提取出来,我使用了" .split("\\b") "的拆分方式(注:拆分字符串的方法多种多样,我使用这种方法的好处是不会把一个多位数拆分成多个数字,可以一步到位的把一个正整数完整的拆分下来,例如"1+2-(-33)/465".split("\\b")会被拆分成一个含有"1","+",“2”,(-",“33”,")/","465"的字符串数组)。

    (2)处理拆分后只含有数字的字符串数组
    将表达式拆分之后,会得到一个字符串数组。我们对其进行分类,将只含有数字的字符串强制类型转换为整数并存入一个整形动态数组num,即num.add(Integer.parseInt(s[i]))。然后再对剩下的字符串数组进行分析。

    (3)处理剩下的字符串数组
    观察剩下的字符串数组,在这个数学表达式正确的前提下,剩下的字符串数组长度只能在[1,4]之间。对长度进行分类再分析

    ①长度为1:如果某个字符串数组的长度为1,那只能是+,-,*,/,(,)之间的某一个,但有用的只有+,-,*,/,所以如果是+,-,*,/就将其强制类型转换为字符型并存入一个字符型动态数组operator,即operator.add(String.valueOf(ch[0]))。如果不是则用".replaceFirst()"的方法去掉。

    ②长度为2:如果某个字符串数组的长度为2,且满足"\\)[+ - / \\*]" 的格式,则有用的运算符为第二个字符,将此字符串的第二个字符存入动态数组operator,剩下的字符则用".replaceFirst()"的方法去掉。

    ③长度为3:如果某个字符串的长度是3,且满足"[+ - / \\*]\\(-“的格式,则有用的运算符为第一个字符,按上述方法对其进行处理。但由于这个字符串结尾是一个”-"号,一定代表负号的意思,则其下一个数字必须取反才能得到正确的结果。所以可以设置一个boolean类型的标记isminus,一旦遇到这个格式则设置其为true,然后让下一个数字取反。

    ④长度为4:如果某个字符串的长度为4,且满足 "\\)[+ - / \\*]\\(-“的格式,则有用的运算符为第二个运算符。按上述的方法对其进行处理,这个格式结尾也也”-"号,所以其处理方式同③。

    4)进行计算
    将数学表达式切割完成后,会得到数据动态数组和运算符动态数组,设置一个循环,循环条件为运算符动态数组是否为空while(operator.size() ! = 0)。然后每次从数据数组中拿出前两个数据,从运算符数组中拿出第一个运算符,对运算符进行判断并计算得到相应的值。然后将值插入到数据数组的第3个位置,再用".remove()"的方法把用过的数据和运算符全部从各自数组中删除,如此循环,直到运算符数组为空。此时数据数组中只剩下一个数据,那就是结果

    展开全文
  • Java 正则表达式:语法讲解和常用表达式汇总

    万次阅读 多人点赞 2019-03-14 15:34:16
    正则表达式定义了字符串的模式。 正则表达式可以用来搜索、编辑或处理文本。 正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。

    原创博文,欢迎转载,转载时请务必附上博文链接,感谢您的尊重。

    正则表达式定义了字符串的模式;
    正则表达式可以用来搜索、编辑或处理文本;
    正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。

    正文

    使用正则表达式需要引入 java.util.regex 包,我们就从这里入手讲解:
    java.util.regex
    java.util.regex 包主要包括以下三个类:

    • Pattern 类:
      pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象,你必须首先调用其公共静态编译方法,它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

    • Matcher 类:
      Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样,Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
      matches方法

    • PatternSyntaxException:
      PatternSyntaxException 是一个非强制异常类,它表示一个正则表达式模式中的语法错误。

    以下实例中演示了正则表达式的使用:

    /* import java.util.regex.*; */
    public void RegexExample() {
    	String input = "I am Jimmy from mp.csdn.net";
    	String regex = ".*csdn.*";
    		
    	// 方式1:String 的 matches 方法
    	boolean flag1 = input.matches(regex);
    		
    	// 方式2:Pattern 对象的 matches 方法
    	boolean flag2 = Pattern.matches(regex, input);
    		
    	// 方式3: Matcher 对象的 matches 方法
    	Pattern p = Pattern.compile(regex);
    	Matcher m = p.matcher(input);
    	boolean flag3 = m.matches();
    	
    	System.out.println("字符串中是否包含了'csdn'子字符串? " + flag1 );
    	System.out.println("字符串中是否包含了'csdn'子字符串? " + flag2 );
    	System.out.println("字符串中是否包含了'csdn'子字符串? " + flag3 );
    }
    输出结果:
    	字符串中是否包含了'csdn'子字符串? true
    	字符串中是否包含了'csdn'子字符串? true
    	字符串中是否包含了'csdn'子字符串? true
    

    从上面的代码中,你会看到一个现象:

    • 3种方式的底层实现其实是一样的,只是封装的成度不一样,实际也确实如此;
    • 明白方式3,更有助于理解正则的执行过程;

    matches 和 lookingAt 方法

    matches() 和 lookingAt() 方法都用来尝试匹配一个输入序列模式。不同的是 matches() 要求整个序列都匹配,而 lookingAt() 不要求;
    lookingAt() 方法虽然不需要整句都匹配,但是需要从第一个字符开始匹配;
    这两个方法经常在输入字符串的开始使用。

    public void matchAndLookingExample() {
    	String REGEX = "foo";
    	String INPUT = "foooooooooo";
    	String INPUT2 = "ooooofoooooo";
    	
    	Pattern pattern = Pattern.compile(REGEX);
    	Matcher matcher = pattern.matcher(INPUT);
    	Matcher matcher2 = pattern.matcher(INPUT2);
    	
    	System.out.println("lookingAt(): "+matcher.lookingAt());
    	System.out.println("matches(): "+matcher.matches());
    	System.out.println("lookingAt(): "+matcher2.lookingAt());
    }
    输出结果:
    	lookingAt(): true	// 开头匹配
    	matches(): false	// 不是整个序列都匹配
    	lookingAt(): false	// 开头不匹配
    

    正则表达式语法

    在其他语言中,\\ 表示:我想要在正则表达式中插入一个普通的(字面上的)反斜杠,请不要给它任何特殊的意义。

    在 Java 中,\\ 表示:我要插入一个正则表达式的反斜线,所以其后的字符具有特殊的意义。

    所以,在其他的语言中(如Perl),一个反斜杠 \ 就足以具有转义的作用,而在 Java 中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在 Java 的正则表达式中,两个 \\ 代表其他语言中的一个 \,这也就是为什么表示一位数字的正则表达式是 \\d,而表示一个普通的反斜杠是 \\\\。

    字符说明
    ^匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配。
    $匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与"\n"或"\r"之前的位置匹配。
    *零次或多次匹配前面的字符或子表达式。例如,zo* 匹配"z"和"zoo"。* 等效于 {0,}。
    +一次或多次匹配前面的字符或子表达式。例如,"zo+"与"zo"和"zoo"匹配,但与"z"不匹配。+ 等效于 {1,}。
    ?零次或一次匹配前面的字符或子表达式。例如,"do(es)?“匹配"do"或"does"中的"do”。? 等效于 {0,1}。
    {n}n 是非负整数。正好匹配 n 次。例如,"o{2}"与"Bob"中的"o"不匹配,但与"food"中的两个"o"匹配。
    {n,}n 是非负整数。至少匹配 n 次。例如,"o{2,}“不匹配"Bob"中的"o”,而匹配"foooood"中的所有 o。"o{1,}“等效于"o+”。"o{0,}“等效于"o*”。
    {n,m}m 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。例如,"o{1,3}"匹配"fooooood"中的头三个 o。‘o{0,1}’ 等效于 ‘o?’。注意:您不能将空格插入逗号和数字之间。
    xy
    [xyz]字符集。匹配包含的任一字符。例如,"[abc]“匹配"plain"中的"a”。
    [ ^xyz]反向字符集。匹配未包含的任何字符。例如,"[^abc]“匹配"plain"中"p”,“l”,“i”,“n”。
    [a-z]字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a"到"z"范围内的任何小写字母。
    \d数字字符匹配。等效于 [0-9]。
    \D非数字字符匹配。等效于 [ ^0-9]。
    \w匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。
    \W与任何非单词字符匹配。与"[ ^A-Za-z0-9_]"等效。

    常用的正则表达式

    说明正则表达式
    一、校验数字的表达式 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
    数字^ [0-9]*$
    n位的数字^\d{n}$
    至少n位的数字^\d{n,}$
    m-n位的数字^\d{m,n}$
    非零开头的最多带两位小数的数字^([1-9][0-9]*)+(.[0-9]{1,2})?$
    带1-2位小数的正数或负数^(-)?\d+(.\d{1,2})?$
    有1~3位小数的正实数^ [0-9]+(.[0-9]{1,3})?$
    非负整数^\d+$
    非正整数^((-\d+)
    二、校验字符的表达式 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
    汉字^ [\u4e00-\u9fa5]{0,}$
    英文和数字^ [A-Za-z0-9]+$
    长度为3-20的所有字符^.{3,20}$
    由26个英文字母组成的字符串^ [A-Za-z]+$
    由数字、26个英文字母或者下划线组成的字符串^\w+$ 或 ^\w{3,20}$
    中文、英文、数字包括下划线^ [\u4E00-\u9FA5A-Za-z0-9_]+$
    中文、英文、数字但不包括下划线等符号^ [\u4E00-\u9FA5A-Za-z0-9]+$
    可以输入含有^%&’,;=?$"等字符[^%&’,;=?$\x22]+
    禁止输入含有~的字符[^~\x22]+
    三、特殊需求表达式 ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
    Email地址^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$
    域名[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
    InternetURL[a-zA-z]+://[^\s]* 或 ^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$
    手机号码^(13[0-9]
    电话号码^((\d{3,4}-)
    身份证号(15位、18位数字)^\d{15}
    短身份证号码(数字、字母x结尾)^([0-9]){7,18}(x
    帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线)^ [a-zA-Z][a-zA-Z0-9_]{4,15}$
    密码(以字母开头,长度在6~18之间,只能包含字母、数字和下划线)^ [a-zA-Z]\w{5,17}$
    日期格式^\d{4}-\d{1,2}-\d{1,2}
    中国邮政编码[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
    腾讯QQ号[1-9][0-9]{4,} (腾讯QQ号从10000开始)
    IP地址\d+.\d+.\d+.\d+ (提取IP地址时有用)
    中文字符的正则表达式[\u4e00-\u9fa5]

    我是IT无知君,您的点赞、评论和关注,是我继续创作的不懈动力。
    学无止境,气有浩然,让我们一起加油,乘风破浪,江湖有缘再见!!

    展开全文
  • java正则表达式大全(常用)

    万次阅读 多人点赞 2018-10-30 21:47:21
    一、校验数字的表达式 1 数字:^[0-9]*$ 2 n位的数字:^\d{n}$ 3 至少n位的数字:^\d{n,}$ 4 m-n位的数字:^\d{m,n}$ 5 零和非零开头的数字:^(0|[1-9][0-9]*)$ 6 非零开头的最多带两位小数的数字:^([1-9][0-9]...
  • 正则表达式是处理字符串的强大的工具,它不是Java的特性,前端的JavaScript等也有。但是相比于其他老牌的高级语言,如C/C++,这是Java比他们独特的地方。 一、正则表达式的概念: 理解可得:正则表达式其实就是一个...
  • 正则表达式中的元符号 \d : 0-9之间的任意一个数字 \d只占一个位置 \w : 数字,字母 ,下划线 0-9 a-z A-Z _ \s : 空格或者空白等 \D : 除了\d \W : 除了\w \S : 除了\s  . : 除了\n之外的任意一个字符  \ : 转义...
  • 今天要讲的是 Java正则表达式。 一个字符串其实就是一个简单的正则表达式,例如 Hello World 正则表达式匹配&quot;Hello World&quot; 字符串 .(点号)也是一个正则表达式,它匹配任何一个字符如:&...
  • 主要介绍了Java正则验证正整数的方法,结合实例形式对比分析了java针对正整数的验证方法及相关注意事项,需要的朋友可以参考下
  • 一、校验数字的表达式 1 数字:^[0-9]*$ 2 n位的数字:^\d{n}$ 3 至少n位的数字:^\d{n,}$ 4 m-n位的数字:^\d{m,n}$ 5 零和非零开头的数字:^(0|[1-9][0-9]*)$ 6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)(....
  • 在做项目的过程中,使用正则表达式来匹配一段文本中的特定种类字符,是比较常用的一种方式,下面是对常用的正则匹配做了一个归纳整理。 一、校验数字的表达式 1 数字:1$ 2 n位的数字:^\d{n}$ 3 至少n位的数字:^\d...
  • * 判断字符串是否全字母 并且全部是正数数字 * @param str 字符串 * @return boolean */ public static boolean validateStrEnglish ( final String str ) { if ( StringUtils . isEmpty ( str ) )...
  • 正则表达式(英语:Regular Expression,在代码中常简写为regex)。 正则表达式是一个字符串,使用单个字符串来描述、用来定义匹配规则,匹配一系列符合某个句法规则的字符串。在开发中,正则表达式通常被用来检索...
  • Java正则表达式详解

    2019-12-21 13:20:45
    正则表达式的概念: 正则表达式是一个字符串,使用单个字符串来描述、用来定义匹配规则,匹配一系列符合某个句法规则的字符串。在开发中,正则表达式通常被用来检索、替换那些符合某个规则的文本。 基础 元字符 ...
  • 正则表达式, 字符串的替换与分解 正则表达式 正则表达式主要用于字符串匹配, 由一些具有特殊意义的符号和常规字符组成, 例如: 特殊符号: $ () * + . [] ? \ ^ {} 常规字符组合: \d \D \w \W \s \S \p ....
  • java正则表达式大全

    2020-10-15 17:45:47
    一、校验数字的表达式 1 数字:^[0-9]*$ 2 n位的数字:^\d{n}$ 3 至少n位的数字:^\d{n,}$ 4 m-n位的数字:^\d{m,n}$ 5 零和非零开头的数字:^(0|[1-9][0-9]*)$ 6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)+...
  • jquery 正整数数字校验正则表达式JavaScript正则表达式校验非零的正整数实例利用js正则表达式校验正数、负数、和小数Javascript校验密码复杂度的正则表达式最全的常用正则表达式大全——包括校验数字、字符、一些...
  • Java 正则表达式

    2021-03-03 00:07:37
    \d) (中国邮政编码为6位数字) 腾讯QQ号 [1-9][0-9]{4,} (腾讯QQ号从10000开始) IP地址 \d+.\d+.\d+.\d+ (提取IP地址时有用) 中文字符的正则表达式 [\u4e00-\u9fa5] java正则表达式大全(常用) 一、校验数字的表达式...
  • Pattern.compile("\\w*", Pattern.MULTILINE).flags() => 8 pattern() String 返回在其中编译过此模式的正则表达式。 Pattern.compile("\\w*").pattern() => \w* static quote(String s) String 返回指定 String 的...
  • 2Java正则表达式 正则表达式定义了字符串的模式。 正则表达式可以用来搜索、编辑或处理文本。 正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别 3代码片段 import ...
  • 正则表达式匹配过程中,如果子表达式匹配到的字符内容,而非位置,并被保存到最终的匹配结果中,那么就认为这个子表达式是占有字符的;如果子表达式匹配的仅仅是位置,或者匹配的内容并不保存到最终的匹配结果中,...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • JAVA正则表达式

    2020-01-25 16:44:49
    JAVA正则表达式 1.什么是正则表达式? 正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤...
  • 正整数正则表达式

    2021-08-30 10:05:29
    正数正则表达式(包括0,小数保留两位): ^((0{1}.\d{1,2})|([1-9]\d.{1}\d{1,2})|([1-9]+\d)|0)$ 正数正则表达式(不包括0,小数保留两位): ^((0{1}.\d{1,2})|([1-9]\d.{1}\d{1,2})|([1-9]+\d))$ 正整数的...
  • Java正则表达式-笔记

    2020-07-25 14:44:25
    Java正则表达式概念常用语法规则匹配规则练习字符串常用正则相关方法方法示例:matches示例:split示例:replaceAll练习匹配正确的数字匹配合法的邮箱获取IP地址(192.168.1.100)中的每段数字 概念 正则表达式...
  • JavaScript的正则表达式,例如var uPattern = /^[a-zA-Z0-9_-]{4,16}$/; 在JAVA中不能要/,只写String reg = "^[a-zA-Z0-9_-]{4,16}$";才行! Java正则的使用: 1、只检测字符串格式 String phoneReg="^1[34578]\\d{...
  • 正则表达式 1.概念 正则表达式(英语:Regular Expression,在代码中常简写为regex)。 正则表达式是一个字符串,使用单个字符串来描述、用来定义匹配规则,匹配一系列符合某个句法规则的字符串。在开发中,正则...
  • 9.java正则表达式

    2018-12-11 12:36:17
    1.基础规则 ... 表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符简单的转义字符 \n 换行符 \t 制表符 \\ \本身 \^ \$ \. \( \) \{...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,723
精华内容 2,289
关键字:

java正则表达式正数

java 订阅