java 正则

flags简写

1. package com.itlwc;
2. public class Test {
3. public static void main(String[] args) throws Exception {
4. String str = "abc:0000:defg";
5. System.out.println(str.replace("0000","8765"));
6. // 替换所有匹配正则表达式的
7. System.out.println(str.replaceAll("\\d", "0"));
8. // 只替换第一个匹配正则表达式的
9. System.out.println(str.replaceFirst("\\d", "1"));
10. // str是否匹配给定正则表达式
11. System.out.println(str.matches(".{13}"));
12. //拆分
13. for(String s : str.split(":")){
14. System.out.print(s+"\t");
15. }
16. System.out.println();
17. //拆分几段
18. for(String s : str.split(":",2)){
19. System.out.print(s+"\t");
20. }
21. }
22. }
23. /*
24. 打印结果:
25. abc:8765:defg
26. abc:0000:defg
27. abc:1000:defg
28. true
29. abc 0000    defg
30. abc 0000:defg
31. */

1. java.util.regex.Pattern
2. 其对象表示通过编译的正则式,利用该类对象可以与任意字符串进行模式匹配
3. 构造器
4. Pattern类的构造器是private
5. 声明
6. public final class Pattern extends Object implements Serializable
7. 创建Pattern的静态工厂
8. public static Pattern compile(String regex)
9. 将指定正则式编译成Pattern对象返回
10. public static Pattern compile(String regex,int flags)
11. 将指定正则式按照指定标志编译成Pattern对象返回

1. package com.itlwc;
2. import java.util.regex.Matcher;
3. import java.util.regex.Pattern;
4. public class Test {
5. public static void main(String[] args) throws Exception {
6. // 编译好的模式用起来更快一些
7. // 将给定的正则表达式编译到模式中
8. Pattern p = Pattern.compile("[a-z]{3}");
9. // 将给定的正则表达式编译到具有给定标志的模式中
10. p = Pattern.compile("[a-z]{3}", Pattern.CASE_INSENSITIVE);
11. // 返回此模式的匹配标志
12. System.out.println(p.flags());
13. // 匹配某个字符串之后的结果,这个有可能有很多个
14. // 该方法返回表示将要被匹配字符序列的匹配器对象
15. Matcher m = p.matcher("fgh");
16. System.out.println(m.matches());
17. // 编译给定正则表达式并尝试将给定输入与其匹配
18. System.out.println(Pattern.matches("[a-z]{3}", "fgh"));
19. // 返回在其中编译过此模式的正则表达式
20. System.out.println(p.pattern());
21. // 该方法返回指定字符串的模式文本表示
22. System.out.println(Pattern.quote("abc"));
23. // 匹配拆分
24. String[] str1 = Pattern.compile(",").split("boo,and,foo");
25. for (String s : str1) {
26. System.out.print(s + "\t");
27. }
28. System.out.println();
29. // 匹配拆分,拆分几段
30. String[] str2 = Pattern.compile(":").split("boo:and:foo", 2);
31. for (String s : str2) {
32. System.out.print(s + "\t");
33. }
34. }
35. }
36. /*
37. 打印结果:
38. 2
39. true
40. true
41. [a-z]{3}
42. \Qabc\E
43. boo and foo
44. boo and:foo
45. */

1. java.util.regex.Matcher 匹配器
2. 声明
3. public final class Matcher extends Object implements MatchResult

1. package com.itlwc;
2. import java.util.regex.Matcher;
3. import java.util.regex.Pattern;
4. public class Test {
5. public static void main(String[] args) throws Exception {
6. Matcher m1 = Pattern.compile("\\d{3,5}").matcher("123-45682-152-00");
7. // 返回由此匹配器解释的模式
8. System.out.println(m1.pattern());
9. // 只有整个字符序列完全匹配成功才返回true
10. System.out.println(m1.matches());
11. // 把原来吃点的吐出来恢复到从前的状态
12. m1.reset();
13. // 找一个和模式匹配的子串,找到之后正则表达式引擎会把第一个子串去掉
14. System.out.println(m1.find());
15. // 起始位置和结束位置,但必须能找到,否则报错
16. System.out.println(m1.start() + "-" + m1.end());
17. // 每次都从开始位置找
18. System.out.println(m1.lookingAt());
19. System.out.println("------------------------------");
20. CharSequence cs = "java JAVA javaEE hiJAVA abcdefg";
21. int i = Pattern.CASE_INSENSITIVE;
22. Matcher m2 = Pattern.compile("java", i).matcher(cs);
23. while (m2.find()) {
24. // 分组,输出匹配到的子串
25. System.out.print(m2.group() + "\t");
26. }
27. System.out.println();
28. System.out.println("------------------------------");
29. // 把java全部替换成JAVA
30. System.out.println(m2.replaceAll("JAVA"));
31. System.out.println("------------------------------");
32. // 把单数java转换为小写,双数java转换为大写
33. m2.reset();
34. StringBuffer sb = new StringBuffer();
35. int count = 0;// 奇数偶数的常量
36. while (m2.find()) {
37. count++;
38. if (count % 2 == 0) {
39. // 替换
40. m2.appendReplacement(sb, "JAVA");
41. } else {
42. m2.appendReplacement(sb, "java");
43. }
44. }
45. // 添加尾巴,否则abcdefg不显示
46. m2.appendTail(sb);
47. System.out.println(sb);
48. System.out.println("------------------------------");
49. // 取符合正则表达式
50. Pattern p = Pattern.compile("\\d{3,5}[a-z]{2}");
51. Matcher m3 = p.matcher("123aa-33345bb-234cc-00");
52. while (m3.find()) {
53. System.out.print(m3.group() + "\t");
54. }
55. System.out.println();
56. // 使用分组取数字,有几个(就分了几组
57. // 怎么知道是第几组,规律是(是第几个就是第几组
58. p = Pattern.compile("(\\d{3,5})([a-z]{2})");
59. m3 = p.matcher("123aa-33345bb-234cc-00");
60. while (m3.find()) {
61. // 只要第一组数字
62. System.out.print(m3.group(1) + "\t");
63. }
64. m3.reset();
65. System.out.println();
66. while (m3.find()) {
67. // 只要第一组字母
68. System.out.print(m3.group(2) + "\t");
69. }
70. }
71. }
72. /*
73. 打印结果:
74. \d{3,5}
75. false
76. true
77. 0-3
78. true
79. ------------------------------
80. java    JAVA    java    JAVA
81. ------------------------------
82. JAVA JAVA JAVAEE hiJAVA abcdefg
83. ------------------------------
84. java JAVA javaEE hiJAVA abcdefg
85. ------------------------------
86. 123aa   33345bb 234cc
87. 123 33345   234
88. aa  bb  cc
89. */

1. package com.itlwc;
2. import java.io.BufferedReader;
3. import java.io.FileReader;
4. import java.util.regex.Matcher;
5. import java.util.regex.Pattern;
6. public class Test {
7. public static void main(String[] args) throws Exception {
8. FileReader fr = new FileReader("D:\\email.html");
9. BufferedReader br = new BufferedReader(fr);
10. String line = "";
11. while ((line = br.readLine()) != null) {
12. parse(line);
13. }
14. }
15. private static void parse(String line) {
16. Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
17. Matcher m = p.matcher(line);
18. while (m.find()) {
19. System.out.println(m.group());
20. }
21. }
22. }