Go语言视频零基础入门到精通

javalearner

1. import java.util.regex.Matcher;  
   
2. import java.util.regex.Pattern;  
   
3.   
   
4. /**  
   
5.   * jdk1.4中加入了java.util.regex包提供对正则表达式的支持。  
   
6.   * 而且Java.lang.String类中的replaceAll和split函数也是调用的正则表达式来实现的。  
   
7.   */
   
8. public class RegexExpression {  
   
9.   
   
10.      /**  
    
11.       * 利用正则表达式查找匹配字符串  
    
12.       */
    
13.      public static void testFind() {  
    
14.          // ^符号匹配字符串的开头  
    
15.          // 匹配以abc开头的字符串  
    
16.          RegexExpression.find("abcdef", "^abc");  
    
17.          RegexExpression.find("Aabc def", "^abc");  
    
18.          System.out.println();  
    
19.   
    
20.          // $符号匹配字符串的结尾  
    
21.          // 匹配以def结尾的字符串  
    
22.          RegexExpression.find("Aabcdef", "def$");  
    
23.          RegexExpression.find("AabcdeF", "def$");  
    
24.          // 如果同时使用^符号和$符号，将进行精确匹配  
    
25.          RegexExpression.find("def", "^def$");  
    
26.          RegexExpression.find("abcdefg", "^def$");  
    
27.          System.out.println();  
    
28.   
    
29.          // *符号匹配0个或多个前面的字符  
    
30.          RegexExpression.find("a", "ab*");  
    
31.          RegexExpression.find("ab", "ab*");  
    
32.          RegexExpression.find("abbb", "ab*");  
    
33.          System.out.println();  
    
34.   
    
35.          // +符号匹配至少一个前面的字符  
    
36.          RegexExpression.find("a", "ab+");  
    
37.          RegexExpression.find("ab", "ab+");  
    
38.          RegexExpression.find("abbb", "ab+");  
    
39.          System.out.println();  
    
40.   
    
41.          // ?符号匹配0个或1个前面的字符  
    
42.          RegexExpression.find("a", "ab?c?");  
    
43.          RegexExpression.find("ab", "ab?c?");  
    
44.          RegexExpression.find("abc", "ab?c?");  
    
45.          RegexExpression.find("abbcb", "ab?c?");  
    
46.          System.out.println();  
    
47.   
    
48.          // .符号匹配除换行符以外的任何字符，  
    
49.          RegexExpression.find("a", ".");  
    
50.          // .与+连用能匹配除换行符以外的所有字符串  
    
51.          RegexExpression.find("dasf4566a`1345=-=4bsd", ".+");  
    
52.          System.out.println();  
    
53.   
    
54.          // x|y匹配"x"或"y"  
    
55.          // abc|xyz 可匹配 "abc"或 "xyz"，而"ab(c|x)yz"匹配 "abcyz"和"abxyz"  
    
56.          RegexExpression.find("x", "x|y");  
    
57.          RegexExpression.find("y", "x|y");  
    
58.          RegexExpression.find("abc", "abc|xyz");  
    
59.          RegexExpression.find("xyz", "abc|xyz");  
    
60.          RegexExpression.find("abc", "ab(c|x)yz");  
    
61.          RegexExpression.find("abcyz", "ab(c|x)yz");  
    
62.          System.out.println();  
    
63.   
    
64.          // {n}匹配恰好n次（n为非负整数）前面的字符  
    
65.          RegexExpression.find("aa", "a{3}");  
    
66.          RegexExpression.find("aaa", "a{3}");  
    
67.          System.out.println();  
    
68.   
    
69.          // {n,}匹配至少n次（n为非负整数）前面的字符  
    
70.          RegexExpression.find("aaa", "a{3,}");  
    
71.          RegexExpression.find("aaaaa", "a{3,}");  
    
72.          System.out.println();  
    
73.   
    
74.          // {m,n}匹配至少m个，至多n个前面的字符  
    
75.          RegexExpression.find("aaa", "a{3,4}");  
    
76.          RegexExpression.find("aaaa", "a{3,4}");  
    
77.          RegexExpression.find("aaaaa", "a{3,4}");  
    
78.          System.out.println();  
    
79.   
    
80.          // [xyz]表示一个字符集，匹配括号中字符的其中之一  
    
81.          RegexExpression.find("a", "[abc]");  
    
82.          RegexExpression.find("b", "[abc]");  
    
83.          RegexExpression.find("c", "[abc]");  
    
84.          RegexExpression.find("ab", "[abc]");  
    
85.          System.out.println();  
    
86.   
    
87.          // [^xyz]表示一个否定的字符集。匹配不在此括号中的任何字符  
    
88.          RegexExpression.find("a", "[^abc]");  
    
89.          RegexExpression.find("x", "[^abc]");  
    
90.          RegexExpression.find("8", "[^abc]");  
    
91.          System.out.println();  
    
92.   
    
93.          // [a-z]匹配从"a"到"z"之间的任何一个小写字母字符  
    
94.          RegexExpression.find("c", "[b-d]");  
    
95.          RegexExpression.find("f", "[b-d]");  
    
96.          RegexExpression.find("$", "[b-d]");  
    
97.          System.out.println();  
    
98.   
    
99.          // [^a-z]表示某个范围之外的字符，匹配不在指定范围内的字符  
    
100.          RegexExpression.find("f", "[b-d]");  
     
101.          RegexExpression.find("b", "[b-d]");  
     
102.          System.out.println();  
     
103.   
     
104.          // [a-zA-Z] a到z或A到Z  
     
105.          RegexExpression.find("B", "[a-cA-F]");  
     
106.          RegexExpression.find("G", "[a-cA-F]");  
     
107.          System.out.println();  
     
108.   
     
109.          // [a-z-[bc]] a到z，除了b和c  
     
110.          RegexExpression.find("c", "[a-z-[bcd]]");  
     
111.          RegexExpression.find("e", "[a-z-[bcd]]");  
     
112.          RegexExpression.find("f", "[a-z-[e-x]]");  
     
113.          System.out.println();  
     
114.   
     
115.          // 特殊字符，
116. 换行符；f分页符；
     回车；        制表符  
     
117.          RegexExpression.find("
118. ", "
119. ");  
     
120.          RegexExpression.find("f", "f");  
     
121.          RegexExpression.find("
     ", "
     ");  
     
122.          RegexExpression.find("        ", "        ");  
     
123.          System.out.println();  
     
124.   
     
125.          // \表示转义符，在使用时要用\\代表\，\代表。  
     
126.          RegexExpression.find("", "\");  
     
127.          System.out.println();  
     
128.   
     
129.          // s 任何白字符，包括空格、制表符、分页符等。等价于"[f
130. 
             ]"  
     
131.          // 使用s时前面再加一个  
     
132.          RegexExpression.find("
133. ", "\s");  
     
134.          RegexExpression.find("f", "\s");  
     
135.          RegexExpression.find("
     ", "\s");  
     
136.          RegexExpression.find("        ", "\s");  
     
137.          System.out.println();  
     
138.   
     
139.          // S 任何非空白的字符。等价于"[^f
140. 
             ]"  
     
141.          // 使用s时前面再加一个  
     
142.          RegexExpression.find("
143. ", "\S");  
     
144.          RegexExpression.find("f", "\S");  
     
145.          RegexExpression.find("a", "\S");  
     
146.          RegexExpression.find("9", "\S");  
     
147.          System.out.println();  
     
148.   
     
149.          // w 任何单词字符，包括字母和下划线。等价于"[A-Za-z0-9_]"  
     
150.          // 使用时用\w  
     
151.          RegexExpression.find("a", "\w");  
     
152.          RegexExpression.find("9", "\w");  
     
153.          RegexExpression.find("X", "\w");  
     
154.          RegexExpression.find("_", "\w");  
     
155.          System.out.println();  
     
156.   
     
157.          // W 任何非单词字符。等价于"[^A-Za-z0-9_]"  
     
158.          // 使用时用\W  
     
159.          RegexExpression.find("a", "\W");  
     
160.          RegexExpression.find("9", "\W");  
     
161.          RegexExpression.find("$", "\W");  
     
162.          RegexExpression.find("", "\W");  
     
163.          System.out.println();  
     
164.   
     
165.          // d匹配一个数字字符，等价于[0-9]  
     
166.          RegexExpression.find("6", "\d");  
     
167.          RegexExpression.find("9", "\d");  
     
168.          RegexExpression.find("A", "\d");  
     
169.          System.out.println();  
     
170.   
     
171.          // D匹配一个非数字字符，等价于[^0-9]  
     
172.          RegexExpression.find("%", "\D");  
     
173.          RegexExpression.find("$", "\D");  
     
174.          RegexExpression.find("A", "\D");  
     
175.          RegexExpression.find("8", "\D");  
     
176.          System.out.println();  
     
177.   
     
178.          // 匹配单词的结尾  
     
179.          RegexExpression.find("love", "ve\b");  
     
180.          RegexExpression.find("very", "ve\b");  
     
181.          System.out.println();  
     
182.   
     
183.          // B匹配单词的开头  
     
184.          RegexExpression.find("love", "ve\B");  
     
185.          RegexExpression.find("very", "ve\B");  
     
186.          System.out.println();  
     
187.      }  
     
188.      /**  
     
189.       * 利用正则表达式查找匹配字符串。  
     
190.       * @param str   待匹配的字符串  
     
191.       * @param regex 正则表达式  
     
192.       * @return  
     
193.       */
     
194.      public static boolean find(String str, String regex) {  
     
195.          // 将正则表达式编译成一个Pattern  
     
196.          Pattern p = Pattern.compile(regex);  
     
197.          // 创建一个Matcher  
     
198.          Matcher m = p.matcher(str);  
     
199.          // Matcher的find方法用来查找或者匹配，只要能找到满足正则表达式的子串，就返回true  
     
200.          boolean b = m.find();  
     
201.          System.out.println(""" + str + "" 匹配正则表达式 "" + regex + "" ?  " + b);  
     
202.          return b;  
     
203.      }  
     
204.      /**  
     
205.       * 测试利用正则表达式 精确匹配 字符串  
     
206.       */
     
207.      public static void testMatch() {  
     
208.          RegexExpression.match("abcdef", "^abc");  
     
209.          RegexExpression.match("Aabc def", "^abc");  
     
210.          RegexExpression.match("Aabcdef", "def$");  
     
211.          RegexExpression.match("AabcdeF", "def$");  
     
212.          RegexExpression.match("def", "^def$");  
     
213.      }  
     
214.      /**  
     
215.       * 精确匹配字符串和正则表达式，所谓精确匹配是字符串的每个字符都满足正则表达式  
     
216.       * @param str  
     
217.       * @param regex  
     
218.       * @return  
     
219.       */
     
220.      public static boolean match(String str, String regex) {  
     
221.          // 将正则表达式编译成一个Pattern  
     
222.          Pattern p = Pattern.compile(regex);  
     
223.          // 创建一个Matcher  
     
224.          Matcher m = p.matcher(str);  
     
225.          boolean b = m.matches();// 精确匹配  
     
226.          System.out.println(""" + str + "" 精确匹配正则表达式 "" + regex + "" ?  "
     
227.                  + b);  
     
228.          return b;  
     
229.      }  
     
230.      /**  
     
231.       * 测试利用正则表达式替换字符串  
     
232.       */
     
233.      public static void testReplace() {  
     
234.          // 将字符串中重复的空格替换为一个空格  
     
235.          RegexExpression.replace("a  a    a   a", " {2,}", " ");  
     
236.          RegexExpression.replace("abcad a", "a", "x");  
     
237.      }  
     
238.      /**  
     
239.       * 利用正则表达式替换字符串  
     
240.       * @param str    待替换的字符串  
     
241.       * @param regex  正则表达式  
     
242.       * @param newStr 用来替换的字符串  
     
243.       * @return  
     
244.       */
     
245.      public static String replace(String str, String regex, String newStr) {  
     
246.          Pattern p = Pattern.compile(regex);  
     
247.          Matcher m = p.matcher(str);  
     
248.          // 用新串替换所有满足正则表达式的子串  
     
249.          String s = m.replaceAll(newStr);  
     
250.          System.out.println(""" + str + "" 中匹配正则表达式 "" + regex + "" 部分被 ""
     
251.                  + newStr + "" 替换后: " + s);  
     
252.          return s;  
     
253.      }  
     
254.      /**  
     
255.       * 利用正则表达式分割字符串  
     
256.       */
     
257.      public static void testSplit() {  
     
258.          // 按空格分割字符串，空格符可以是连续的多个。  
     
259.          System.out.println("RegexExpression.split("ab  aba a    bbc bc", " +", 5): result");  
     
260.          RegexExpression.outputStrArray(RegexExpression.split(  
     
261.                  "ab  aba a    bbc bc", " +", 5));  
     
262.          // 按照字母b分割字符串  
     
263.          System.out  
     
264.                  .println("RegexExpression.split("ab  aba a    bbc bc", "b", 5): result");  
     
265.          RegexExpression.outputStrArray(RegexExpression.split(  
     
266.                  "ab  aba a    bbc bc", "b", 5));  
     
267.      }  
     
268.      /**  
     
269.       * 使用正则表达式分割字符串  
     
270.       * @param str   待分割的字符串  
     
271.       * @param regex 正则表达式  
     
272.       * @param count 最终被分成的段数的最大值  
     
273.       * @return  
     
274.       */
     
275.      public static String[] split(String str, String regex, int count) {  
     
276.          Pattern p = Pattern.compile(regex);  
     
277.          // 按照符合正则表达式的子串分割字符串  
     
278.          return p.split(str, count);  
     
279.      }  
     
280.      /**  
     
281.       * 输出字符串数组  
     
282.       * @param array  
     
283.       */
     
284.      public static void outputStrArray(String[] array) {  
     
285.          if (array != null) {  
     
286.              for (int i = 0; i < array.length; i++) {  
     
287.                  System.out.println(i + ": " + array[i]);  
     
288.              }  
     
289.          }  
     
290.      }  
     
291.      public static void main(String[] args) {  
     
292.          RegexExpression.testFind();  
     
293.          RegexExpression.testMatch();  
     
294.          System.out.println();  
     
295.          RegexExpression.testReplace();  
     
296.          System.out.println();  
     
297.          RegexExpression.testSplit();  
     
298.          System.out.println();  
     
299.          // 查找并替换， 替换换前2个满足正则表达式的子串  
     
300.          Pattern p = Pattern.compile("a+");  
     
301.          Matcher m = p.matcher("bba bb aaa bbabb bab");  
     
302.          StringBuffer sb = new StringBuffer();  
     
303.          int i = 0;  
     
304.          while ((m.find()) && (i < 2)) {  
     
305.              // 将字符串中的匹配的部分替换，  
     
306.              // 并且两次匹配之间（包括被匹配的部分）的字符串追加到sb后  
     
307.              m.appendReplacement(sb, "XX");  
     
308.              i++;  
     
309.          }  
     
310.          // 将字符串中没有进行匹配的部分全部追加到sb后面  
     
311.          m.appendTail(sb);  
     
312.          System.out.println(sb.toString());  
     
313.      }  
     
314.      /**  
     
315.       * 在程序中使用正则表达式的步骤一般如下： 1. 建立Pattern对象，通过静态方法Pattern.compile(); 2.  
     
316.       * 取得Matcher对象，通过pattern.matcher(CharSequence charSequence); 3.  
     
317.       * 调用Matcher对象的相关查找方法。  
     
318.       * java.lang.CharSequence接口是在JDK1.4版本中被添加进来的，它为不同种类的char序列  
     
319.       * 提供了统一的只读访问。实现的类有String, StringBuffer, java.nio.CharBuffer  
     
320.       * Matcher提供几个不同的查找方法，比String类的matches()方法更灵活，如下：  
     
321.       * match() 使用整个字符串与相关模式相比较，和String的matches()差不多  
     
322.       * lookingAt() 从字符串开头的地方与相关模式比较  
     
323.       * find() 匹配字符串，没有必要从字符串的第一个字符开始，如果前一个操作匹配， 而且匹配器没有重置的话，则从不匹配的第一个字符开始。  
     
324.       * 上面每个方法都返回boolean类型，返回true则意味的匹配，返回false则不匹配。  
     
325.       * 要检测给定的String是否匹配给定的模式，只须下面这样就可以了：  
     
326.       * Matcher m = Pattern.compile(yourPattern).matcher(yourString);  
     
327.       * if (m.find()) { System.out.println(“match”); } else {  
     
328.       * System.out.println(“no match”); }  
     
329.       */
     
330. }

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/10/28/235846046.zip