正则表达式学习

1. package com.zhc.love;
2. import java.util.regex.Matcher;
3. import java.util.regex.Pattern;
6. public class TestRegexp {
8.     /**
9.      * @param zhc
10.      * 和正则表达式有关系的类只有三个.java.lang.String. 
11.      * java.util.regex.pattern 
12.      * java.util.regex.Matcher
13.      */
14.     public static void main(String[] args) {
15.         // 正则表达式本身也是一个字符串
16.         //java.lang.String 的方法 boolean matches(String regex)  
17.         //一个点代表一个字母,是否匹配三个字母
18.         System.out.println("aaa".matches("..."));
19.         //替换一个字符串中的数字 /d 代表数字
20.         p("ad87654aa".replaceAll("//d", "-"));
21.         //匹配三个从a-z的字母,先产生一个规则.储存在p对象中
22.         Pattern p = Pattern.compile("[a-z]{3}");
23.         //调用p对象的匹配方法,去跟字符处匹配,结果保留在m对象中
24.         Matcher m = p.matcher("aaaaa");
25.         //打印m,看字符串是不是匹配,返回boolean类型
26.         p(m.matches());
27.         //初步认识Regex
28.         //.表示一个字符  ;* 通配符,表示任意个字符 ;+ 表示出现一次或多次;?一次或者一次也没有
29.         //[]代表一个范围 [0-9]表示0-9的范围
30.         //{}表示出现的次数 {3} 出现3次
31.         p("a".matches("."));
32.         p("aa".matches("aa"));
33.         p("aaaa".matches("a*"));//a可以出现任意次
34.         p("aaaa".matches("a+"));
35.         p("".matches("a*"));
36.         p("aaaa".matches("a?"));
37.         p("".matches("a?"));
38.         p("a".matches("a?"));
39.         p("214523145234532".matches("//d{3,100}"));
40.         p("192.168.0.aaa".matches("//d{1,3}//.//d{1,3}//.//d{1,3}//.//d{1,3}"));
41.         p("192".matches("[0-2][0-9][0-9]"));
42.         //正则表达式中范围的描述
43.         p("----------------------------------------");
44.         p("a".matches("[abc]"));//要匹配abc中的一个
45.         p("a".matches("[^abc]"));//取除了abc的任意字符
46.         p("A".matches("[a-zA-Z]"));//取大写或小写的字符
47.         p("A".matches("[a-z]|[A-Z]"));//a-z
48.         p("A".matches("[a-z[A-Z]]"));
49.         p("R".matches("[A-Z&&[RFG]]"));//取交集[A-Z和[RFG]]取交集做匹配准则
50.         //认识/s 表示空白字符 ;/w 单词字符：[a-zA-Z_0-9] /d  ;数字：[0-9] ;/ 反斜线字符
51.         p("----------------------------------------");
52.         p(" /n/r/t".matches("//s{4}"));
53.         p(" ".matches("//S"));
54.         p("a_8".matches("//w{3}"));
55.         p("abc888&^%".matches("[a-z]{1,3}//d+[&^#%]+"));
56.         p("//".matches(""));
57.         //POSIX Style 用POSIX风格来指定规则,POSIX是unix的一种标准
58.         p("----------------------------------------");
59.         p("a".matches("//p{Lower}"));//相当于[a-z]
60.         //边界匹配boundary [^] 意思是取反.^意思是一行的开头
61.         p("----------------------------------------");
62.         p("hello sir".matches("^h.*"));
63.         p("hello sir".matches(".*ir$"));
64.         p("hello sir".matches("^h[a-z]{1,3}o//b.*"));
65.         p("hellosir".matches("^h[a-z]{1,3}o//b.*"));
66.         //空白行的检测
67.         p("----------------------------------------");
68.         p(" /n".matches("^[//s&&[^//n]]*//n$"));
69.         //匹配emali地址的正则表达式
70.         p("----------------------------------------");
71.         p("aaa-aaa@aaa.com".matches("[//w.-]+@[//w*]+[.][//w*]+"));
72.         //matches find lookingAt  matches匹配整个字符串 相当与c语言中的strtok方法
73.         //每次匹配完一次后,指针停留在匹配的最后一个字符串的位置上,必须reset下
74.         p("----------------------------------------");
75.         Pattern p1 = Pattern.compile("//d{3,5}");
76.         String s1 = "123-34345-234-00";
77.         Matcher m1 = p1.matcher(s1);
78.         p(m1.matches());
79.         p(m1.find());//找一个和整个模式相匹配的子串
80.         p(m1.find());//找一个和整个模式相匹配的子串
81.         p(m1.find());//最后匹配-00 ,已经不符合匹配规则
82.         p("----------------------------------------");
83.         Pattern p2 = Pattern.compile("//d{3,5}");
84.         String s2 = "123-34345-234-00";
85.         Matcher m2 = p2.matcher(s2);
86.         p(m2.matches());
87.         m2.reset();//把原来指针指向开头的地方
88.         p(m2.find());//找一个和整个模式相匹配的子串
89.         p(m2.find());//找一个和整个模式相匹配的子串
90.         p(m2.find());//找一个和整个模式相匹配的子串
91.         p(m2.find());//最后匹配-00 ,已经不符合匹配规则
92.         p("-----------------------------------------");
93.         Pattern p3 = Pattern.compile("//d{3,5}");
94.         String s3 = "123-34345-234-00";
95.         Matcher m3 = p1.matcher(s3);
96.         p(m3.lookingAt());//从开头开始匹配.匹配了则显示true
97.         p(m3.lookingAt());
98.         p(m3.lookingAt());
99.         p(m3.lookingAt());
100.         //Matcher的start()方法end()方法找到匹配字符串的指针的位置
101.         p("-----------------------------------------");
102.         Pattern p4 = Pattern.compile("//d{3,5}");
103.         String s4 = "123-34345-234-00";
104.         Matcher m4 = p4.matcher(s4);
105.         p(m4.matches());
106.         m4.reset();//把原来指针指向开头的地方
107.         p(m4.find());//找一个和整个模式相匹配的子串 0-3 第0个位置到指针的下一个开始的位置3
108.         p(m4.start() + "-" + m4.end());
109.         p(m4.find());//找一个和整个模式相匹配的子串
110.         p(m4.start() + "-" + m4.end());
111.         p(m4.find());//找一个和整个模式相匹配的子串
112.         p(m4.start() + "-" + m4.end());
113.         p(m4.find());//最后匹配-00 ,已经不符合匹配规则 如果找不到start会报错
114.         
115.         //字符串的替换replacement
116.         p("-----------------------------------------");
117.         //从指定的字符串找到规则中的字符串.打印出来 group() 找到跟规定字符串的字符串.把他放在一个"数组"里 
118.         //Pattern p5 = Pattern.compile("java");
119.         Pattern p5 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);//可以加一些修饰.这是忽略大小写
120.         Matcher m5 = p5.matcher("java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");
121.         //Matcher m5 = p5.matcher("java java java java java ");
122.         while(m5.find()){
123.             p(m5.group());
124.         }
125.         p("-----------------------------------------");
126.         Pattern p6 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);//可以加一些修饰.这是忽略大小写
127.         Matcher m6 = p6.matcher("java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");
128.         while(m6.find()){
129.             p(m6.replaceAll("DUANJING"));
130.         }//把找到的字符串都替换成指定的字符串
131.         p("-----------------------------------------");
132.         //当偶数换成java 当奇数换成JAVA ,public Matcher appendReplacement(StringBuffer sb,String replacement)
133.         //将替换后的字符串保存在buf中,但是指针只指到替换的最后一个位置.得用appendTail(StringBuffer sb) 
134.         //将字符串末尾添加到buf中
135.         Pattern p7 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);//可以加一些修饰.这是忽略大小写
136.         Matcher m7 = p7.matcher("aaaa java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");
137.         int i=0;
138.         StringBuffer buf = new StringBuffer();
139.         while(m7.find()){
140.             i++;
141.             if(i%2 == 0) {
142.                 m7.appendReplacement(buf, "java");
143.             } else {
144.                 m7.appendReplacement(buf, "JAVA");
145.             }
146.         }
147.         //m.appendTail(buf);
148.         p(buf);
149.         //正则表达式的分组 ()表示分组 ()的数量代表组的数量 每个组有自己的组号
150.         //m.group() 整个组 m.group()第一组 (是第几个就是第几组
151.         p("-----------------------------------------");
152.         Pattern p8 = Pattern.compile("(//d{3,5})([a-z]{2})");
153.         String s8 = "123aa-34345bb-234cc-00";
154.         Matcher m8 = p8.matcher(s8);
155.         while(m8.find()) {
156.             p(m8.group(2));//打印第二个分组 都字母的
157.             }
158.     }
159.     //重写System.out.println(o);方法
160.     public static void p(Object o){
161.         System.out.println(o);
162.     }
164. }

1. package com.zhc.love;
3. import java.io.BufferedReader;
4. import java.io.FileNotFoundException;
5. import java.io.FileReader;
6. import java.io.IOException;
7. import java.util.regex.Matcher;
8. import java.util.regex.Pattern;
10. public class EmailSpider {
12.     /**
13.      * @by zhc
14.      * 从网页中抓取email地址
15.      */
16.     public static void main(String[] args) {
17.         //先把网页读取进来,用BufferReader 封装
18.         String line;
19.         BufferedReader br = null;
20.         try {
21.             br = new BufferedReader(new FileReader("D://workspace//RegExp//aaa.txt"));
22.             while((line=br.readLine())!=null){
23.                 parse(line);
24.             }
25.         } catch (FileNotFoundException e) {
26.             System.out.println("文件没有找到!");
27.         } catch (IOException e) {
28.             System.out.println("读取文件错误!");
29.         }finally{
30.             if(br != null){
31.                 try {
32.                     br.close();
33.                 } catch (IOException e) {
34.                     e.printStackTrace();
35.                 }
36.             }
37.         }
39.     }
40.     //分析页面的email地址
41.     private static void parse(String line) {
42.         //首先定义一个正则表达式
43.         Pattern p = Pattern.compile("[//w.-]+@[//w*]+[.][//w*]+");
44.         //用规则去匹配读取的一行
45.         Matcher m  = p.matcher(line);
46.         //当有结果的时候把结果打印出来
47.         while(m.find()){
48.             System.out.println(m.group());
49.         }
50.         
51.         
52.     }
54. }