1 /*
2          * 告知此字符串是否匹配给定的正则表达式(也是一个字符串)。
3          */
4         System.out.println("abc".matches("..."));//每个"."表示一个字符

1 /*
2          * 把字符串里的所有数字替换成"-"，普通方法需要charAt逐个判断;
3          * "\\d"表示任意一个数字或者换成"[0-9]";
4          * "\\D"表示任意一个非数字或者换成"[^0-9]"
5          */
6         System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//每个"."表示一个字符

 1 /*
 2          * compile将给定的正则表达式编译到模式中(每次编译需要费时间);{3}表示恰好三次。
 3          *     X{n} X，恰好 n 次 
 4          *    X{n,} X，至少 n 次 
 5          *    X{n,m} X，至少 n 次，但是不超过 m 次 
 6          */
 7         Pattern p = Pattern.compile("[a-z]{3}");
 8         Matcher m = p.matcher("ggs");//创建匹配给定输入与此模式的匹配器。内部实际上是创建了一个优先状态的自动机(编译原理)
 9         //matcher和matches里待匹配的字符串实际上是CharSequence（接口）,不过String实现了该接口，存在多态
10         System.out.println(m.matches());//若是"ggss"就不匹配了
11         //可一直接"ggs".matches("[a-z]{3}"),不过上面的有好处，至少效率高了，而且Pattern和Matcher提供了很多功能

 1 "a".matches(".");//true,"."表示任意一个字符,汉字也行
 2         "aa".matches("aa");//true,也就是说普通字符串也可以作为正则表达式
 3         /*
 4          * true,"*"表示0或者多个字符,不过后面的要和第一个相同，
 5          * 否则false，也就是判断字符串是否是单一字符组成的字符串
 6          */
 7         "aaaa".matches("a*");
 8         "".matches("a*");//true
 9         "aaa".matches("a?");//true，一次或者0次
10         "".matches("a?");//true
11         "a".matches("a?");//true
12         "544848154564113".matches("\\d{3,100}");//true
13         //这个是最简单的IP判断，不过若是超过255则判断不出来
14         "192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\d{1,3}");
15         "192".matches("[0-2][0-9][0-9]");

1 //发现|和||没区别，&和&&有区别，不知道这么理解对不对
2         System.out.println("C".matches("[A-Z&&[ABS]]"));//false
3         System.out.println("C".matches("[A-Z&[ABS]]"));//true
4         System.out.println("A".matches("[A-Z&&[ABS]]"));//true
5         System.out.println("A".matches("[A-Z&[ABS]]"));//true
6         System.out.println("C".matches("[A-Z|[ABS]]"));//true
7         System.out.println("C".matches("[A-Z||[ABS]]"));//true

 1 " \n\t\r".matches("\\s{4}");//true
 2         " ".matches("\\S");//false
 3         "a_8".matches("\\w{3}");//true
 4         //“+”表示一次或者多次
 5         "abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+");//true
 6         /*
 7          * 待匹配字符也只是一个反斜线,不过不可写成"\"那么和后面的"组合了，
 8          * 前面的"无法匹配就会CE。
 9          * 后面不可写成"\\",那么会运行错误（编译没问题），必须写成"\\\\"
10          */
11         System.out.println("\\".matches("\\\\"));//true

1 "hello world".matches("^h.*");//^行的开头 
2         "hello world".matches(".*ld$");//$行的结尾 
3         "hello world".matches("^h[a-z]{1,3}o\\b.*");//\b单词边界 
4         "helloworld".matches("^h[a-z]{1,3}o\\b.*");

1 " \n".matches("^[\\s&&[^\\n]]*\\n$");//判断空白行，空白行开头是空白符 

 1 Pattern p = Pattern.compile("\\d{3,5}");
 2         String s = "133-34444-333-00";
 3         Matcher m = p.matcher(s);
 4         m.matches();//matches匹配全部字符串
 5         m.reset();
 6         /*
 7          * 下面若是先调用了reset方法则输出true，true，true，false.
 8          * 否则倒数第二个find也输出false。
 9          * 原因如下：
10          * matches匹配到第一个"-"发现不匹配了，但是这四个字符已经被吃掉啦，再次匹配就从
11          * 34444开始了,第二个find从333，因为find匹配的是下一个子序列。
12          * reset方法让matches吃掉的字符串再吐出来。
13          * 综上：matches和find之间要使用reset，因为二者相互影响
14          * 
15          */
16         m.find();
17         m.find();
18         m.find();//尝试查找与该模式匹配的输入序列的下一个子序列
19         m.find();
20         /*
21          * 尝试将从区域开头开始的输入序列与该模式匹配。
22          * Thinking in java的作者狠狠滴批评了这个方法，因为从字面看不出来到底从哪开始匹配。
23          * 下面全部是true，因为每次都从头开始
24          */
25         m.lookingAt();
26         m.lookingAt();
27         m.lookingAt();
28         m.lookingAt();

 1 import java.util.regex.Matcher;
 2 import java.util.regex.Pattern;
 3 
 4 public class TestRegexReplacement {
 5     
 6     public static void main(String[] args) {
 7         
 8         Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//后面的参数是整形,表示“大小写不敏感”
 9         Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
10         while(m.find()) {
11             System.out.println(m.group());//m.group会输出所有的java（忽略大小写）
12             
13         }
14         
15         
16         String s = m.replaceAll("Java");//String也有该方法
17         System.out.println(s);
18         
19         m.reset();//一定要加，因为find和matcher相互影响
20         StringBuffer sb = new StringBuffer();
21         int i = 0;
22         /*
23          * 下面的方法是把找到的奇数个java替换为“Java”，偶数个替换成"java"
24          */
25         while(m.find()) {
26             i++;
27             //不能直接写成i&1必须转化为boolean
28             if((i&1)==1) {
29                 m.appendReplacement(sb, "Java");
30             }else {
31                 m.appendReplacement(sb, "java");
32             }
33         }
34         
35         m.appendTail(sb);//把找到的最后一个java后边的剩余字符串加上
36         System.out.println(sb);//不加reset的话只输出了Acmer
37     }
38 }

 1 /*
 2          * 分别加上小括号，不算最外边的大括号，第一个左括号便是第一组
 3          */
 4         Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
 5         String s = "123aaa-77878bb-646dd-00";
 6         Matcher m = p.matcher(s);
 7         while(m.find()) {
 8             System.out.println(m.group());
 9             System.out.println(m.group(1));//输出每对符合的 数字
10             System.out.println(m.group(2));//输出每对符合的 字母
11         }

 1 import java.io.BufferedReader;
 2 import java.io.FileNotFoundException;
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 import java.util.regex.Matcher;
 6 import java.util.regex.Pattern;
 7 
 8 /*
 9  * 需要什么养的方法的话先些方法名
10  * 然后ctrl + 1列出推荐，系统创建该方法
11  */
12 public class EmailSpider {
13 
14     public static void main(String[] args) {
15         // TODO Auto-generated method stub
16         try {
17             BufferedReader br = new BufferedReader(new FileReader("F:\\regex.html"));
18             String line = "";
19             try {
20                 while((line=br.readLine())!=null) {
21                     solve(line);
22                 }
23             } catch (IOException e) {
24                 // TODO Auto-generated catch block
25                 e.printStackTrace();
26             }
27             
28         } catch (FileNotFoundException e) {
29             // TODO Auto-generated catch block
30             e.printStackTrace();
31         }
32         
33 
34     }
35 
36     private static void solve(String line) {
37         // TODO Auto-generated method stub
38         //正则表达式要是不满足相应功能的话不会出错，因为他是字符串
39         Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
40         Matcher m = p.matcher(line);
41         
42         while(m.find()) {
43             System.out.println(m.group());
44         }
45         
46     }
47 
48 }

 1 //加上分组是为了看得更清晰一些
 2     Pattern p = Pattern.compile("(.{3,10})+[0-9]");
 3     String s = "aaaa5bbbb6";//长度是10
 4     Matcher m = p.matcher(s);
 5     /*
 6      * 现在输出0-10，默认是Greedy，先吞进10个字符，发现不匹配，吐出来一个，发现匹配了；
 7      * 若是Pattern.compile("(.{3,10}?)+[0-9]")则成了Reluctant，那么是先吞进三个字符,发现不匹配，继续吞入 知道匹配，输出0到5；
 8      * 若是Pattern.compile("(.{3,10}++)+[0-9]")则是Possessive（独占式），也是先吞入10个字符，但是不向外吐，那么就不匹配了，
 9      * 这种方式主要用在需要高效率的地方（会有误差）。
10      */
11     if(m.find()) {
12         System.out.println(m.start() + "----" + m.end());
13     }else {
14         System.put.println("Not match!");
15     }

 1 //非捕获组的意思和字面相反，意思是若是符合则捕获
 2     Pattern p = Pattern.compile("(?=a).{3}");
 3     /*
 4      * 输出a66，相当于要求以a开头,也可以这么写Pattern.compile("[a].{2}");
 5      * 若是Pattern.compile(".{3}(?!=a)")不是不以a结尾{2}[^a]，而是下一个字符不是a(lookahead)，输出44a,66b,所以这种用法不常用；
 6      * 若是Pattern.compile(".{3}(?=a)")则输出444(因为?=a是lookahead),放在前面则包含在组内，后面则不包含在组内；
 7      * 
 8      * 
 9      */
10     String s = "444a66b";
11     Matcher m = p.matcher(s);
12     while(m.find()) {
13         System.out.println(m.group());
14     }

1 Pattern p = Pattern.compile("(\\d\\d)\\1");
2     /*
3      * 输出true，\\1表示和第一个组的一样，若改成1213就不对了;
4      * 若是Pattern.compile("(\\d(\\d))\\2")则需改成122才对
5      * 
6      */
7     String s = "1212";
8     Matcher m = p.matcher(s);
9     System.out.println(m.matches());