精华内容
下载资源
问答
  • 本文实例讲述了javascript正则表达式使用replace()替换手机号的方法。分享给大家供大家参考。 具体实现方法如下: 代码如下: <html> <head> <title>javascript正则表达式使用replace()替换手机号...
  • ps:下面看下利用正则表达式提取括号内内容 比如现在要提取 中华人们共和国,简称(中国) 这句话中括号里的“中国” import java.util.regex.Matcher; import java.util.regex.Pattern; public class Test { ...
  • 在JS的正则零宽断言匹配中,只支持前瞻匹配,不支持后瞻。这就尴尬了,因为在业务当中,我们大多时候是知道了要目标数据的前后缀字符串,但是并不想连同前后缀一起获取。 为了模拟后瞻,我想,要不就用笨方法,先将...
  • 下面看下正则表达式实现手机号中间4位数隐藏或者只显示末尾四位数 // 匹配手机号首尾,以类似“123****8901”的形式输出 '12345678901'.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2'); 此段正则匹配字符串中的连续11...
  • Java 正则表达式的用法和实例

    万次阅读 多人点赞 2019-06-11 11:17:00
    表达式”t.o“ 可以匹配:tno,t#o,teo等等。不可以匹配:tnno,to,Tno,t正o等。 2、中括号”[]“:只有方括号里面指定的字符才参与匹配,也只能匹配单个字符。 表达式:t[abcd]n 只可以匹配:tan,tbn,tcn,...

    一、概述:

    • 用来描述或者匹配一系列符合某个语句规则的字符串

    二、单个符号

    1、英文句点.符号:匹配单个任意字符。

    • 表达式t.o 可以匹配:tnot#oteo等等。不可以匹配:tnnotoTnot正o等。

    2、中括号[]:只有方括号里面指定的字符才参与匹配,也只能匹配单个字符。

    • 表达式:t[abcd]n 只可以匹配:tantbntcntdn。不可以匹配:thntabntn等。

    3、| 符号。相当与“或”,可以匹配指定的字符,但是也只能选择其中一项进行匹配。

    • 表达式:t(a|b|c|dd)n 只可以匹配:tantbntcntddn。不可以匹配taantntabcn等。

    4、表示匹配次数的符号
    在这里插入图片描述

    • 表达式:[0—9]{ 3 } \— [0-9]{ 2 } \— [0-9]{ 3 } 的匹配格式为:999—99—999
      因为符号在正则表达式中有特殊的含义,它表示一个范围,所以在前面加转义字符\

    5、^符号:表示否,如果用在方括号内,^表示不想匹配的字符。

    • 表达式:[^x] 第一个字符不能是x

    6、\S符号:非空字符
    7、\s符号:空字符,只可以匹配一个空格、制表符、回车符、换页符,不可以匹配自己输入的多个空格。
    8、\r符号:空格符,与\n\tab相同

    三、快捷符号

    1、\d表示[0—9]
    2、\D表示[^0—9]
    3、\w表示[0—9A—Z_a—z]
    4、\W表示[^0—9A—Z_a—z]
    5、\s表示[\t\n\r\f]
    6、\S表示[^\t\n\r\f]

    四、常用的正则表达式

    1、Java:(([a-z]|_)(\\w*)){6,20}匹配以字母或下划线开头,字母数字下划线结尾的字符串
    2、JavaScript:/^(\-?)(\d+)$/匹配数字
    3、JavaScript:/^\w+$/匹配字母数字下划线。

    五、Java 中正则表达式的应用

    1、判断功能

    • public boolean matches(String regex)

    案例:判断录入的手机号是否为13或者18开头

    package Lemon;
    
    import java.util.Scanner;
    
    public class RegexDm {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入手机好:");
            String s = sc.nextLine();
    
            String regex = "1[38]\\d{9}";//定义手机好规则
            boolean flag = s.matches(regex);//判断功能
            System.out.println("flag:"+flag);
        }
    }
    

    2、分割功能

    • public String[] split(String regex)

    案例:

    package Lemon;
    
    import java.util.Scanner;
    
    public class RegexDm {
        public static void main(String[] args){
            String age = "18-24";//定义年龄范围
            String regex = "-";
            String[] strArr = age.split(regex);//分割成字符串数组
    
            int startAge = Integer.parseInt(strArr[0]);
            int endAge = Integer.parseInt(strArr[1]);
    
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您的年龄:");
            int a = sc.nextInt();
            if (a >= startAge && a <= endAge){
                System.out.println("你就是我想找的");
            }else{
                System.out.println("滚");
            }
        }
    }
    

    3、替换功能

    • public String replaceAll(String regex,String replacement)

    案例:

    package Lemon;
    
    public class RegexDm {
        public static void main(String[] args){
            String s = "12342jasfkgnas234";
            //把字符串里面的数字替换成*
            String regex = "\\d";
            String ss = "*";
            String result = s.replaceAll(regex,ss);
            System.out.println(result);
        }
    }
    

    六、常用正则表达式

    • ^\d+$ :非负整数(正整数 + 0)

    • ^[0-9]*[1-9][0-9]*$ :正整数

    • ^((-\d+)|(0+))$ :非正整数(负整数 + 0)

    • ^-[0-9]*[1-9][0-9]*$ :负整数

    • ^-?\d+$ :整数

    • ^\d+(\.\d+)?$ :非负浮点数(正浮点数 + 0)

    • ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$ :正浮点数

    • ^((-\d+(\.\d+)?)|(0+(\.0+)?))$ :非正浮点数(负浮点数 + 0)

    • ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$ :负浮点数

    • ^(-?\d+)(\.\d+)?$ :浮点数

    • ^[A-Za-z]+$ :由26个英文字母组成的字符串

    • ^[A-Z]+$ :由26个英文字母的大写组成的字符串

    • ^[a-z]+$ :由26个英文字母的小写组成的字符串

    • ^[A-Za-z0-9]+$ :由数字和26个英文字母组成的字符串

    • ^\w+$ :由数字、26个英文字母或者下划线组成的字符串

    • ^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$ :email地址

    • ^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$ :url

    • /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/ :年-月-日

    • /^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/ :月/日/年

    • ^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$ :Emil

    • /^((\+?[0-9]{2,4}\-[0-9]{3,4}\-)|([0-9]{3,4}\-))?([0-9]{7,8})(\-[0-9]+)?$/ :电话号码

    • ^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$ :IP地址

    • 匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    • 匹配双字节字符(包括汉字在内):[^\x00-\xff]

    • 匹配空行的正则表达式:\n[\s| ]*\r

    • 匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/

    • 匹配首尾空格的正则表达式:(^\s*)|(\s*$)

    • 匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    • 匹配网址URL的正则表达式:^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$

    • 匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

    • 匹配国内电话号码:(\d{3}-|\d{4}-)?(\d{8}|\d{7})?

    • 匹配腾讯QQ号:^[1-9]*[1-9][0-9]*$

    元字符及其在正则表达式上下文中的行为:

    • \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。
    • ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性,^ 也匹配 \n\r之后的位置。
    • $ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性,$ 也匹配 \n\r之前的位置。
    • * 匹配前面的子表达式零次或多次。
    • + 匹配前面的子表达式一次或多次。+ 等价于 {1,}
    • ? 匹配前面的子表达式零次或一次。? 等价于 {0,1}
    • {n} n 是一个非负整数,匹配确定的n 次。
    • {n,} n 是一个非负整数,至少匹配n 次。
    • {n,m} m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。在逗号和两个数之间不能有空格。
    • ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。
    • . 匹配除 \n之外的任何单个字符。要匹配包括 \n 在内的任何字符,请使用象 [.\n]的模式。
    • (pattern) 匹配pattern 并获取这一匹配。
    • (?:pattern) 匹配pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。
    • (?=pattern) 正向预查,在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。
    • (?!pattern) 负向预查,与(?=pattern)作用相反
    • x|y 匹配 xy
    • [xyz] 字符集合。
    • [^xyz] 负值字符集合。
    • [a-z] 字符范围,匹配指定范围内的任意字符。
    • [^a-z] 负值字符范围,匹配任何不在指定范围内的任意字符。
    • \b 匹配一个单词边界,也就是指单词和空格间的位置。
    • \B 匹配非单词边界。
    • \cx 匹配由x指明的控制字符。
    • \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 为十六进制转义值。十六进制转义值必须为确定的两个数字长。
    • \num 匹配 num,其中num是一个正整数。对所获取的匹配的引用。
    • \n 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式,则 n 为后向引用。否则,如果 n 为八进制数字 (0-7),则 n 为一个八进制转义值
    • \nm 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式,则 nm 为后向引用。如果 \nm 之前至少有 n 个获取,则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足,若 n 和 m 均为八进制数字 (0-7),则 \nm 将匹配八进制转义值 nm
    • \nml 如果 n 为八进制数字 (0-3),且 ml 均为八进制数字 (0-7),则匹配八进制转义值 nml
    • \un 匹配 n,其中 n 是一个用四个十六进制数字表示的Unicode字符。
    • 匹配中文字符的正则表达式: [u4e00-u9fa5]
    • 匹配双字节字符(包括汉字在内):[^x00-xff]
    • 匹配空行的正则表达式:n[s| ]*r
    • 匹配HTML标记的正则表达式:/<(.*)>.*</1>|<(.*) />/
    • 匹配首尾空格的正则表达式:(^s*)|(s*$)
    • 匹配Email地址的正则表达式:w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
    • 匹配网址URL的正则表达式:http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

    利用正则表达式限制网页表单里的文本框输入内容:

    • 用正则表达式限制只能输入中文:onkeyup="value=value.replace(/[^u4E00-u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^u4E00-u9FA5]/g,''))"
    • 用正则表达式限制只能输入全角字符: onkeyup="value=value.replace(/[^uFF00-uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^uFF00-uFFFF]/g,''))"
    • 用正则表达式限制只能输入数字:onkeyup="value=value.replace(/[^d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"
    • 用正则表达式限制只能输入数字和英文:onkeyup="value=value.replace(/[W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

    整理:

    • 匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    • 匹配双字节字符(包括汉字在内):[^\x00-\xff]

    • 匹配空行的正则表达式:\n[\s| ]*\r

    • 匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/

    • 匹配首尾空格的正则表达式:(^\s*)|(\s*$)

    • 匹配IP地址的正则表达式:/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //

    • 匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    • 匹配网址URL的正则表达式:http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

    • sql语句:^(select|drop|delete|create|update|insert).*$

    • 非负整数:^\d+$

    • 正整数:^[0-9]*[1-9][0-9]*$

    • 非正整数:^((-\d+)|(0+))$

    • 负整数:^-[0-9]*[1-9][0-9]*$

    • 整数:^-?\d+$

    • 非负浮点数:^\d+(\.\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+)?)|(0+(\.0+)?))$

    • 负浮点数:^(-((正浮点数正则式)))$

    • 英文字符串:^[A-Za-z]+$

    • 英文大写串:^[A-Z]+$

    • 英文小写串:^[a-z]+$

    • 英文字符数字串:^[A-Za-z0-9]+$

    • 英数字加下划线串:^\w+$

    • E-mail地址:^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$

    • URL:^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$ 或者:^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~@[\]\':+!]*([^<>\"\"])*$

    • 邮政编码:^[1-9]\d{5}$

    • 中文:^[\u0391-\uFFE5]+$

    • 电话号码:^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$

    • 手机号码:^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$

    • 双字节字符(包括汉字在内):^\x00-\xff

    • 匹配首尾空格:(^\s*)|(\s*$)(像vbscript那样的trim函数)

    • 匹配HTML标记:<(.*)>.*<\/\1>|<(.*) \/>

    • 匹配空行:\n[\s| ]*\r

    • 提取信息中的网络链接:(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

    • 提取信息中的邮件地址:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    • 提取信息中的图片链接:(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

    • 提取信息中的IP地址:(\d+)\.(\d+)\.(\d+)\.(\d+)

    • 提取信息中的中国手机号码:(86)*0*13\d{9}

    • 提取信息中的中国固定电话号码:(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}

    • 提取信息中的中国电话号码(包括移动和固定电话):(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}

    • 提取信息中的中国邮政编码:[1-9]{1}(\d+){5}

    • 提取信息中的浮点数(即小数):(-?\d*)\.?\d+

    • 提取信息中的任何数字 :(-?\d*)(\.\d+)?

    • IP地址:(\d+)\.(\d+)\.(\d+)\.(\d+)

    • 电话区号:/^0\d{2,3}$/

    • 腾讯QQ号:^[1-9]*[1-9][0-9]*$

    • 帐号(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

    • 中文、英文、数字及下划线:^[\u4e00-\u9fa5_a-zA-Z0-9]+$

    七、实例

    1、效验QQ号(要求:5-15位数字,0不能开头)

    package Lemon;
    
    import java.util.Scanner;
    
    public class RegexDm {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您的QQ号码:");
            String qq = sc.nextLine();
            System.out.println("checkQQ:"+checkQQ(qq));
        }
    
        private static boolean checkQQ(String qq) {
            return qq.matches("[1-9]{1}\\d{4,14}");
        }
    }
    
    展开全文
  • java正则表达式分组替换实现 java并没有提供类似csharp的正则表达式分组替换机制,要做高级的正则表达式分组替换需要自己实现。 所幸的是Elliott Hughes已经实现了java的正则表达是分组替换。 下面是它的实现代码: ...

    分组替换

    java正则表达式分组替换实现

    java并没有提供类似csharp的正则表达式分组替换机制,要做高级的正则表达式分组替换需要自己实现。

    所幸的是Elliott Hughes已经实现了java的正则表达是分组替换。

    下面是它的实现代码:

    import java.util.regex.*;
    
    /**
     * A Rewriter does a global substitution in the strings passed to its
     * 'rewrite' method. It uses the pattern supplied to its constructor, and is
     * like 'String.replaceAll' except for the fact that its replacement strings
     * are generated by invoking a method you write, rather than from another
     * string. This class is supposed to be equivalent to Ruby's 'gsub' when
     * given a block. This is the nicest syntax I've managed to come up with in
     * Java so far. It's not too bad, and might actually be preferable if you
     * want to do the same rewriting to a number of strings in the same method
     * or class. See the example 'main' for a sample of how to use this class.
     *
     * @author Elliott Hughes
     */
    public abstract class Rewriter
    {
      private Pattern pattern;
      private Matcher matcher;
    
      /**
       * Constructs a rewriter using the given regular expression; the syntax is
       * the same as for 'Pattern.compile'.
       */
      public Rewriter(String regex)
      {
        this.pattern = Pattern.compile(regex);
      }
    
      /**
       * Returns the input subsequence captured by the given group during the
       * previous match operation.
       */
      public String group(int i)
      {
        return matcher.group(i);
      }
    
      /**
       * Overridden to compute a replacement for each match. Use the method
       * 'group' to access the captured groups.
       */
      public abstract String replacement();
    
      /**
       * Returns the result of rewriting 'original' by invoking the method
       * 'replacement' for each match of the regular expression supplied to the
       * constructor.
       */
      public String rewrite(CharSequence original)
      {
        this.matcher = pattern.matcher(original);
        StringBuffer result = new StringBuffer(original.length());
        while (matcher.find())
        {
          matcher.appendReplacement(result, "");
          result.append(replacement());
        }
        matcher.appendTail(result);
        return result.toString();
      }
    
      public static void main(String... args) throws Exception
      {
        String str = "12 54 1 65";
    
        // anonymous subclass
        Rewriter tripler = new Rewriter("(\\d{1,2})")
        {
          public String replacement()
          {
            int intValue = Integer.valueOf(group(1));
            return String.valueOf(intValue * 3);
          }
        };
        System.out.println(tripler.rewrite(str));
    
        // inline subclass
        System.out.println(new Rewriter("(\\d{1,2})")
        {
          public String replacement()
          {
            int intValue = Integer.valueOf(group(1));
            return String.valueOf(intValue * 3);
          }
        }.rewrite(str));
    
      }
    }
    

    Rewriter类是一个抽象类,我们需要根据需要实现replacement()方法,该方法会根据正则匹配的分组的结果返回要替换的值。

    展开全文
  • java正则表达式详解

    万次阅读 多人点赞 2019-04-02 16:35:46
    一、正则表达式术语 1)元字符 : 非一般字符,具有某种意义的字符。如 : \bX : \b边界符, 以 X开始的单词 2)正则表达式语法大全 字符 说明 \ 将下一字符标记为特殊字符...

    微信搜索:“二十同学” 公众号,欢迎关注一条不一样的成长之路

    一、正则表达式术语

     1)元字符 : 非一般字符,具有某种意义的字符。如 : \bX : \b边界符, 以 X开始的单词  

    2)正则表达式语法大全

    字符

    说明

    \

    将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"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 匹配版权符号 (©)。

    二、Pattern类与Matcher类详解

            java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式。 Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查。 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式,然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

    以下我们就分别来看看这两个类:

    捕获组的概念

    捕获组可以通过从左到右计算其开括号来编号,编号是从1 开始的。例如,在表达式 ((A)(B(C)))中,存在四个这样的组:

    ((A)(B(C)))
    (A)
    (B(C))
    (C)

    组零始终代表整个表达式。 以 (?) 开头的组是纯的非捕获 组,它不捕获文本,也不针对组合计进行计数。

           与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组,则在第二次计算失败时将保留其以前捕获的值(如果有的话)例如,将字符串"aba" 与表达式(a(b)?)+ 相匹配,会将第二组设置为 "b"。在每个匹配的开头,所有捕获的输入都会被丢弃。

    详解Pattern类和Matcher类

           java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳). 
           Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式, 

    Pattern p=Pattern.compile("\\w+"); 
    p.pattern();//返回 \w+ 

    pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

    1.Pattern.split(CharSequence input)

             Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[],我猜String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的. 

    Pattern p=Pattern.compile("\\d+"); 
    String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); 

    结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com" 

    2.Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.

    Pattern.matches("\\d+","2223");//返回true 
    Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到 
    Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到 

    3.Pattern.matcher(CharSequence input)

             说了这么多,终于轮到Matcher类登场了,Pattern.matcher(CharSequence input)返回一个Matcher对象.
             Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例. 
             Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

    4.Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()

            Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false 
            matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.matches();//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功. 
    Matcher m2=p.matcher("2223"); 
    m2.matches();//返回true,因为\d+匹配到了整个字符串

           我们现在回头看一下Pattern.matcher(String regex,CharSequence input),它与下面这段代码等价 
    Pattern.compile(regex).matcher(input).matches() 
    lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.lookingAt();//返回true,因为\d+匹配到了前面的22 
    Matcher m2=p.matcher("aa2223"); 
    m2.lookingAt();//返回false,因为\d+不能匹配前面的aa 

    find()对字符串进行匹配,匹配到的字符串可以在任何位置. 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.find();//返回true 
    Matcher m2=p.matcher("aa2223"); 
    m2.find();//返回true 
    Matcher m3=p.matcher("aa2223bb"); 
    m3.find();//返回true 
    Matcher m4=p.matcher("aabb"); 
    m4.find();//返回false 

    5.Mathcer.start()/ Matcher.end()/ Matcher.group()

        当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息. 

    • start()返回匹配到的子字符串在字符串中的索引位置. 
    • end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置. 
    • group()返回匹配到的子字符串 
    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("aaa2223bb"); 
    m.find();//匹配2223 
    m.start();//返回3 
    m.end();//返回7,返回的是2223后的索引号 
    m.group();//返回2223 
    
    Mathcer m2=m.matcher("2223bb"); 
    m.lookingAt();   //匹配2223 
    m.start();   //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0 
    m.end();   //返回4 
    m.group();   //返回2223 
    
    Matcher m3=m.matcher("2223bb"); 
    m.matches();   //匹配整个字符串 
    m.start();   //返回0,原因相信大家也清楚了 
    m.end();   //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串 
    m.group();   //返回2223bb 

            说了这么多,相信大家都明白了以上几个方法的使用,该说说正则表达式的分组在java中是怎么使用的. 
    start(),end(),group()均有一个重载方法它们是start(int i),end(int i),group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组. 

    Pattern p=Pattern.compile("([a-z]+)(\\d+)"); 
    Matcher m=p.matcher("aaa2223bb"); 
    m.find();   //匹配aaa2223 
    m.groupCount();   //返回2,因为有2组 
    m.start(1);   //返回0 返回第一组匹配到的子字符串在字符串中的索引号 
    m.start(2);   //返回3 
    m.end(1);   //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置. 
    m.end(2);   //返回7 
    m.group(1);   //返回aaa,返回第一组匹配到的子字符串 
    m.group(2);   //返回2223,返回第二组匹配到的子字符串 

    现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单. 
     

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com"); 
    while(m.find()) { 
         System.out.println(m.group()); 
    } 
    
    //输出: 
    
    456456 
    0532214 
    123 
    
    
    //如将以上while()循环替换成 
    
    while(m.find()) { 
         System.out.println(m.group()); 
         System.out.print("start:"+m.start()); 
         System.out.println(" end:"+m.end()); 
    } 
    
    //则输出: 
    
    456456 
    start:6 end:12 
    0532214 
    start:19 end:26 
    123 
    start:36 end:39 

             现在大家应该知道,每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息. 
             注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用.

    三、常用的正则表达式:

    (1)    "^\d+$"  //非负整数(正整数 + 0)

    (2)    "^[0-9]*[1-9][0-9]*$"  //正整数

    (3)    "^((-\d+)|(0+))$"  //非正整数(负整数 + 0)

    (4)    "^-[0-9]*[1-9][0-9]*$"  //负整数

    (5)    "^-?\d+$"    //整数

    (6)    "^\d+(\.\d+)?$"  //非负浮点数(正浮点数 + 0)

    (7)    "^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"  //正浮点数

    (8)    "^((-\d+(\.\d+)?)|(0+(\.0+)?))$"  //非正浮点数(负浮点数 + 0)

    (9)    "^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"  //负浮点数

    (10)  "^(-?\d+)(\.\d+)?$"  //浮点数

    (11)  "^[A-Za-z]+$"  //由26个英文字母组成的字符串

    (12)  "^[A-Z]+$"  //由26个英文字母的大写组成的字符串

    (13)  "^[a-z]+$"  //由26个英文字母的小写组成的字符串

    (14)  "^[A-Za-z0-9]+$"  //由数字和26个英文字母组成的字符串

    (15)  "^\w+$"  //由数字、26个英文字母或者下划线组成的字符串

    (16)  "^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"    //email地址

    (17)  "^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"  //url

    (18)  /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/   //  年-月-日

    (19)  /^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/   // 月/日/年

    (20)  "^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$"   //Emil

    (21)  /^((\+?[0-9]{2,4}\-[0-9]{3,4}\-)|([0-9]{3,4}\-))?([0-9]{7,8})(\-[0-9]+)?$/     //电话号码

    (22)  "^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$"   //IP地址

    (23)   

    (24)  匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    (25)  匹配双字节字符(包括汉字在内):[^\x00-\xff]

    (26)  匹配空行的正则表达式:\n[\s| ]*\r

    (27)  匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/

    (28)  匹配首尾空格的正则表达式:(^\s*)|(\s*$)

    (29)  匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    (30)  匹配网址URL的正则表达式:^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$

    (31)  匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

    (32)  匹配国内电话号码:(\d{3}-|\d{4}-)?(\d{8}|\d{7})?

    (33)  匹配腾讯QQ号:^[1-9]*[1-9][0-9]*$

    (34)  元字符及其在正则表达式上下文中的行为:

    (35)  \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。

    (36)  ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性,^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。

    (37)  $ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性,$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。

    (38)  * 匹配前面的子表达式零次或多次。

    (39)  + 匹配前面的子表达式一次或多次。+ 等价于 {1,}。

    (40)  ? 匹配前面的子表达式零次或一次。? 等价于 {0,1}。

    (41)  {n} n 是一个非负整数,匹配确定的n 次。

    (42)  {n,} n 是一个非负整数,至少匹配n 次。

    (43)  {n,m} m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。在逗号和两个数之间不能有空格。

    (44)  ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。

    (45)  . 匹配除 "\n" 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符,请使用象 ’[.\n]’ 的模式。

    (46)  (pattern) 匹配pattern 并获取这一匹配。

    (47)  (?:pattern) 匹配pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。

    (48)  (?=pattern) 正向预查,在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。

    (49)  (?!pattern) 负向预查,与(?=pattern)作用相反

    (50)  x|y 匹配 x 或 y。

    (51)  [xyz] 字符集合。

    (52)  [^xyz] 负值字符集合。

    (53)  [a-z] 字符范围,匹配指定范围内的任意字符。

    (54)  [^a-z] 负值字符范围,匹配任何不在指定范围内的任意字符。

    (55)  \b 匹配一个单词边界,也就是指单词和空格间的位置。

    (56)  \B 匹配非单词边界。

    (57)  \cx 匹配由x指明的控制字符。

    (58)  \d 匹配一个数字字符。等价于 [0-9]。

    (59)  \D 匹配一个非数字字符。等价于 [^0-9]。

    (60)  \f 匹配一个换页符。等价于 \x0c 和 \cL。

    (61)  \n 匹配一个换行符。等价于 \x0a 和 \cJ。

    (62)  \r 匹配一个回车符。等价于 \x0d 和 \cM。

    (63)  \s 匹配任何空白字符,包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

    (64)  \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

    (65)  \t 匹配一个制表符。等价于 \x09 和 \cI。

    (66)  \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。

    (67)  \w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。

    (68)  \W 匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。

    (69)  \xn 匹配 n,其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。

    (70)  \num 匹配 num,其中num是一个正整数。对所获取的匹配的引用。

    (71)  \n 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式,则 n 为后向引用。否则,如果 n 为八进制数字 (0-7),则 n 为一个八进制转义值。

    (72)  \nm 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式,则 nm 为后向引用。如果 \nm 之前至少有 n 个获取,则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足,若 n 和 m 均为八进制数字 (0-7),则 \nm 将匹配八进制转义值 nm。

    (73)  \nml 如果 n 为八进制数字 (0-3),且 m 和 l 均为八进制数字 (0-7),则匹配八进制转义值 nml。

    (74)  \un 匹配 n,其中 n 是一个用四个十六进制数字表示的Unicode字符。

    (75)  匹配中文字符的正则表达式: [u4e00-u9fa5]

    (76)  匹配双字节字符(包括汉字在内):[^x00-xff]

    (77)  匹配空行的正则表达式:n[s| ]*r

    (78)  匹配HTML标记的正则表达式:/<(.*)>.*</1>|<(.*) />/

    (79)  匹配首尾空格的正则表达式:(^s*)|(s*$)

    (80)  匹配Email地址的正则表达式:w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*

    (81)  匹配网址URL的正则表达式:http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

    (82)  利用正则表达式限制网页表单里的文本框输入内容:

    (83)  用正则表达式限制只能输入中文:οnkeyup="value=value.replace(/[^u4E00-u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^u4E00-u9FA5]/g,''))"

    (84)  用正则表达式限制只能输入全角字符: οnkeyup="value=value.replace(/[^uFF00-uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^uFF00-uFFFF]/g,''))"

    (85)  用正则表达式限制只能输入数字:οnkeyup="value=value.replace(/[^d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

    (86)  用正则表达式限制只能输入数字和英文:οnkeyup="value=value.replace(/[W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

    (87)  整理:

    (88)  匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    (89)  匹配双字节字符(包括汉字在内):[^\x00-\xff]

    (90)  匹配空行的正则表达式:\n[\s| ]*\r

    (91)  匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/

    (92)  匹配首尾空格的正则表达式:(^\s*)|(\s*$)

    (93)  匹配IP地址的正则表达式:/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //

    (94)  匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    (95)  匹配网址URL的正则表达式:http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

    (96)  sql语句:^(select|drop|delete|create|update|insert).*$

    (97)  非负整数:^\d+$

    (98)  正整数:^[0-9]*[1-9][0-9]*$

    (99)  非正整数:^((-\d+)|(0+))$

    (100)  负整数:^-[0-9]*[1-9][0-9]*$

    (101)  整数:^-?\d+$

    (102)  非负浮点数:^\d+(\.\d+)?$

    (103)  正浮点数:^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$

    (104)  非正浮点数:^((-\d+\.\d+)?)|(0+(\.0+)?))$

    (105)  负浮点数:^(-((正浮点数正则式)))$

    (106)  英文字符串:^[A-Za-z]+$

    (107)  英文大写串:^[A-Z]+$

    (108)  英文小写串:^[a-z]+$

    (109)  英文字符数字串:^[A-Za-z0-9]+$

    (110)  英数字加下划线串:^\w+$

    (111)  E-mail地址:^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$

    (112)  URL:^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$

    或:^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$

    (113)  邮政编码:^[1-9]\d{5}$

    (114)  中文:^[\u0391-\uFFE5]+$

    (115)  电话号码:^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$

    (116)  手机号码:^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$

    (117)  双字节字符(包括汉字在内):^\x00-\xff

    (118)  匹配首尾空格:(^\s*)|(\s*$)(像vbscript那样的trim函数)

    (119)  匹配HTML标记:<(.*)>.*<\/\1>|<(.*) \/>

    (120)  匹配空行:\n[\s| ]*\r

    (121)  提取信息中的网络链接:(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

    (122)  提取信息中的邮件地址:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    (123)  提取信息中的图片链接:(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

    (124)  提取信息中的IP地址:(\d+)\.(\d+)\.(\d+)\.(\d+)

    (125)  提取信息中的中国手机号码:(86)*0*13\d{9}

    (126)  提取信息中的中国固定电话号码:(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}

    (127)  提取信息中的中国电话号码(包括移动和固定电话):(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}

    (128)  提取信息中的中国邮政编码:[1-9]{1}(\d+){5}

    (129)  提取信息中的浮点数(即小数):(-?\d*)\.?\d+

    (130)  提取信息中的任何数字 :(-?\d*)(\.\d+)?

    (131)  IP:(\d+)\.(\d+)\.(\d+)\.(\d+)

    (132)  电话区号:/^0\d{2,3}$/

    (133)  腾讯QQ号:^[1-9]*[1-9][0-9]*$

    (134)  帐号(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

    (135)  中文、英文、数字及下划线:^[\u4e00-\u9fa5_a-zA-Z0-9]+$ 

     

    展开全文
  • Java正则表达式示例

    2020-06-04 10:52:04
    Java 8流和正则表达式示例。 注意 在Wikipedia上学习基本的正则表达式 1. String.matches(regex) 1.1在此示例中,检查字符串是否为数字。 JavaRegEx1.java package com.mkyong.regex; import java.util...

    Java 8流和正则表达式示例。

    注意
    Wikipedia上学习基本的正则表达式

    1. String.matches(regex)

    1.1在此示例中,检查字符串是否为数字。

    JavaRegEx1.java
    package com.mkyong.regex;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class JavaRegEx1 {
    
        public static void main(String[] args) {
    
            List<String> numbers = Arrays.asList("1", "20", "A1", "333", "A2A211");
    
            for (String number : numbers) {
    		
                if (number.matches("\\d+")) {
                    System.out.println(number);		// 1, 20, 333
                }
            }
    
            // Java 8 stream example
            numbers.stream()
                    .filter(x -> x.matches("\\d+"))
                    .forEach(System.out::println);
    
        }
    }

    输出量

    1
    20
    333
    
    1
    20
    333

    2. String.replaceAll(正则表达式,替换)

    2.1本示例将所有数字替换为#

    JavaRegEx2.java
    package com.mkyong.regex;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class JavaRegEx2 {
    
        public static void main(String[] args) {
    
            List<String> numbers = Arrays.asList("1", "20", "A1", "333", "A2A211");
    
            for (String number : numbers) {
                System.out.println(number.replaceAll("\\d", "#"));
            }
    
            // Java 8 stream example
            numbers.stream()
                    .map(x -> x.replaceAll("\\d", "#"))
                    .forEach(System.out::println);
    
        }
    }

    输出量

    #
    ##
    A#
    ###
    A#A###
    
    #
    ##
    A#
    ###
    A#A###

    3.模式和匹配器

    3.1从“字符串”列表中查找所有数字。

    JavaRegEx3.java
    package com.mkyong.regex;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class JavaRegEx3 {
    
        public static void main(String[] args) {
    
            List<String> numbers = Arrays.asList("1", "20", "A1", "333", "A2A211");
    
            Pattern pattern = Pattern.compile("\\d+");
    
            for (String number : numbers) {
    
                Matcher matcher = pattern.matcher(number);
                while (matcher.find()) {
                    System.out.println(matcher.group(0));
                }
    
            }
    	
    	}
    }

    输出量

    1
    20
    1
    333
    2
    211

    3.2对于Java 8流,首先我们尝试进行如下转换:

    numbers.stream()
    		.map(x -> pattern.matcher(x))
    		.filter(Matcher::find)          // A2A211, will it loop?
    		.map(x -> x.group())
    		.forEach(x -> System.out.println(x));

    输出,最后的211是否丢失?

    1
    20
    1
    333
    2

    流无法循环.filter来获取所有组,我们需要使用自定义的Spliterators进行破解

    JavaRegEx4.java
    package com.mkyong.regex;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Spliterators;
    import java.util.function.Consumer;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import java.util.stream.StreamSupport;
    
    public class JavaRegEx4 {
    
        public static void main(String[] args) {
    
            List<String> numbers = Arrays.asList("1", "20", "A1", "333", "A2A211");
    
            Pattern pattern = Pattern.compile("\\d+");
    
            numbers.stream()
                    .flatMap(x ->
                            StreamSupport.stream(new MatchItr(pattern.matcher(x)), false))
                    .forEach(x -> System.out.println(x));
    
    
        }
    
        final static class MatchItr extends Spliterators.AbstractSpliterator<String> {
            private final Matcher matcher;
    
            MatchItr(Matcher m) {
                super(m.regionEnd() - m.regionStart(), ORDERED | NONNULL);
                matcher = m;
            }
    
            public boolean tryAdvance(Consumer<? super String> action) {
                if (!matcher.find()) return false;
                action.accept(matcher.group());
                return true;
            }
        }
    
    }

    输出量

    1
    20
    1
    333
    2
    211

    4. Java 9,Scanner.findAll(regex)

    4.1 Java 9,我们可以使用Scanner.findAll(regex)返回与提供的正则表达式匹配的匹配结果流。

    Scanner scan = new Scanner("A2A211");
    	List<String> collect = scan
    			.findAll("\\d+")
    			.map(m -> m.group())
    			.collect(Collectors.toList());
    	collect.forEach(x -> System.out.println(x));

    输出量

    2
    211

    最终版本,带有Java 9。

    JavaRegEx5.java
    package com.mkyong.regex;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Scanner;
    import java.util.regex.Pattern;
    import java.util.stream.Collectors;
    
    public class JavaRegEx5 {
    
        public static void main(String[] args) {
    
            List<String> numbers = Arrays.asList("1", "20", "A1", "333", "A2A211");
    
            Pattern pattern = Pattern.compile("\\d+");
    
            List<String> collect = numbers.stream()
                    .map(x -> new Scanner(x).findAll(pattern)
                            .map(m -> m.group())
                            .collect(Collectors.toList())
                    )
                    .flatMap(List::stream)
                    .collect(Collectors.toList());
    
            collect.forEach(x -> System.out.println(x));
    
        }
    
    }

    输出量

    1
    20
    1
    333
    2
    211

    参考文献

    翻译自: https://mkyong.com/java/java-regular-expression-examples/

    展开全文
  • Java正则表达式之分组和替换

    万次阅读 多人点赞 2019-08-24 08:36:17
    正则表达式的分组不是很好懂,但却是很强大的文本处理工具。 1 分组替换 什么是分组,直接引用 Java Api 中 Pattern 中的描述: Capturing groups are numbered by counting their opening parentheses from ...
  • Java 正则表达式 匹配sql参数和替换 目录 匹配和替换sql里面的参数 要求: 代码: 思考: 总结: 语法: \\s 匹配空格 在动态sql查询中,需要替换sql查询语句的条件 匹配和替换sql里面的参数 要求: ...
  • java 正则表达式验证

    千次阅读 2019-06-28 13:03:39
    import java.util.regex.Matcher; import java.util.regex.Pattern; public final class RegExpValidatorUtils { /** * 验证邮箱 * * @param 待验证的字符串 * @return 如果是符合的字符串,返回 <...
  • 1、正则表达式 边界匹配器: 开头: 以 ^ 开头 -> /^ 结尾: 以 $ 结尾 -> /$ 正则表达式常用API: String replaceAll(String regex, String replacement) boolean matches(String regex) 判断是否...
  • 代码 public static void main(String[] args) { String pattern = "[\\s|!|@|#|$|%|^|&|*|(|)|_|+|=|{|}|:|\"|<|>|?|\\[|\\]|;|'|,|.|/|" + "!|@|#|¥|%|…|…|&|*|(|)|—|+|:|“|《|... Patte
  • java正则表达式使用

    千次阅读 2019-03-27 11:41:45
    正则表达式 是什么: 正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串 干什么:正则主要用于 字符串中 为方便 字符串操作 ,很多地方不使用正则表达式也能达到目的,但是可能麻烦很多。 怎么...
  • Java正则表达式的概念及使用

    千次阅读 多人点赞 2020-04-08 20:47:15
    正则表达式(Regular Expression) 1、什么是正则表达式正则表达式使用单个字符串来描述,匹配一系列符合某个语句规则的字符串,定义了字符串的模式。 2、正则表达式用来干什么? 正则表达式主要用于字符串中...
  • java 正则表达式不包含某个字符

    千次阅读 2020-07-29 09:34:25
    java 正则表达式不包含某个字符 由于需要对sql进行匹配,需要正则表达式前不包含,或? 具体方式如下: Pattern pattern = Pattern.compile("(?!,|\\s)\\@\\{(.*?)}",Pattern.CASE_INSENSITIVE); Matcher matcher...
  • 本资源文件是我自己总结的,其中包括5个类,这5个类的代码基本概括了java正则表达式替换String的多种情况,比如获取某个文件路径中盘符/后边的部分内容,提取"<title>XXXX</title>"中的文字XXXX,用正则表达式获取指定...
  •  今天在处理SQL语句的时候,由于数据库中存的格式是VARCHAR2型的,这就需要对SQL语句中WHERE条件后边的带数字的字符串加上单引号,对于字符串的处理,首先想到的就是正则表达式,对正则表达式,虽然有一些了解,...
  • Java正则表达式

    千次阅读 2019-07-06 19:03:50
    java.util.regex程序包只包含用于实现Java正则表达式处理技术的两个类,分别名为Pattern和Matcher。自然而然你会想到正则表达式由模式匹配(pattern matching)而成。java.lang还定义了一个新接口,它支持这些新的类...
  • java 正则表达式详细用法

    万次阅读 多人点赞 2017-04-17 21:49:43
    1正则表达式1.1。什么是正则表达式正则表达式定义字符串的搜索模式 正则表达式的英文全称是regular expression。搜索模式可以是简单字符,固定字符串或包含描述模式的特殊字符的复杂表达式的任何内容 由...
  • 简介 在我们日常开发中,常常会对一些固定信息需要识别,如:手机号、身份证等。...那么就需要过滤一些基本的垃圾信息,提示用户输入错误,需要重新输入。 代码工具类 public class InfoFilterUtil { ...
  • // 正则表达式 Pattern pattern = Pattern.compile(patternStr); // 参数:要匹配的目标字符串 Map,String> map = new HashMap,String>(); map.put("$user_name$","user_value"); map.put("$company_name$",...
  • Java 正则表达式

    2020-06-03 11:52:16
    Java 正则表达式 正则表达式定义了字符串的模式。可以用来搜索、编辑或处理文本。正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。 正则表达式实例 java.util.regex 包主要包括以下三个类: ...
  • 因为正则表达式是一个很庞大复杂的体系,在此仅列举一些些入门的常用的概念和例子,更多的请参阅相关书籍及自行摸索。 比如 public String testForStringFilter(String s){  // 清除掉所有特殊字符  String ...
  • java正则表达式及字符串处理详解本篇博文主要是对java String类涉及正则表达式方法及java.util.regex包中相关类和方法的一个总结 String类相关方法 boolean matches(String regex) 告知此字符串是否匹配给定的正则...
  • 因为正则表达式是一个很庞杂的体系,此例仅举些入门的概念,更多的请参阅相关书籍及自行摸索。 \\  反斜杠 \t  间隔  ('\u0009') \n  换行  ('\u000A') \r  回车  ('\u000D') ...
  • 最近开发遇到个需求,需要使用正则来替换字符串中间的一部分内容,也是面向百度探索了一番,之前还没怎么在实际中用过正则_,这里记录一下。
  • Java正则表达式循环匹配字符串

    千次阅读 2020-03-11 14:36:09
    // 正则表达式 Pattern pattern = Pattern.compile(patternStr); // 参数:要匹配的目标字符串 Map map = new HashMap(); map.put("$user_name$","user_value"); map.put("$company_name$","company_value"); map....
  • replace和replaceAll是JAVA中常用的替换字符的方法,它们的区别是: 1)replace的参数是char和CharSequence,即可以支持字符的替换,也支持字符串的替换(CharSequence即字符串序列的意思,说白了也就是字符串); 2)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,632
精华内容 13,852
关键字:

java正则表达式replace

java 订阅