JAVA中的正则表达式--待续

1、关于“”，在JAVA中的正则表达式中的不同；

    在其他语言中"\"表示为：我想要在正则表达式中插入一个普通的反斜杠；

    在Java中“\”表示为：我想要插入一个正则表达式反斜杠；

    eg:验证整数的正则表达式为\d; 如果想要插入一个反斜杠则为：\\ ；

    如果是换行符和制表符则为 和 ；

2、特殊字符

Greedy 数量词
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次
Reluctant 数量词
X??	X，一次或一次也没有
X*?	X，零次或多次
X+?	X，一次或多次
X{n}?	X，恰好 n 次
X{n,}?	X，至少 n 次
X{n,m}?	X，至少 n 次，但是不超过 m 次
Possessive 数量词
X?+	X，一次或一次也没有
X*+	X，零次或多次
X++	X，一次或多次
X{n}+	X，恰好 n 次
X{n,}+	X，至少 n 次
X{n,m}+	X，至少 n 次，但是不超过 m 次

演示代码：

package com.st.day20150525;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringTest03 {
    
    public static String message ="The class String includes methods for examining "
            + "individual characters of the sequence, for comparing strings, "
            + "for searching strings, for extracting substrings, and for "
            + "creating a copy of a string with all characters translated to "
            + "uppercase or to lowercase. Case mapping is based on the Unicode "
            + "Standard version specified by the Character class.";
    
    public static void main(String[] args) {
        /**
         * 首先介绍String自带的三个正则表达式的工具
         */
        //1、使用String中的内建的功能，进行字符的验证
        System.out.println("1、使用String中的内建的功能，进行字符的验证");
        System.out.println("1243".matches("-?\d+"));
        System.out.println("+911".matches("-?\d+"));
        System.out.println("+911".matches("(-|\+)?\d+"));
        
        System.out.println("----------------------------------------------");
        //2、使用String.split() 将字符串从正则表达式匹配的地方分开
        System.out.println("2、使用String.split() 将字符串从正则表达式匹配的地方分开");
        String[] str01 = message.split("of|to");    // 从of 或者 to 的地方进行分开
        for (int i = 0; i < str01.length; i++) {
            System.out.println("第"+i+": "+str01[i]);
        }
        String[] str02 = message.split("\W");     // 从空格的地方进行分开
        for (int i = 0; i < str02.length; i++) {
            System.out.print("第"+i+": "+str02[i]+"  ");
        }
        System.out.println("----------------------------------------------");
        // 3、使用String中的替代，进行正则表达是的验证
        System.out.println("3、使用String中的替代，进行正则表达是的验证");
        String str03 = message.replaceFirst("the|of|to", "你被替换了");
        System.out.println(str03);
        // 替换所有的以f开头的单词
        String str04 = message.replaceAll("f\w+", "apple");
        System.out.println(str04);
        System.out.println("----------------------------------------------");
        /**
         * 使用Pattern、Matcher进行正则表达式验证
         * Pattern：表示编译后的正则表达式对象，可以通过Pattern.compile()来编译你的表达式获取该对象
         * 调用Pattern对象中的matcher方法，传入你要验证的字符串，获取Macher对象；
         * 使用Matcher对象中的方法判断各种不同类型的对象是否匹配成功。
         * 
         * boolean matches()     字符完全匹配
         * boolean lookingAt()   判断字符串开始部分是否能够匹配(不一定是整个字符串)
         * boolean find()        多匹配，从头找到尾，找出所有匹配的字符
         * boolean find(int i)   从第i个字符进行匹配
         * 
         * find()可以在输入的字符的任何位置进行定位匹配正则表达式
         * lookingAt()和matches() 只有在字符的最开始的地方匹配才能成功，
         * lookingAt()只需要字符开始的一部分匹配成功就OK了，matches()需要字符完全的匹配
         */
        Pattern pattern = Pattern.compile("\w+");     
        Matcher matcher = pattern.matcher("I am a good boy!");
        System.out.println("==========Matcher中的find=================");
        while(matcher.find()){
            System.out.println(matcher.group());    // 讲所有的单词隔开
        }
        int i = 0 ;  //  从第三个字符开始
        System.out.println("============测试find(int i)================");
        while(matcher.find(i)){
            System.out.print(matcher.group()+"  ");
            i++ ;
        }
        System.out.println("============测试find()、lookingAt()和matches()的不同=================");
        String str = "Today is a perfect day to start living your dream.";
        
        for(String reg:new String[]{"\w+","Today.*","T\w+"}){
            Pattern p = Pattern.compile(reg);
            Matcher m = p.matcher(str);
            while (m.find())  System.out.println("find() :"+m.group()+"==="+m.start()+"==="+m.end());
            System.out.println("---------------");
            if(m.matches()) System.out.println("matches() :"+m.start()+"====="+m.end());
            System.out.println("---------------");
            if(m.lookingAt()) System.out.println("lookingAt() :"+m.start()+"==="+m.end());
        }
        
        System.out.println("/////////////////////////////////////////////////////////////");
        /**
         * Pattern.compile(String reg,int flag);   //flag为标记参数
         * 在这里只介绍三种常用的标记参数
         * Pattern.CASE_INSENSITIVE   忽略大小写
         * Pattern.COMMENTS           忽略空格符和用“#”开始到行末的注释内容
         * Pattern.MULTILINE          多行表示，表达式^ 和 $ 匹配每一行的字符   
         */
        System.out.println("----------------Pattern标记-----------------------------");
        
        Pattern pa = Pattern.compile("^Java", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE) ;   // 通过 “|”的标识符，组合标记的功能
        Matcher ma = pa.matcher("Java is a laguage
java regex
JAVA is good,I like java.");
        while (ma.find()) {
            System.out.println(ma.group());
        }
    }
}