【转】java 正则表达式

上一篇 / 下一篇  2017-07-11 16:13:59 / 个人分类:Java

  1. package pack.java.regexp;  
  2.   
  3. import java.util.regex.Matcher;  
  4. import java.util.regex.Pattern;  
  5.   
  6. /** 
  7.  * 正则表达式实例1 
  8.  * @author Administrator 
  9.  * 
  10.  */  
  11. public class RegexpDemo01 {  
  12.       
  13.     public static void main(String[] args) {  
  14.         //正则常用表达式介绍;  
  15.         //符号:.代表任意字符;  
  16.         //符号:*代表0个或者多个  
  17.         //符号:+代表1个或者多个  
  18.         //符号:?代表0个或者1个  
  19.         //符号:/d代表数字0-9  
  20.         //符号:/D代表非数字0-9的字符;  
  21.         //符号:/w代表字符a-z或者字符A-Z或者下划线_或者数字0-9,如[a-zA-Z_0-9]  
  22.         //符号:/W代表非[a-zA-Z_0-9]的字符;  
  23.         //符号:/s代表空白字符如:\n、\t、\r 或者 空白等;  
  24.         //符号:/S代表非空白字符的字符;  
  25.         //符号:\代表转义\如果需要写正则表达式匹配\必须写\\匹配.  
  26.         //符号:^如果位于中括号里面是取反,如果^位于中括号外面代表字符输入的开头;  
  27.         //符号:$代表字符结束的末尾;  
  28.         //符号:/b代表单词边界,如i am或者i\tam 等;  
  29.           
  30.         //表达式中的.代表匹配任意字符,返回结果true;  
  31.         p("@1A中".matches("...."));  
  32.         //每次匹配一个长度,并且是数字0-9,或者使用\d也行;  
  33.         p("abcd123abc".replaceAll("[0-9]{1}","-"));  
  34.         //当字符串只有3个长度时才匹配成功;  
  35.         Pattern compile = Pattern.compile("\\w{3}");  
  36.         p(compile.matcher("aA1").matches());  
  37.         //正则表达式*代表0个或者多个,返回结果true;  
  38.         p("aA1bc".matches("\\w*"));  
  39.         //正则表达式+号代表1个或者多个,返回结果true;  
  40.         p("AVB123a".matches("\\w+"));  
  41.         //正则表达式?号代表0个或者1个,返回结果true;  
  42.         p("".matches("\\w?"));  
  43.         //正则表达式{3}代表字符串需要连续出现多少次,返回结果true;  
  44.         p("aaa".matches("a{3}"));  
  45.         //正则表达式{3,}代表至少出现3次最多未知,结果返回true;  
  46.         p("123456".matches("\\d{3,}"));  
  47.         //正则表达式区间{3,100}匹配,代表至少3次不超过100次,结果返回true;  
  48.         p("张AB/3&*".matches(".{3,100}"));  
  49.         //正则表达式[0-9]代表一个范围匹配,结果返回true;  
  50.         p("192".matches("[0-2][0-9][0-9]"));  
  51.           
  52.         //范围匹配规则如下:  
  53.         //正则表达式[abc]代表只需要匹配此[]中的任意一个字符(只匹配单个字符).返回true;  
  54.         p("a".matches("[abc]"));  
  55.         //正则表达式取反[^abc]代表除了表达式的字符都可以匹配,返回true  
  56.         p("d".matches("[^abc]"));  
  57.         //正则表达式-代表一个范围,[a-zA-Z]代表范围,a到z和A-Z;返回true;  
  58.         p("abc".matches("[a-zA-Z]{3}"));  
  59.         //正则表达式|代表或者,如:[a-z]|[A-Z] 表示小写字符a-z或者大写字母A-Z;  
  60.         p("abez".matches("([a-z]|[A-Z]){4,}"));  
  61.         //正则表达式并集&&表示并且的意思,例如:[A-Z&&[ABC]],代表需要匹配A-Z中的一个字母并且和[ABC]中的一个匹配,只有2个表达式都成立时才返回true;  
  62.         p("A".matches("[A-Z&&[ABC]]"));  
  63.           
  64.         //匹配空白字符以及制表符、回车符、换行等,使用\s即可,返回true;  
  65.         p(" \n\r\t".matches("\\s+"));  
  66.         //匹配下划线字母数字,使用\w即可,返回true;  
  67.         p("a_z_2333aABD".matches("\\w{1,}"));  
  68.         //匹配数字、字母、以及多个符号&^%#等;  
  69.         p("abc3ABC$^&".matches("\\w{1,7}[%$&^]+"));  
  70.         //匹配\\需要转义\\\\进行匹配,返回true  
  71.         p("\\".matches("\\\\"));  
  72.           
  73.         //边界匹配规则如下:  
  74.         //正则表达式需要从字符起始位置开始找起需要^并且匹配中间任意字符.和以llo字符结尾的字符,返回true;  
  75.         p("hello zhangsan".matches("^h.*san$"));  
  76.         //匹配以abc结尾的字符,返回true  
  77.         p("hello zhangabc".matches(".*abc$"));  
  78.         //匹配空行;  
  79.         p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));  
  80.           
  81.         //单词边界规则如下;  
  82.         //匹配单词,可以使用\b代表有单词边界的地方开始匹配或者是\t代表空格.  
  83.         p("Yes sir.".matches("[a-z]*\\b.{1,}"));  
  84.         p("Yes\tsir.".matches("[a-z]*\\b.{1,}"));  
  85.           
  86.         //matches find lookingat区别  
  87.         //正则表达式中的matcher表示匹配整个字符串;  
  88.         Pattern comp1 = Pattern.compile("\\d{3,5}");  
  89.         Matcher matcher = comp1.matcher("111-430-13331-234-13");  
  90.         p(matcher.matches());  
  91.         //重置表示重新从最初的位置开始找起;  
  92.         matcher.reset();  
  93.         //find表示每次匹配一次就移除匹配的部分,保留子字符串,然后返回匹配项返回true;  
  94.         p(matcher.find());  
  95.         p(matcher.start() + " - "+matcher.end());  
  96.         p(matcher.find());  
  97.         p(matcher.start() + " - "+matcher.end());  
  98.         p(matcher.find());  
  99.         p(matcher.start() + " - "+matcher.end());  
  100.         p(matcher.find());  
  101.         matcher.reset();  
  102.         //lookingAt表示每次从最开始的位置开始找;  
  103.         p(matcher.lookingAt());  
  104.           
  105.         //较复杂的查找和替换操作;  
  106.         Pattern comp2 = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//忽略大小写;  
  107.         Matcher matcher2 = comp2.matcher("Java.Net JAVA JavA Java java JAVADemoJaVaDD I Love You JAva test abcd 123.");  
  108.         int i =0;  
  109.         StringBuffer sb = new StringBuffer();  
  110.         while(matcher2.find()){  
  111.             i++;  
  112.             //如果是偶数java转成大写,否则转成小写;  
  113.             if(i%2==0){  
  114.                 matcher2.appendReplacement(sb, "JAVA");  
  115.             }else{  
  116.                 matcher2.appendReplacement(sb, "java");  
  117.             }  
  118.         }  
  119.         //重新追加没有匹配的字符串;  
  120.         matcher2.appendTail(sb);  
  121.         p(sb);  
  122.           
  123.         //分组匹配输出;如果正则表达式中的"()"代表一组表达式,如果有多组就使用多个()括起来,使用group(1)表示取第一组表达式的值;  
  124.         Pattern comp3 = Pattern.compile("(\\d{3,5})([a-z]{1,3})", Pattern.CASE_INSENSITIVE);  
  125.         Matcher matcher3 = comp3.matcher("123a-234abc-33452SBD-32BS-311XYZ");  
  126.         while(matcher3.find()){  
  127.             p(matcher3.group(1));//表示按(\\d{3,5})第一组的正则表达式进行匹配.  
  128.         }  
  129.     }  
  130.       
  131.     /** 
  132.      * 输出正则表达式匹配后的结果; 
  133.      * @param obj 
  134.      */  
  135.     public static void p(Object obj){  
  136.         System.out.println(obj);  
  137.     }  
  138. }  

TAG:

 

评分:0

我来说两句

Open Toolbar