正则表达式基础

<span style="font-size:18px;">package cn.itcast.test;

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

public class Demo1 {
  
  public static void main(String[] args) {
    /*
    //简单认识正则表达式
    System.out.println("abc".matches("..."));
    //.匹配字母
    */
    /*p("abc".matches("..."));
    
    //\d代表0-9的任何一个数组
    //replaceAll把所有的数字替换成-
    //在java中一个反斜杠(\)代表转义,
    //"\\"-->输出为\  规定\d才代表0-9的任何一个数组
    //一定要注意\d在java中是\\d
    p("a45678a".replaceAll("\\d","-"));
    
    
    //public static Pattern compile(String regex)
    //将给定的正则表达式编译到模式中。
    //把regex这个正则表达式编译下,放到Pattern这个模式中,编译好了,当你再拿这个字符串匹配的时候,速度回快一些
    Pattern pattern = Pattern.compile("[a-z]{3}");
    //[a-z]{3}-->代表三个字母,都是a-z范围
    Matcher matcher = pattern.matcher("dfg");
    //pattern这个模式匹配dfg这个字符串   
    //matcher  匹配方法   
    //Matcher  匹配器
    p(matcher.matches()); //匹配是否成功
    
    //27--33行的代码执行的速度快  36行慢些  没有编译
    p("dfg".matches("[a-z]{3}"));*/
    
    /*
    初步认识 . *  + ?
      . 一个字符
      * 匹配0次或多个字符,a*  就是匹配一个或多个a,匹配串必须都是a
      + 匹配一个或多个字符
      ?匹配0个或一个
      {}-->表示范围
      []表示某一个字符的范围
    */
    
    /*p("aaaa".matches("a.")); // false
    p("aaaa".matches("a*")); // true
    p("aaaa".matches("a+")); //true
    p("aaaa".matches("a?")); // false
     */   
    p("a".matches("."));
    p("aa".matches("aa"));
    p("aaaa".matches("a*"));
    p("aaaa".matches("a+"));
    p("".matches("a*"));
    p("aaaa".matches("a?"));
    p("".matches("a?"));
    p("2321432456789765432".matches("\\d{3,100}"));//数字的长度在3到100之间
    p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
    p("192".matches("[0-2][0-9][0-9]"));
    
    /*
     * 范围
     * []只匹配一个字符
     * ^ 代表非或除了什么以外的意思
     * -  范围
     * |  或
     * && 并
     * */
    p("a".matches("[abc]"));//取出中括号abc其中的一个与a进行匹配
    p("a".matches("[^abc]"));//除了a,b,c以外的字符与a进行匹配
    p("a".matches("[a-zA-Z]"));//所有的大小写字母与a进行匹配
    p("a".matches("[a-z]|[A-Z]"));//a-z或A-Z与a进行匹配
    p("a".matches("[A-Z]&&[RFG]"));
    
    /*
     *    认识\s \w \d \    
     * 
     *  .  任何字符（与行结束符可能匹配也可能不匹配） 
      \d 数字：[0-9] 
      \D 非数字： [^0-9] 
      \s 空白字符：[ \t\n\x0B\f\r] 
      \S 非空白字符：[^\s] 
      \w 单词字符：[a-zA-Z_0-9] 
      \W 非单词字符：[^\w] 
     */
    p(" \n\r\t".matches("\\s{4}"));
    p(" ".matches("\\S"));
    p("a_8".matches("\\w{3}"));
    p("abd888&^%".matches("[a-z]{1,3}\\d+[&^%#]+"));
    p("\\".matches("\\\\"));//匹配一个反斜杠
    
    //POSIX Style   unix的统一  用的不是太多
    p("a".matches("\\p{Lower}"));//英文的小写字母
    // 注意\\p{Upper}或\\p{Lower}只能判断一个字符，而不是字符串  
    
    //边界匹配(boundary)
    /*
       ^(开头) 在[]内代表非  在模式串的开头代表第一个字母是什么 
       $ 末尾
     */
    p("hello sir".matches("^h.*"));//开头必须是h后面匹配多个0次或多个字符
    p("adasdasd".matches("a.*")); //a后面匹配多个0次或多个字符
    p("adasdasd".matches(".*")); //这是任意的0个或多个字符
    p("adasdasd".matches("a*"));//a后面是0个或多个a  flase
    p("hello sir".matches(".*ir$"));
    p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
    p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
    
    //空白行
    p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));
    //第一个是空格,一个或多个,末尾是\n
    
    //练习
    p("aaa 8888c".matches(".*\\d{4}.")); //true
    p("aaa 8888c".matches(".*\\b\\d{4}."));//true
    p("aaa 8888c".matches(".*\\d{4}."));//true
    p("aaa8888c".matches(".*\\b\\d{4}."));//false
    
    //邮箱的匹配
    p("[email protected]".matches("[a-zA-Z|[0-9]]+@[a-zA-Z|[0-9]]+.[a-zA-Z]{1,6}"));
    p("[email protected]".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));
    
    //metches find lookingAt
    
    /*
     *    Matcher类的方法:
      metches  永远匹配整个字符串
      find   找子串
      lookingAt 每次从头上找子串
      
      注意:
        在metches与find一起用的时间,
        metches在匹配的时候,如果匹配不成功,会把光标停在不匹配的哪里,你在调用find,
        会接着上一次的光标进行匹配,如果你想从头开始,需要用reset方法重置一下
     */
    System.out.println("---------------------");
    Pattern pat = Pattern.compile("\\d{3,5}");
    String s = "123-34354-123-00";
    Matcher m = pat.matcher(s);
    p(m.matches());//模式串与s全部进行匹配
    m.reset();//注意此方法,重置匹配器
    p(m.find());//模式串在s找一个子串进行匹配
    p(m.start()+"-"+m.end());
    p(m.find());
    p(m.start()+"-"+m.end());
    p(m.find());
    p(m.start()+"-"+m.end());
    p(m.find());
    //p(m.start()+"-"+m.end());根据模式串进行匹配的时候,只有找到子串才可以使用start与end方法
    System.out.println("---------------------");
    p(m.lookingAt());
    p(m.lookingAt());
    p(m.lookingAt());

    
    //1.字符串的替换(replacement)
    Pattern p = Pattern.compile("java");//这方法区分大小写
    Matcher ma= p.matcher("java Java JAVA JaVa IloveJAVA you hateJava");
    while(ma.find()){
      p(ma.group());//输出匹配到的子串  分组
    }
    
    //2字符串的替换(replacement)              ?
    Pattern p1 = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//这方法区分大小写  Pattern.CASE_INSENSITIVE   启用不区分大小写的匹配。
    Matcher ma1= p1.matcher("java dsfs  Java JAVA JaVa IloveJAVA you hateJava dsfds");
            //匹配的时候把dsfs  Java看成一个串
    StringBuffer buf = new StringBuffer();
    int i=0;
    while(ma1.find()){
      i++;
      if(i%2==0){
        ma1.appendReplacement(buf, "java");
      }else{
        ma1.appendReplacement(buf, "JAVA");
      }
    }
    ma1.appendTail(buf);
    p(buf);
    
    //1.分组  group
    Pattern p2 = Pattern.compile("\\d{3,5}[a-z]{2}");
    String  s1 = "132aa-1235bb-132zz-00";
    Matcher m1 = p2.matcher(s1);
    while(m1.find()){//查找子串
      p(m1.group());
    }
    System.out.println("----------------------------------------");
    //2.分组  group
    //\\d{3,5}[a-z]{2}-->这组正则表达式,用小括号,把他们分开,分成两组,再加上子串本身,共三组,
    //group默认数组子串的全部  
    // -->(\\d{3,5})([a-z]{2})-->分组,在多个()时候,只数左小括号,按照1,2,3,4,5...进行编号,在grounp中,直接grounp(n)   n代表你想调用的子串
    Pattern p5 = Pattern.compile("(\\d{3,5})([a-z]{2})");
    String  s5 = "132aa-1235bb-132zz-00";
    Matcher m5 = p5.matcher(s5);
    while(m5.find()){//查找子串
      p(m5.group(2));
    }
    
    
    
    
    
  }
  
  public static void p(Object o){
    System.out.println(o);
  }
}
</span>