Java 正则简单用法

Posted 2020-10-08

正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它 用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

众所周知，在程序开发中，难免会遇到需要匹配、查找、替换、判断字符串的情况发生，而这些情况有时又比较复杂，如果用纯编码方式解决，往往会浪费程序员的时间及精力。因此，学习及使用正则表达式，便成了解决这一矛盾的主要手段。

下面是正则表达式的解释：

• // 反斜杠
• /t 间隔 (‘/u0009‘)
• /n 换行 (‘/u000A‘)
• /r 回车 (‘/u000D‘)
• /d 数字 等价于[0-9]
• /D 非数字 等价于[^0-9]
• /s 空白符号 [/t/n/x0B/f/r]
• /S 非空白符号 [^/t/n/x0B/f/r]
• /w 单独字符 [a-zA-Z_0-9]
• /W 非单独字符 [^a-zA-Z_0-9]
• /f 换页符
• /e Escape
• /b 一个单词的边界
• /B 一个非单词的边界
• /G 前一个匹配的结束
• ^为限制开头

1. ^java     条件限制为以Java为开头字符
2. $为限制结尾
3. java$     条件限制为以java为结尾字符
4. .  条件限制除/n以外任意一个单独字符
5. java..     条件限制为java后除换行外任意两个字符

• 加入特定限制条件「[]」

1. [a-z]     条件限制在小写a to z范围中一个字符
2. [A-Z]     条件限制在大写A to Z范围中一个字符
3. [a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
4. [0-9]     条件限制在小写0 to 9范围中一个字符
5. [0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
6. [0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)

• []中加入^后加再次限制条件「[^]」

1. [^a-z]     条件限制在非小写a to z范围中一个字符
2. [^A-Z]     条件限制在非大写A to Z范围中一个字符
3. [^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
4. [^0-9]     条件限制在非小写0 to 9范围中一个字符
5. [^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
6. [^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)

 

下面几个简单的Java正则用例：

 1 public class RegexTest {
 2     public static void main(String[] args) {
 3         String a = "aaaaa";
 4         String b = "11111";
 5         String c = "abc123";
 6         if (a.matches("\\\\D+")) {
 7             System.out.println("This is first true");
 8         }
 9         if (a.matches("[a-z]+")) {
10             System.out.println("This is second true");
11         }
12         if (a.matches("[A-Z]+")) {
13             System.out.println("This is third true");
14         }
15         if (b.matches("\\\\d+")) {
16             System.out.println("This is fourth true");
17         }
18         if (b.matches("[0-9]+")) {
19             System.out.println("This is fifth true");
20         }
21         if (c.matches("[a-zA-Z0-9]+")) {
22             System.out.println("This is sixth true");
23         }
24         if (c.matches("\\\\D+\\\\d+")) {
25             System.out.println("This is seventh true");
26         }
27     }
28 }

 

Pattern.compile函数，可以加入控制正则表达式的匹配行为的参数：
Pattern Pattern.compile(String regex, int flag)

flag的取值范围如下：

Pattern.CANON_EQ     当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a/u030A"会匹配"?"。默认情况下，不考虑"规 范相等性(canonical equivalence)"。

Pattern.CASE_INSENSITIVE(?i)     默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹 配，只要将UNICODE_CASE与这个标志合起来就行了。
Pattern.COMMENTS(?x)     在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"//s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
Pattern.DOTALL(?s)     在这种模式下，表达式‘.‘可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式‘.‘不匹配行的结束符。

Pattern.MULTILINE

(?m)     在这种模式下，‘^‘和‘$‘分别匹配一行的开始和结束。此外，‘^‘仍然匹配字符串的开始，‘$‘也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。

Pattern.UNICODE_CASE
(?u)     在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。

Pattern.UNIX_LINES(?d)     在这个模式下，只有‘/n‘才被认作一行的中止，并且与‘.‘，‘^‘，以及‘$‘进行匹配。

 1 import java.io.File;
 2 import java.io.FileFilter;
 3 import java.io.PrintStream;
 4 import java.util.ArrayList;
 5 import java.util.Iterator;
 6 import java.util.regex.Matcher;
 7 import java.util.regex.Pattern;
 8 
 9 public class FilesAnalyze {
10     //用于缓存文件列表
11     @SuppressWarnings("rawtypes")
12     private ArrayList files = new ArrayList();
13     //用于承载文件路径
14     private String _path;
15     //用于承载未合并的正则公式
16     private String _regexp;
17     class MyFileFilter implements FileFilter {
18        /**
19         * 匹配文件名称
20         */
21        public boolean accept(File file) {
22         try {
23          Pattern pattern = Pattern.compile(_regexp);
24          Matcher match = pattern.matcher(file.getName());        
25          return match.matches();
26         } catch (Exception e) {
27          return true;
28         }
29        }
30       }
31     /**
32      * 解析输入流
33      * @param inputs
34      */
35     FilesAnalyze(String path,String regexp){
36       getFileName(path,regexp);
37     }
38     /**
39      * 分析文件名并加入files
40      * @param input
41      */
42     @SuppressWarnings("unchecked")
43     private void getFileName(String path,String regexp) {
44       //目录
45        _path=path;
46        _regexp=regexp;
47        File directory = new File(_path);
48        File[] filesFile = directory.listFiles(new MyFileFilter());
49        if (filesFile == null) return;
50        for (int j = 0; j < filesFile.length; j++) {
51         files.add(filesFile[j]);
52        }
53        return;
54       }
55     /**
56      * 显示输出信息
57      * @param out
58      */
59     @SuppressWarnings("rawtypes")
60     public void print (PrintStream out) {
61       Iterator elements = files.iterator();
62       while (elements.hasNext()) {
63         File file=(File) elements.next();
64           out.println(file.getPath());  
65       }
66     }
67     public static void output(String path,String regexp) {
68       FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp);
69       fileGroup1.print(System.out);
70     }
71     public static void main (String[] args) {
72       output("D://","[A-z|.]*");
73     }
74 }

 http://www.cnblogs.com/shuqi/p/4427693.html这个博主的常用正则表达式比较全，可以深入学习下