精华内容
下载资源
问答
  • 获取大括号小括号内容 项目开发用到了,暂做个简单记录 private static String regex = "\\{([^}]*)\\}";//匹配大括号 private static String regexx = "\\(([^}]*)\\)";//匹配小括号 public static void main...
  • 正则表达式,又称正规表示法、常规表示法(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多...
  • JAVA 正则表达式记录

    2021-11-18 14:55:41
    java 正则表达式

    java.util.regex 包主要包括以下三个类:

    • Pattern 类:

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

    • Matcher 类:

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

    • PatternSyntaxException:

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

    • 捕获组

      捕获组是把多个字符当一个单独单元进行处理的方法,它通过对括号内的字符分组来创建。

    • 调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。

    • (group(0)),它总是代表整个表达式。


      在 Java 的正则表达式中,两个 \\ 代表其他语言中的一个 \,这也就是为什么表示一位数字的正则表达式是 \\d,而表示一个普通的反斜杠是 \\

      以下为菜鸟教程示例

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
     
    public class RegexMatches
    {
        public static void main( String[] args ){
     
          // 按指定模式在字符串查找
          String line = "This order was placed for QT3000! OK?";
          String pattern = "(\\D*)(\\d+)(.*)";
     
          // 创建 Pattern 对象
          Pattern r = Pattern.compile(pattern);
     
          // 现在创建 matcher 对象
          Matcher m = r.matcher(line);
          if (m.find( )) {
             System.out.println("Found value: " + m.group(0) );
             System.out.println("Found value: " + m.group(1) );
             System.out.println("Found value: " + m.group(2) );
             System.out.println("Found value: " + m.group(3) ); 
          } else {
             System.out.println("NO MATCH");
          }
       }
    }
    Found value: This order was placed for QT3000! OK?
    Found value: This order was placed for QT
    Found value: 3000
    Found value: ! OK?

    \D

    非数字字符匹配。等效于 [^0-9]。

    ^

    匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配。

    ^  在() []中的区别

    展开全文
  • 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).*$
    
    

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

    正则表达式——总结

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

    展开全文
  • 最近写脚本,需要对脚本中函数传递的路径参数进行截取,发现了以下比较好用的方法,记录下: file=/dir1/dir2/dir3/my.file.txt 我们可以用${ }分别替换获得不同的值: ${file#*/}:拿掉第一条/及其左边的字串:...
  • java正则表达式解析

    万次阅读 多人点赞 2018-11-08 20:59:07
    一、知道java正则表达式是干什么的? 百度百科定义: 其实这已经说得很明确了,正则表达式其实就是一个字符串,这个字符串是按照一定的规则进行组合得来的,而这个规则当然是创始者定义,用这些规则我们能做什么...

    “正则表达式”到用时方恨少!

    学习正则表达式,我觉得还是要循循渐进,由易到难,一点点深入......(本人也在学习中这里提供个人理解思路,以及一些大神们的独到讲解。。。。。。)

    一、知道java正则表达式是干什么的?

    百度百科定义:

    其实这已经说得很明确了,正则表达式其实就是一个字符串,这个字符串是按照一定的规则进行组合得来的,而这个规则当然是创始者定义,用这些规则我们能做什么呢?看红色曲线,这个“规则字符串”用来表达对字符串(这里的字符串是我们自己的)的一种过滤逻辑。

    正则表达式的目的:

    给定一个正则表达式和另一个字符串,我们可以达到如下的目的:

    1. 给定的字符串是否符合正则表达式的过滤逻辑(称作“匹配”):

    2. 可以通过正则表达式,从字符串中获取我们想要的特定部分。

    第一条解释,意思就是我们写了一个字符串,这些字符串是否符合正则表达式的过滤逻辑,举个例子:

    手机号码

    ^1[3|4|5|8][0-9]\\d{8}$ 

    这是我在网上找的例子,这个正则表达式是一个手机号码的表达式,那么就是说我们写了一个字符串13023629739,这个电话号码就是符合这个正则表达式的。

    第二条解释,假如我们要从一个html页面中过滤一些css与js的url,那么整个html就是给定的字符串,而css与js的url就是我们想要的特定的部分。

    二、java正则表达式是怎么用的?

       知道了正则表达式是干什么的,就要说说他在java中是怎么用的。我直接上代码:(匹配实现替换功能

    String  str ="13023629739";
    //该方法接受一个正则表达式作为它的第一个参数。
    Pattern p = Pattern.compile("^1[3|4|5|8][0-9]\\d{8}$");
    //对输入str进行解释和匹配操作
    Matcher m = p.matcher(str);
    if(m.find() ==true) {
    	String replaceAll = str.replaceAll(m.group(), "12345678910");
    	System.out.println(replaceAll);
    }

    输出结果:

    12345678910

    这里用到java.util.regex 包。

    主要包括以下三个类:

    • Pattern 类:

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

    • Matcher 类:

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

    • PatternSyntaxException:

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

    三、弄清楚( )、[ ]、{ }的作用 

     我初学正则时被这三个括号给整的五迷三道的,现在找了一些资料供大家理解。

    正则表达式的() [] {}有不同的意思。

    () 是为了提取匹配的字符串。表达式中有几个()就有几个相应的匹配字符串。

    (\s*)表示连续空格的字符串。

    []是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[\s*]表示空格或者*号。

    {}一般用来表示匹配的长度,比如 \s{3} 表示匹配三个空格,\s{1,3}表示匹配一到三个空格。

    (0-9) 匹配 '0-9′ 本身。 [0-9]* 匹配数字(注意后面有 *,可以为空)[0-9]+ 匹配数字(注意后面有 +,不可以为空){1-9} 写法错误。

    [0-9]{0,9} 表示长度为 0 到 9 的数字字符串。

    ——————————————————————————————————————————————————————

    圆括号()是组,主要应用在限制多选结构的范围/分组/捕获文本/环视/特殊模式处理
    示例:
    1、(abc|bcd|cde),表示这一段是abc、bcd、cde三者之一均可,顺序也必须一致
    2、(abc)?,表示这一组要么一起出现,要么不出现,出现则按此组内的顺序出现
    3、(?:abc)表示找到这样abc这样一组,但不记录,不保存到$变量中,否则可以通过$x取第几个括号所匹配到的项,比如:(aaa)(bbb)(ccc)(?:ddd)(eee),可以用$1获取(aaa)匹配到的内容,而$3则获取到了(ccc)匹配到的内容,而$4则获取的是由(eee)匹配到的内容,因为前一对括号没有保存变量
    4、a(?=bbb) 顺序环视 表示a后面必须紧跟3个连续的b
    5、(?i:xxxx) 不区分大小写 (?s:.*) 跨行匹配.可以匹配回车符

    方括号是单个匹配,字符集/排除字符集/命名字符集
    示例:
    1、[0-3],表示找到这一个位置上的字符只能是0到3这四个数字,与(abc|bcd|cde)的作用比较类似,但圆括号可以匹配多个连续的字符,而一对方括号只能匹配单个字符
    2、[^0-3],表示找到这一个位置上的字符只能是除了0到3之外的所有字符
    3、[:digit:] 0-9 [:alnum:] A-Za-z0-9

    ——————————————————————————————————————————————————————

    ()和[]有本质的区别
    ()内的内容表示的是一个子表达式,()本身不匹配任何东西,也不限制匹配任何东西,只是把括号内的内容作为同一个表达式来处理,例如(ab){1,3},就表示ab一起连续出现最少1次,最多3次。如果没有括号的话,ab{1,3},就表示a,后面紧跟的b出现最少1次,最多3次。另外,括号在匹配模式中也很重要。这个就不延伸了,LZ有兴趣可以自己查查
    []表示匹配的字符在[]中,并且只能出现一次,并且特殊字符写在[]会被当成普通字符来匹配。例如[(a)],会匹配(、a、)、这三个字符。
    所以() [] 无论是作用还是表示的含义,都有天壤之别,没什么联系

    ——————————————————————————————————————————————————————

     四、搞懂正则表达式语法

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

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

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

    字符

    说明

    \

    将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"n"匹配字符"n"。"\n"匹配换行符。序列"\\\\"匹配"\\","\("匹配"("。

    ^

    匹配输入字符串开始的位置。如果设置了 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 次。例如,"o{2}"与"Bob"中的"o"不匹配,但与"food"中的两个"o"匹配。

    {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?'。注意:您不能将空格插入逗号和数字之间。

    ?

    当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如,在字符串"oooo"中,"o+?"只匹配单个"o",而"o+"匹配所有"o"。

    .

    匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。

    (pattern)

    匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用"\("或者"\)"。

    (?:pattern)

    匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如,'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。

    (?=pattern)

    执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows",但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

    (?!pattern)

    执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows",但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

    x|y

    匹配 x 或 y。例如,'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。

    [xyz]

    字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"。

    [^xyz]

    反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain"中"p","l","i","n"。

    [a-z]

    字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a"到"z"范围内的任何小写字母。

    [^a-z]

    反向范围字符。匹配不在指定的范围内的任何字符。例如,"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。

    \b

    匹配一个字边界,即字与空格间的位置。例如,"er\b"匹配"never"中的"er",但不匹配"verb"中的"er"。

    \B

    非字边界匹配。"er\B"匹配"verb"中的"er",但不匹配"never"中的"er"。

    \cx

    匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样,则假定 c 就是"c"字符本身。

    \d

    数字字符匹配。等效于 [0-9]。

    \D

    非数字字符匹配。等效于 [^0-9]。

    \f

    换页符匹配。等效于 \x0c 和 \cL。

    \n

    换行符匹配。等效于 \x0a 和 \cJ。

    \r

    匹配一个回车符。等效于 \x0d 和 \cM。

    \s

    匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。

    \S

    匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。

    \t

    制表符匹配。与 \x09 和 \cI 等效。

    \v

    垂直制表符匹配。与 \x0b 和 \cK 等效。

    \w

    匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。

    \W

    与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。

    \xn

    匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。

    \num

    匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,"(.)\1"匹配两个连续的相同字符。

    \n

    标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n是八进制转义码。

    \nm

    标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获,则 n 是反向引用,后面跟有字符 m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 和 m 是八进制数字 (0-7)。

    \nml

    当 n 是八进制数 (0-3),m 和 l 是八进制数 (0-7) 时,匹配八进制转义码 nml

    \un

    匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 (©)。

     

     知道了这些我觉得就需要很多的练习才能掌握住正则表达式。。。我也在学习过程,后续会把自己的学习经历写下来!

    小例子1:字符串中找数字(写法因人而异)

    /**
     * 字符串中找到数字
     * @author Administrator
     *
     */
    public class FindNum {
    	public static void main(String[] args) {
    		//等价于String pattern="[0-9]{3}";
    		String pattern="[0-9]+";
    		String str = "abc123def";
    		Pattern p = Pattern.compile(pattern);
    		Matcher m = p.matcher(str);
    		if(m.find() ==true) {
    			String string=m.group();
    			System.out.println(string);
    		}
    	}
    }

    小例子二:匹配文件

    /**
     * 匹配文件
     * @author Administrator
     *
     */
    public class File {
    	public static void main(String[] args) {
    		String file1="data.dat";
    		String file2="data1.dat";
    		String file3="data2.dat";
    		String file4="datax.dat";
    		String file5="dataN.dat";
    		//等效于"data(\\w)*\\.dat"  "data(\\w)?\\.dat"
    		String pattern="^data(\\w)*\\.dat$";
    		Pattern p=Pattern.compile(pattern);
    		Matcher m1=p.matcher(file1);
    		Matcher m2=p.matcher(file2);
    		Matcher m3=p.matcher(file3);
    		Matcher m4=p.matcher(file4);
    		Matcher m5=p.matcher(file5);
    		//在执行这条输出之后,下面的不再执行,不知什么缘故?
    		//System.out.println(m1.matches());
    		if(m1.find() ==true) {
    			String string = file1.replaceAll(m1.group(), "m1匹配成功");
    			System.out.println(string);
    		}
    		if(m2.find() ==true) {
    			String string = file2.replaceAll(m2.group(), "m2匹配成功");
    			System.out.println(string);
    		}
    		if(m3.find() ==true) {
    			String string = file3.replaceAll(m3.group(), "m3匹配成功");
    			System.out.println(string);
    		}
    		if(m4.find() ==true) {
    			String string = file4.replaceAll(m4.group(), "m4匹配成功");
    			System.out.println(string);
    		}
    		if(m5.find() ==true) {
    			String string = file5.replaceAll(m5.group(), "m5匹配成功");
    			System.out.println(string);
    		}
    		
    		/**
    		 * 测试data.*\\.dat
    		 * 等价于data.+\\.dat
    		 * 等价于data.{3}\\.dat
    		 * 等价于data[a-z]{3}\\.dat
    		 * 等价于data[a-z]{0,}\\.dat
    		 */
    		String pattern1="data[a-z]{0,}\\.dat";
    		String file6 ="dataacd.dat";
    		Pattern p1=Pattern.compile(pattern1);
    		Matcher m6 =p1.matcher(file6);
    		if(m6.find()==true) {
    			String string = file6.replaceAll(m6.group(), "m6匹配成功");
    			System.out.println(string);
    		}
    	}
    }

    小例子3:注册匹配 

    /**
     * 注册匹配
     * @author Administrator
     *
     */
    public class Registered {
    	public static void main(String[] args) {
    		//注册名
    		String name = "Ghd_Dxf-1314";
    		String name1 = "Ghd_Dxf1314";
    		//匹配正则
    		String pattern="[a-zA-Z0-9_-]{5,15}";
    		Pattern p=Pattern.compile(pattern);
    		Matcher m=p.matcher(name);
    		Matcher m1=p.matcher(name1);
    		if(m.find()==true) {
    			boolean string=name.matches(pattern);
    			System.out.println(string);
    		}
    		if(m1.find()==true) {
    			boolean string=name1.matches(pattern);
    			System.out.println(string);
    		}
    	}
    }
    

    我觉得这个正则就是记住规则,然后多加练习就能熟练掌握。。。。。。。。一起学习吧

    展开全文
  • 之前很少写正则表达式,即便是要判断手机号和邮箱之类的功能也是直接copy的网上的内容,最近工作中用到正则表达式比较多,特此记录正则表达式中最常用到的忽略大小写的写法。 直接上代码: import java.util....

    之前很少写正则表达式,即便是要判断手机号和邮箱之类的功能也是直接copy的网上的内容,最近工作中用到正则表达式比较多,特此记录正则表达式中最常用到的忽略大小写的写法。

    直接上代码:

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Test {
    
    	public static void main(String[] args) {
    		String text = "Invoice No : 654321";
    		Pattern p = Pattern.compile("INVOICE\\s*NO?[\\pP|\\pS\\w\\s]*",Pattern.CASE_INSENSITIVE);
    		Matcher m = p.matcher(text);
    		if (m.matches()) {
    			System.out.println("匹配上了!");
    		}else {
    			System.out.println("没匹配上");
    		}
    	}
    }

    运行结果:

    通过百度可以得知,Pattern.CASE_INSENSITIVE的作用是启用大小写不敏感匹配,等价于修饰符(?i)。

    那么也就是说还有另外一种写法:

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Test {
    
    	public static void main(String[] args) {
    		String text = "Invoice No : 654321";
    		Pattern p = Pattern.compile("(?i)INVOICE\\s*NO?[\\pP|\\pS\\w\\s]*");
    		Matcher m = p.matcher(text);
    		if (m.matches()) {
    			System.out.println("匹配上了!");
    		}else {
    			System.out.println("没匹配上");
    		}
    	}
    }

    运行结果:

    最后,会利用正则表达式去掉多余的信息的话,简直就太方便了:

    public class Test {
    
    	public static void main(String[] args) {
    		String text = "Invoice No : 654321";
    		text = text.replaceAll("(?i)INVOICE\\s*NO?[\\pP|\\pS\\s]*", "");
    		System.out.println(text);
    	}
    }

    运行结果:

     

    展开全文
  • JAVA正则表达式轻松替换JSON中大字段(一)背景(二)正则表达式(三)在JAVA代码中的实现(四)合并正则表达式(五)最终结果(六)所感 (一)背景 在软件开发工作中我们经常用JSON来传输数据,根据业务需要不免...
  • Java正则表达式详细用法

    千次阅读 多人点赞 2019-03-22 23:18:35
    正则表达式是一串特定的字符,正则表达式有两个作用: 一.判断一个给定的字符串是否符合正则校验,返回一个特定的布尔值(true或false) 1. . 和 \ . 在正则表达式中表示任意一个字符 \ 在正则表达式当中表示...
  • Java正则表达式匹配所有字符

    千次阅读 2020-03-24 13:11:19
    Java正则表达式匹配所有字符 使用Java在插件开发过程中发现正则表达式[.\n]*并不能达到匹配所有字符的效果 正解如下,特此记录 可以使用[\s\S]*来匹配 其中\s表示匹配任何空白字符 \S表示匹配任何非空白字符 任何...
  • 文章目录1. 结果2. 表达式3.参考博客 1. 结果 2. 表达式 网上查了很多资料,发现有些博客是错误的。为了防止以后每次都要区分正确还是错误,在这里记录一下。...((25[0-5])|(2[0-4]\d)|(1\d{2})|(([1...在Java代码中使用
  • 由于工作中用到正则表达式不多,一直没有好好学习正则表达式。在网上找到了原版的精通正则表达式(第三版)电子版,抽时间详细学习,下面对最近学到的做个总结。 最近在进行安全检查漏洞修补,在做XSS攻击过滤器时,...
  • Java 正则表达式详解

    2018-04-24 12:34:31
    Java 提供了功能强大的正则表达式API,在java.util.regex 包下。本教程介绍如何使用正则表达式API。 正则表达式 一个正则表达式是一个用于...下面是一个简单的Java正则表达式的例子,用于在文本中搜索 http:// ?
  • 正则表达式到底是什么东西? 字符是计算机软件处理文字时最基本的单位,可能是字母,数字,标点符号,空格,换行符,汉字等等。字符串是0个或更多个字符的序列。文本也就是文字,字符串。说某个字符串匹配某个正则...
  • Java正则表达式过滤html中的标签

    千次阅读 2019-05-21 18:29:58
    今天在写项目中发现,发布一篇文章包含图片时数据库里存入的包含html标签,在文章列表中会显示这些标签,而不是过滤掉这些标签只展示内容,记录一下后台过滤...这是通过后台进行正则表达式的过滤,也可以前台。  
  • Java 正则表达式源码解析

    千次阅读 2019-06-04 22:05:23
    compile 方法解析完正则表达式之后,会得到一个root Node节点。匹配的时候,会调用root Node 的match 方法,rootNode 依次调用next 的match 方法,在match 的过程中,记录匹配的开始结束位置,最终得到结果。我们看...
  • 最近再改freemarker和Mybatis-...在更改controller时,遇到了截取一个时间段变为两个对象的问题,现记录下通过正则表达式截取的过程. 首先上硬核的,正则截取YYYY-MM-DD HH:MM:SS -YYYY-MM-DD HH:MM:SS字段. /** * ...
  • 最近开发遇到个需求,需要使用正则来替换字符串中间的一部分内容,也是面向百度探索了一番,之前还没怎么在实际中用过正则_,这里记录一下。
  • java 正则表达式提取字符串

    万次阅读 2019-03-23 14:30:07
    如果需要提取的字符串没有好的规则,则直接用点.;其他部分剩下的就是自己需要提取的 Pattern p=Pattern.compile("(INSERT INTO PUBLIC\\.WS_TRIGGER_SWITCH VALUES \\(')(.+)(', '.+','1'\\);)");...
  • Java正则表达式学习

    2020-12-21 19:21:30
    Java正则表达式学习 1.概念 正则表达式,又称规则表达式。(英语:Regular Expression,常简写为regex)。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。支持正则表达式的有:PHP、Java、Python、...
  • Java使用正则表达式去除前导0 代码 String s="0000000002121210" s=s.replaceAll("^(0+)", ""); System.out.println(s);
  • java正则表达式判断IP

    千次阅读 2017-05-09 16:40:22
    真正用到的时候,查找就发现很多都是错误的,所以还是自己整理将正确的代码记录一下吧。。   以下亲测可用,判断字符串是否符合IP地址格式   public static boolean isboolIp(String ipAddress) { ...
  • JAVA使用正则表达式对数值进行限制 web开发中对数值进行约束,可以在页面处理,也可以在后端处理。为了保险,量表都进行约束。我记录一下后端Java的处理方便以后查看。 public class RegexUtils { /** * 匹配 ...
  • 正则表达式左侧开始,每出现一个左括号"("做一个分组,分组编号从 1 开始。0 代表整个表达式。 对于时间字符串:2017-04-25,表达式如下 (\\d{4})-((\\d{2})-(\\d{2})) 有 4 个左括号,所以有 4 个分组: ...
  • Lambda表达式、Stream流、正则表达式
  • JAVA正则表达式语法大全

    千次阅读 2016-05-05 09:42:51
    1 [正则表达式]文本框输入内容控制 2 整数或者小数:^[0-9]+\.{0,1}[0-9]{0,2}$ 3 只能输入数字:"^[0-9]*$"。 4 只能输入n位的数字:"^\d{n}$"。 5 只能输入至少n位的数字:"^\d{n,}$"。 6 只能输入m~n位的...
  • JAVA正则表达式

    2018-09-18 23:52:18
    1. 由几个例子引入 .(点号)匹配任何一个字符,如:“a” 或 “1”。 \s+:可匹配多个空格 ^ 定义了以什么开始 ...\d+ 匹配一个或多个数字 ...2. java.util.regex 包主要包括以下三个类: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,694
精华内容 22,277
关键字:

java正则表达式怎么记

java 订阅