【JAVA基础】正则表达式

483阅读 正则表达式
483 次查看

正则表达式就是我们程序员为了在海量数据中搜索到符合我们规定的格式的数据所采用的一种规范，官方一点就是说正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。

下面我们介绍一下正则表达式的规则，而且会给出一个详尽的实例来让你完全理解正则表达式的应用。

1.正则表达式的构造摘要 

正则表达式的构造摘要
构造 匹配

字符
x 字符 x
\\ 反斜线字符
\0n 带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn 带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 带有十六进制值 0x 的字符 hh
\uhhhh 带有十六进制值 0x 的字符 hhhh
\t 制表符 (‘\u0009’)
\n 新行（换行）符 (‘\u000A’)
\r 回车符 (‘\u000D’)
\f 换页符 (‘\u000C’)
\a 报警 (bell) 符 (‘\u0007’)
\e 转义符 (‘\u001B’)
\cx 对应于 x 的控制符

字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

POSIX 字符类（仅 US-ASCII）
\p{Lower} 小写字母字符：[a-z]
\p{Upper} 大写字母字符：[A-Z]
\p{ASCII} 所有 ASCII：[\x00-\x7F]
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]
\p{Digit} 十进制数字：[0-9]
\p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct} 标点符号：!”#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} 可见字符：[\p{Alnum}\p{Punct}]
\p{Print} 可打印字符：[\p{Graph}\x20]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{XDigit} 十六进制数字：[0-9a-fA-F]
\p{Space} 空白字符：[ \t\n\x0B\f\r]

Java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase} 等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase} 等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace} 等效于 java.lang.Character.isWhitespace()
\p{javaMirrored} 等效于 java.lang.Character.isMirrored()

Unicode 块和类别的类
\p{InGreek} Greek 块（简单块）中的字符
\p{Lu} 大写字母（简单类别）
\p{Sc} 货币符号
\P{InGreek} 所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]]  所有字母，大写字母除外（减去）

边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾

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 次

Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组

Back 引用
\n 任何匹配的 nth 捕获组

引用
\ Nothing，但是引用以下字符
\Q Nothing，但是引用所有字符，直到 \E
\E Nothing，但是结束从 \Q 开始的引用

特殊构造（非捕获）
(?:X) X，作为非捕获组
(?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on – off
(?idmsux-idmsux:X)   X，作为带有给定标志 i d m s u x on – off
的非捕获组  (?=X) X，通过零宽度的正 lookahead
(?!X) X，通过零宽度的负 lookahead
(?<=X) X，通过零宽度的正 lookbehind
(?<!X) X，通过零宽度的负 lookbehind
(?>X) X，作为独立的非捕获组

2.正则表达式应用大实例

正则表达式:RegularExpressions（字符串处理利器）

都在java.util.regex.*;包中

样例：

[java] view plain copy

  1. package cn.edu.RegularExpressions;
  2. import java.util.regex.Matcher;
  3. import java.util.regex.Pattern;
  4. class Test {
  5.     public static void main(String[] args) {
  6.         //简单理解正则表达式
  7.         System.out.println(“abc”.matches(“…”));
  8.         //其中“\d”代表一个数字(0-9)
  9.         System.out.println(“a324234a”.replaceAll(“\\d”, “-“));
  10.         Pattern p=Pattern.compile(“[a-z]{3}”);
  11.         Matcher m=p.matcher(“fgh”);
  12.         System.out.println(m.matches());
  13.         System.out.println(“fgha”.matches(“[a-z]{3}”));
  14.         /*结果
  15.          * true
  16.            a——a
  17.            true
  18.            false
  19.          * */
  21.         //初步认识. * +
  22.         p(“1:”+“a”.matches(“.”));//
  23.         p(“2:”+“aa”.matches(“aa”));//true，正则表达式可以写正常的字符
  24.         p(“3:”+“aaaa”.matches(“a*”));//“*”代表的是0个或者多个
  25.         p(“4:”+“aaaa”.matches(“a+”));//“+”代表的是1个或者多个
  26.         p(“5:”+“”.matches(“a*”));
  27.         p(“6:”+“aaaa”.matches(“a?”));//“？”代表的是0个或1个
  28.         p(“7:”+“”.matches(“a?”));
  29.         p(“8:”+“a”.matches(“a?”));
  30.         p(“9:”+“2342342432423234”.matches(“\\d{3,100}”));//“{”与“}”代表出现的次数(几次，至少几次，最多几次最少几次)
  31.         //最简单的检测IP地址的方式：
  32.         p(“10:”+“192.168.0.aaa”.matches(“\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}”));
  33.         p(“11:”+“192”.matches(“[0-2][0-9][0-9]”));//“[]”代表一个范围
  34.         /*结果：
  35.         1:true
  36.         2:true
  37.         3:true
  38.         4:true
  39.         5:true
  40.         6:false
  41.         7:true
  42.         8:true
  43.         9:true
  44.         10:false
  45.         11:true*/
  47.         p(“a”.matches(“[abc]”));
  48.         p(“a”.matches(“[^abc]”));
  49.         p(“A”.matches(“[a-zA-Z]”));
  50.         p(“A”.matches(“[a-z] | [A-Z]”));
  51.         p(“A”.matches(“[a-z[A-Z]]”));
  52.         p(“R”.matches(“[A-Z&&[RFG]]”));
  53.         /*true
  54.         false
  55.         true
  56.         false
  57.         true
  58.         true*/
  61.         /*
  62.          * “.”代表任何字符
  63.          * “/d”[0-9]的数字
  64.          * “/D”非[0-9]的数字[^\d]
  65.          *”/s”空白字符（包括空格，Tab键\t，换行\n，backspace后退键/x0B，制表符/f，回车/r）
  66.          * “/S”非“空白字符”[^\s]
  67.          * “/w”单词字符[a-zA-Z_0-9]
  68.          * “/W””非“单词字符”[^\w]
  69.          */
  70.         p(” \n\r\t”.matches(“\\s{4}”));
  71.         p(” “.matches(“\\S”));
  72.         p(“a_8”.matches(“\\w{3}”));
  73.         p(“abc888&^%”.matches(“[a-z]{1,3}\\d+[&^#%]+”));
  74.         p(“\\”.matches(“\\\\“));//在matches中，一个”\“要用”\\”来表示
  75.     /*  true
  76.         false
  77.         true
  78.         true
  79.         true*/
  81.         //POSIX Style
  82.         p(“a”.matches(“\\p{Lower}”));
  83.         /*true*/
  85.         //边界匹配
  86.         //”^”位于中括号里面的时候是取反的意思，位于外面代表的是输入的开头
  87.         p(“hello sir”.matches(“^h.*”));//以”h”开头
  88.         p(“hello sir”.matches(“.*ir$”));//以”ir”结尾
  89.         p(“hello sir”.matches(“^h[a-z]{1,3}o\\b.*”));//\b一个单词的边界（空格，空白字符，换行，特殊字符）
  90.         p(“hellosir”.matches(“^h[a-z]{1,3}o\\b.*”));
  91.         /*true
  92.             true 
  93.             false*/
  95.         //把空白行找出来
  96.         p(” \n”.matches(“^[\\s&&[^\\n]]*\\n”));//以空白字符开头，并且不是换行符，出现0次或多次
  97.         /*true*/
  99.         //匹配email地址的正则表达式(有得email地址是含有横线和点号的)
  100.         p(“basdbjasbkja@dasbdn.com”.matches(“[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+”));
  102.         //matches find lookingAt
  103.         Pattern p1=Pattern.compile(“\\d{3,5}”);//编译正则表达式
  104.         String s=“123-34345-234-00”;
  105.         Matcher m1=p1.matcher(s);
  106.         p(m1.matches());
  107.         //false
  108.         //find()一段一段的匹配
  109.         //分析到“-”时，不符合p1的标准，认为结束
  110.         m1.reset();//matches与find一起使用时需要reset
  111.         p(m1.find());
  112.         p(m1.start()+“-“+m1.end());//输出“-”的起始位置和结束位置(结束位置就是本身位置)
  113.         p(m1.find());
  114.         p(m1.start()+“-“+m1.end());
  115.         p(m1.find());
  116.         p(m1.start()+“-“+m1.end());
  117.         p(m1.find());
  118. //      true
  119. //      true
  120. //      true
  121. //      false
  123.         p(m1.lookingAt());
  124.         //true
  126.         //区别matches找整个串 
  127.         //find找字串
  128.         //lookingAt每次都从头上开始找
  130.         //字符串的替换
  131.         Pattern p2=Pattern.compile(“java”,Pattern.CASE_INSENSITIVE);//CASE_INSENSITIVE忽略大小写
  132.         Matcher m2=p2.matcher(“java Java JAVa JaVa IloveJAVA you hateJava lalalala”);
  133.         while(m2.find()){
  134.             p(m2.group());//按组找
  135.         }
  136.         p(m2.replaceAll(“JAVA”));
  137.         //全部改为JAVA JAVA JAVA JAVA IloveJAVA you hateJAVA
  139.         m2.reset();
  140.         StringBuffer buf=new StringBuffer();
  141.         int i=0;
  142.         while(m2.find()){
  143.             i++;
  144.             if(i%2==0){//奇数大写偶数小写
  145.                 m2.appendReplacement(buf, “java”);
  146.             }else{
  147.                 m2.appendReplacement(buf, “JAVA”);
  148.             }
  149.         }
  150.         m2.appendTail(buf);//将尾巴加进去
  151.         p(buf);
  152.         //JAVA java JAVA java IloveJAVA you hatejava lalalala
  154.         //分组：使用小括号组成的，分了机组就有几对小括号
  155.         //每个组有自己的组号
  156.         Pattern p3=Pattern.compile(“(\\d{3,5})([a-z]{2})”);
  157.         String s1=“123aa-12323bb-456cc-00”;
  158.         Matcher m3=p3.matcher(s1);
  159.         while(m3.find()){
  160.             p(m3.group());//按组找
  161.             p(m3.group(1));
  162.             p(m3.group(2));
  163.         }
  164.         /*123aa
  165.         123
  166.         aa
  167.         12323bb
  168.         12323
  169.         bb
  170.         456cc
  171.         456
  172.         cc*/
  173.     }
  175.     public static void p(Object o){
  176.         System.out.println(o);
  177.     }
  178. }

3.实例：利用正则表达式写简单的邮件爬虫

把qiu_email.htm这个网页文件中的所有信息中属于邮箱地址的信息搜索出来

[java] view plain copy

  1. package cn.edu.RegularExpressions;
  4. import java.io.BufferedReader;
  5. import java.io.FileReader;
  6. import java.util.regex.Matcher;
  7. import java.util.regex.Pattern;
  10. public class EmailSpider {
  11.         public static void main(String[] args) {
  12.             try {
  13.      BufferedReader br=new BufferedReader(new FileReader(“F:\\Talk\\qiu_email.htm”));
  14.                 String line=“”;
  15.                 while((line=br.readLine())!=null){
  16.                     parse(line);
  17.                 }
  18.             } catch (Exception e) {
  19.                 e.printStackTrace();
  20.             }
  21.         }
  26.         private static void parse(String line) {
  27.                         //email的正则表达式
  28.             Pattern p=Pattern.compile(“[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+”);
  29.             Matcher m=p.matcher(line);
  30.             while(m.find()){
  31.                 System.out.println(m.group());
  32.             }
  34.         }
  35. }

转载请注明出处：http://blog.csdn.net/acmman/article/details/45078731

/************************************************************************/

实例：

// 以java开头,以>结束的字符串
Pattern p = Pattern.compile(“java.+?>”);

java架构师历程，欢迎扫描关注
分享到0