正则表达式

package org.learning.javaLearning;

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

public class Regex {
    /**
     * 关于正则表达式
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        System.out.println("Greedy方式：**********");
        p("a".matches("."));//.任意字符
        p("aa".matches("aa"));
        p("aaa".matches("a*"));//a* a零次或多次
        p("".matches("a*"));
        p("a".matches("a?"));//a? a零次或一次
        p("".matches("a?"));
        p("aaaaa".matches("a+"));//a+ a一次或多次
        p("a".matches("a+"));
        p("aa".matches("a{2}"));//a{n} a恰好n次
        p("aaa".matches("a{2,}"));//a{n,} a至少n次
        p("aaaa".matches("a{2,4}"));//a{n,m} a至少n次至多m次
        // 进行转义 d代表数字   . 代表 .
        p("192.168.0.127".matches("d{1,3}.d{1,3}"));
        p("192".matches("[0-2][0-9][0-9]"));//有三个数字，第一个0-2，第二个0-9，第三个0-9之间的数字
        
        System.out.println("关于范围：**********");
        p("b".matches("[abc]"));// [abc] a或b或c
        p("b".matches("[^abc]"));// [^abc] 非a，b，c
        p("b".matches("[a-zA-Z]"));// [a-zA-Z] a-z或A-Z
        p("b".matches("[a-z[m-o]]"));// [a-z[m-o]] a-z或m-o [a-zm-o]
        p("b".matches("[a-z&&[def]]"));// [a-z&&[def]] a-z之间且是d或e或f 交集
        p("b".matches("[a-z&&[^def]]"));// [a-z&&[^def]] a-z之间且除了def
        p("b".matches("[a-z&&[^b-d]]"));// [a-z&&[^b-d]] a-z之间且除了[b-d]之间的
    
        System.out.println("关于空白字符，数字，单词字符：**********");
        p("123ccc".matches("d{1,3}[a-z]{1,3}"));// d 数字
        p("4567cccc".matches("D{1,4}[a-z]{1,4}"));// D 非数字
        p("tnfr".matches("s{1,5}"));// s空白字符：t空格 n换行符 x0B f换页符 r回车
        p("t".matches("S"));// S非空白字符
        p("string".matches("w{1,6}"));// w单词字符 [a-zA-Z_0-9]
        p("int".matches("W(3)"));// W非单词字符
        
        System.out.println("关于边界匹配：**********");
        // ^ $ b B A输入的开始 z Z输入的结尾 G上一个匹配的结尾
        p("Hello regix!".matches("^H.*"));// ^匹配行的开头
        p("Hello regix!".matches(".*regix!$"));// $ 匹配的行结尾
        p("Hello regix!".matches("^H[a-z]{1,4}b.*!$"));// b 单词边界，指前边的Hello为一个单词
        p("HelloHash!".matches("^H[a-z]{1,4}B.*!$"));// B 非单词边界
        
        //邮箱验证[w[.-]][email?protected][w[.-]]+.[w]+
        //+ 代表前面的字符至少出现一次(一次或多次)
        //*代表字符可出现也可不出现(零次或一次或多次)
        //?代表前面的字符最多出现一次(零次或一次)
        System.out.println("邮箱验证：**********");
        p("[email?protected]".matches("[w[.-]][email?protected][w[.-]]+.[w]+"));
        
        //表达式：网络协议地址：^(http|https|ftp)://[a-zA-Z0-9-.]+.[a-zA-Z]{2,3}(:[a-zA-Z0-9]*)?/?([a-zA-Z0-9-._?,‘/+&%$#=~])*$
        System.out.println("网址验证：***********");
        Pattern p1=Pattern.compile("^([Hh][Tt]{2}[Pp]://|^[Hh][Tt]{2}[Pp][Ss]://|^[Ff][Tt][Pp]://)(([A-Za-z0-9-~]+).)+([A-Za-z0-9-~/])+$");
        Matcher m1=p1.matcher("http://localhost:8080/haha.wl");
        Matcher m2=p1.matcher("https://imooc.com");
        p(m1.matches());
        p(m2.matches());
    
        System.out.println("Matcher类的matches()、lookAt()和find()的区别：");
        
        Pattern pp=Pattern.compile("d{3,5}");
        Matcher mm=pp.matcher("123-33456-111-00");
        
        p(mm.matches());//完全匹配时为true，只有整个字符序列完全匹配成功，才返回True，否则返回False。但如果前部分匹配成功，将移动下次匹配的位置。
        
        mm.find();//部分匹配时即为true，从当前位置开始匹配，找到一个匹配的子串，将移动下次匹配的位置。
        System.out.print("当前匹配位置：");
        p(mm.start());//前边matches()虽然匹配失败，但123与pattern匹配成功，匹配位置移动到位置4上
        
        mm.reset();//重置匹配位置
        p(mm.find());
        System.out.print("find第一次匹配的目标：");
        p(mm.group());
        System.out.print("find第一次匹配的位置：");
        p(mm.start());
        
        p(mm.find());
        System.out.print("find第二次匹配的目标：");
        p(mm.group());
        System.out.print("find第二次匹配的位置：");
        p(mm.start());
        
        p(mm.lookingAt());//部分匹配即为true，总是从第一个字符进行匹配,匹配成功了不再继续匹配，匹配失败了,也不继续匹配。
        System.out.print("lookingAt第一次匹配的目标：");
        p(mm.group());
        System.out.print("lookingAt第一次匹配的位置：");
        p(mm.start());
    }
    
    public static void p(Object o) {
        System.out.println(o);
    }

}