正则表达式

正则表达式概述
    * 正则表达式用来进行复杂的字符串操作
        正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，
        组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
    * 许多程序设计语言都支持正则表达式



正则表达式语法(任何语言通用)
    * 方括号
        []用于查找某个范围内的字符,加^表示不包含的意思([]只能匹配一个字符)
        [abc]           查找方括号之间的任何字符。 
        [^abc]          查找任何不在方括号之间的字符。 
        [0-9]           查找任何从 0 至 9 的数字。 
        [a-z]           查找任何从小写 a 到小写 z 的字符。
        [a-z&&[def]]    d、e 或 f（交集） 
        [a-z&&[^m-p]]   a 到 z，而非 m 到 p：[a-lq-z]（减去） 
        注意:在[]中|表示本身.逗号在[]内没有分隔的意思,表示本身
    * 特殊字符
        .       查找单个字符，除了换行和行结束符。 
        \w      查找单词字符。  [a-zA-Z_0-9]
        \W      查找非单词字符。[^\w]
        \d      查找数字。      [0-9]
        \D      查找非数字字符。[^0-9]
        \s      查找空白字符。  [ \t\n\x0B\f\r]
        \S      查找非空白字符。[^\s]
        \n      查找换行符。 
        \f      查找换页符。 
        \r      查找回车符。 
        \t      查找制表符。 
    * 数量词
        n+      匹配任何包含至少一个 n 的字符串。 
        n*      匹配任何包含零个或多个 n 的字符串。 
        n?      匹配任何包含零个或一个 n 的字符串。 
        n{X}    匹配包含 X 个 n 的序列的字符串。 
        n{X,Y}  匹配包含 X 或 Y 个 n 的序列的字符串。 
        n{X,}   匹配包含至少 X 个 n 的序列的字符串。 
    * 边界匹配
        ^n      匹配任何开头为 n 的字符串。
        n$      匹配任何结尾为 n 的字符串。 
        ?=n     匹配任何其后紧接指定字符串 n 的字符串。 span的标签:(<(?=span|/span).*?>),里面的组不会被捕获,且预查不消耗字符
        ?!n     匹配任何其后没有紧接指定字符串 n 的字符串。非span的标签:(<(?!span|/span).*?>),里面的组不会被捕获,且预查不消耗字符
        ?:n     例(?:abc|cde),表示abc或cde,不过加?:表示这个小括号不会被看成一个分组
        \b      查找位于单词的开头或结尾的匹配。 
        \B      查找不处在单词的开头或结尾的匹配。
        注意:?! ?=和?:需要加()
    * 组
        用()括起来的项被分为一组,可以改变优先级,同时匹配内容被捕获以便可以在其它位置被引用.
        捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 
            1   ((A)(B(C)))
            2   (A)
            3   (B(C)) 
            4   (C)
        组0始终代表整个表达式。
        组在同一个正则表达式中可以通过"\编号"来引用,组在其它位置可以通过"$编号"来引用
        例:
            将所有叠词替换为一个字符
                String str = "1aa2bb3ccc4ddd5";
                String str2 = str.replaceAll("(.)\\1+", "$1");
                System.out.println(str2);
        如果仅想改变优先级而不想捕获组,则可以使用(?:内容)的方式,这种方式通常和或运算符一起使用
    * 或运算符(|)
        例:(12|34)5 表示 125 或 345
        被小括号括住的被分为一组,如果不想捕获组可(?:12|34)5
        注意: 在[]中|表示本身
    * 贪婪模式和非贪婪模式
        非贪婪模式就是在量词后多加一个问号,表示尽快匹配
        例:
            String str = "大家好，我是小明。我病了。呜呜";
            String re = "我是(.+)。";   //匹配 "我是小明。我病了。"
            String re = "我是(.+?)。";  //匹配 "我是小明。"



java中的正则表达式
    String类的方法
        * 匹配
            String类的方法
                boolean matches(String regex) 返回此字符串是否匹配给定的正则表达式。 注意:此方法是完全匹配
        * 切割
            String类的方法
                String[] split(String regex) 根据给定的正则表达式的匹配来拆分此字符串。 
                String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。 第二个参数可以指定切割limit-1次,为0为负数表示全切,为0也可去除切割后数组最后的空字符串
        * 替换
            String类的方法
                String replaceAll(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。 
                String replaceFirst(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。 
    Pattern(java.util.regex)
        * 正则表达式的编译表示形式。
        * 获得对象方法:
            static Pattern compile(String regex) 
                将给定的正则表达式编译到模式中。 
            static Pattern compile(String regex, int flags) 
                将给定的正则表达式编译到具有给定标志的模式中。 flags为:不区分大小写,多行模式等
        * 常用方法:
            Matcher matcher(CharSequence input) 
                创建匹配给定输入与此模式的匹配器。 
            static boolean matches(String regex, CharSequence input) 
                编译给定正则表达式并尝试将给定输入与其匹配。 
    Matcher(java.util.regex)
        * 通过解释 Pattern 对 字符序列 执行匹配操作的引擎。 
        * 通过Pattern类的matcher方法获得对象
        * 常用方法:
            int end() 
                返回最后匹配字符之后的偏移量。 
            int end(int group) 
              返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。 
            boolean find() 
                尝试查找与该模式匹配的输入序列的下一个子序列。 
            boolean find(int start) 
                重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。 
            String group() 
                返回由以前匹配操作所匹配的输入子序列。 
            String group(int group) 
                返回在以前匹配操作期间由给定组捕获的输入子序列。 
            int groupCount() 
              返回此匹配器模式中的捕获组数。 
            boolean matches() 
              尝试将整个区域与模式匹配。 
            int start() 
                返回以前匹配的初始索引。 
            int start(int group) 
              返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引。 
            注意:要先find查找一次,才能调用end,group,start方法,否则报异常
    示例
        * 查看邮箱是否是合法邮箱
            String str = "1123734918@qq.com";
            String re = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
            System.out.println(str.matches(re));
        * 查找字符串中单词长度为3的所有单词
            String str = "welcome to my home, but you can't speak";
            Pattern pattern = Pattern.compile("\\b[a-zA-Z]{3}\\b");
            Matcher matcher = pattern.matcher(str);
            while(matcher.find()){
                System.out.println(matcher.group());
                System.out.println("索引范围是:"+matcher.start()+"到"+matcher.end());
            }
        * 将所有叠词替换为一个字符
            String str = "1aa2bb3ccc4ddd5";
            String str2 = str.replaceAll("(.)\\1+", "$1");
            System.out.println(str2);
        * 做一个正则查找程序,读取一个本地文件,从键盘输入正则,查找里面所有的匹配项
            //读取文件
            BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt"),"gbk"));
            StringBuffer str = new StringBuffer();
            String s = null;
            while( (s = in.readLine())!=null ){
                str.append(s+"\r\n");
            }
            //输入正则
            System.out.print("请输入正则:");
            BufferedReader in2 = new BufferedReader(new InputStreamReader(System.in));
            String re = in2.readLine();
            //匹配
            Matcher matcher = Pattern.compile(re).matcher(str);
            int count = 0;
            StringBuffer str2 = new StringBuffer();
            while(matcher.find()){
                count++;
                int groupConut = matcher.groupCount();//始终显示最里面组的内容
                str2.append(matcher.group(groupConut)+"\t索引:"+matcher.start(groupConut)+"~"+matcher.end(groupConut)+"\r\n");
            }
            //打印
            System.out.println("共找到"+count+"个匹配项");
            System.out.println(str2);
        * 判断是否是以135,139,158,187开头,中间四位是3456的合法电话
            String str = "18234569970";
            boolean b = str.matches("(135|139|158|187)3456\\d{4}");//135,139,158,187
            System.out.println(b);