Java 基础学习之正则表达式

水深无声 2024-04-18 13:43 26阅读 0赞

正则表达式（Regular Expression）是在 JDK1.4 中引入的功能。正则表达式可以方便地对数据进行匹配，可以执行更加复杂的字符串拆分、验证、替换等操作。例如，现在要求判断一个字符串是否由数字组成，则可以有以下两种做法。

## 实例 1 ：判断一个字符串是否由数字组成 ##

#### 方案一：判断一个字符串是否由数字组成 ####

package self.learn.regularexpression;
    
    public class RegexDemo01 { 
    
    	public static void main(String[] args) { 
    		String str = "123456789";           // 此字符串由数字组成
    		boolean flag  = true;
    		char c[] = str.toCharArray();       // 将字符串变为字符数组
    		for(int i = 0; i < c.length; i++) {  // 依次判断
    			if(c[i] < '0'||c[i] > '9') {     // 判断每一个字符是否是 0-9
    				flag = false;               // 如果不是则退出循环
    				break;
    			}		
    		}
          if(flag) {                             // 判断输出
        	  System.out.println("是由数字组成！");
          }else { 
    		 System.out.println("不是由数字组成！");
    	}
    	}
    }

#### 方案二：判断一个字符串是否由数字组成（使用正则表达式验证） ####

package self.learn.regularexpression;
    import java.util.regex.Pattern;
    
    public class RegexDemo01 { 
    
    	public static void main(String[] args) { 
    		String str = "123456789";           // 此字符串由数字组成
    		if(Pattern.compile("[0-9]+").matcher(str).matches()) { 
    			System.out.println("是由数字组成！");
    		}else { 
    			System.out.println("不是由数字组成！");
    		}
    	}
    }

上面的代码完成了和第一个范例同样的功能，但是代码的长度要比第一个程序短的多。实际上，上面的程序就是使用正则表达式进行验证的，而中间的 “\[0-9\]+” 就是正则表达式的匹配字符，表示的含义是：由 1 个以上的数字组成的。实际上，具体的正则表达式操作类是需要通过 Pattern 和 Matcher 两个类完成的。

# 1 Pattern 类和 Matcher 类 #

如果想要在程序中使用正则表达式 ，则必须依靠 Pattern 类和 Matcher 类，这两个类都在 java.util.regex。 Pattern 类主要是规范正则表达式的编写（如上面代码中的 \[0-9\] 的编写），而 Matcher 类主要是执行规范，验证一个字符串是否符合其规范。

### 1.1 常用的正则规范的定义如表： ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>规范</th> 
   <th>描述</th> 
   <th>序号</th> 
   <th>规范</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>\\</td> 
   <td>表示反斜线</td> 
   <td>9</td> 
   <td>\w</td> 
   <td>表示字母、数字、下划线</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>\t</td> 
   <td>表示制表符</td> 
   <td>10</td> 
   <td>\W</td> 
   <td>表示非字母、数字、下划线</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>\n</td> 
   <td>换行</td> 
   <td>11</td> 
   <td>\s</td> 
   <td>表示所有空白符（换行、空格等）</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>[abc]</td> 
   <td>字符 a、b 或 c</td> 
   <td>12</td> 
   <td>\S</td> 
   <td>表示所有非空白符</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>[^abc]</td> 
   <td>除了字符 a、b 、c 之外的任意字符</td> 
   <td>13</td> 
   <td>^</td> 
   <td>行的开头</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>[a-zA-Z0-9]</td> 
   <td>表示由字符数字组成</td> 
   <td>14</td> 
   <td>$</td> 
   <td>行的结尾</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>\d</td> 
   <td>表示数字</td> 
   <td>15</td> 
   <td>.</td> 
   <td>匹配除换行符之外的任意字符</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>\D</td> 
   <td>表示非数字</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### 数量表示（X 表示一组规范） ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>规范</th> 
   <th>描述</th> 
   <th>序号</th> 
   <th>规范</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>X</td> 
   <td>必须出现一次</td> 
   <td>5</td> 
   <td>X{n}</td> 
   <td>必须出现 n 次</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>X?</td> 
   <td>可以出现 0 次或 1 次</td> 
   <td>6</td> 
   <td>X{n, }</td> 
   <td>必须出现 n 次以上</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>X*</td> 
   <td>可以出现 0 次、 1 次或多次</td> 
   <td>7</td> 
   <td>X{n, m}</td> 
   <td>必须出现 n~m 次</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>X+</td> 
   <td>可以出现 1 次或多次</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### 逻辑运算符（X、Y 表示一组规范） ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>规范</th> 
   <th>描述</th> 
   <th>序号</th> 
   <th>规范</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>XY 规范后跟着Y</td> 
   <td>X规范后跟着Y 规范</td> 
   <td>3</td> 
   <td>(X)</td> 
   <td>作为一个捕获数组规范</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>X|Y</td> 
   <td>X规范或Y 规范</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### Pattern 类常用方法如表 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public static Pattern compile(String regex)</code></td> 
   <td>普通</td> 
   <td>指定正则表达规则</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public Matcher matcher(CharSequence input)</code></td> 
   <td>普通</td> 
   <td>返回 Mattcher 类实例</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public String[] split(CharSequence input)</code></td> 
   <td>普通</td> 
   <td>字符串拆分</td> 
  </tr> 
 </tbody> 
</table>

在 Pattern 类中，如果要想取得 Pattern 类实例，则必须调用 compile()方法  
如果要验证一个字符串是否符合规范，则可以使用 Matcher 类。

### Matcher 类常用方法如表 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public boolean matches()</code></td> 
   <td>普通</td> 
   <td>执行验证</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public String replaceAll(String replacement)</code></td> 
   <td>普通</td> 
   <td>字符串替换</td> 
  </tr> 
 </tbody> 
</table>

## 实例 2 ：验证一个字符串是否是合法的日期格式 ##

（1）日期格式要求：yyyy-mm-dd  
（2）正则表达式如下：  
  日期：1983   -   07   -   27  
  格式：四位数字  两位数字  两位数字  
  正则：\\d\{4\}   -   \\d\{2\}    -   \\d\{2\}

#### 代码： ####

package self.learn.regularexpression;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegexDemo01 { 
    
    	public static void main(String[] args) { 
    		String str = "1983-07-27";              // 此字符串由数字组成
    		String pat = "\\d{4}-\\d{2}-\\d{2}";    // 定义验证规则
    		Pattern p = Pattern.compile(pat);       // 实例化 Pattern 类
    		Matcher m = p.matcher(str);             // 验证字符串内容是否合法
    		if(m.matches()) { 
    			System.out.println("日期格式合法！");
    		}else { 
    			System.out.println("日期格式不合法！");
    		}
    	}
    }

#### 运行结果截图: ####

![在这里插入图片描述][20190907164258278.png]  
在上面的程序中，“\\” 字符是需要进行转义的，两个 “\\” 实际上表示的是一个 “\\” ，所以“\\d” 表示的是 “\\d”。

## 实例 3：按照字符串的数字将字符串拆分（使用 Pattern 类对字符串进行拆分） ##

#### 代码： ####

package self.learn.regularexpression;
    
    import java.util.regex.Pattern;
    
    public class RegexDemo01 { 
    
    	public static void main(String[] args) { 
    		String str = "A11B3332C456E7789234F";              // 此字符串由数字组成
    		String pat = "\\d+";                         // 定义验证规则
    		Pattern p = Pattern.compile(pat);       // 实例化 Pattern 类
    		String s[] = p.split(str);              // 进行字符串拆分
    		for(int i = 0; i < s.length; i++) { 
    			System.out.print(s[i]+" ");
    		}
    	}
    }

#### 运行结果截图: ####

![在这里插入图片描述][20190907165213841.png]

## 实例 4：将全部数字替换成 “\_” （Matcher 类中的替换操作） ##

#### 代码： ####

package self.learn.regularexpression;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegexDemo01 { 
    
    	public static void main(String[] args) { 
    		String str = "A11B3332C456E7789234F";              // 此字符串由数字组成
    		String pat = "\\d+";                         // 定义验证规则
    		Pattern p = Pattern.compile(pat);       // 实例化 Pattern 类
    		Matcher m = p.matcher(str);             // 实例化 Matcher 类
    		String string = m.replaceAll("_");      // 替换数字
    		System.out.println(string);
    	}
    }

#### 运行结果截图: ####

![在这里插入图片描述][20190907165954821.png]

# 2 String 类对正则表达式的支持 #

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public boolean matches(String regex)</code></td> 
   <td>普通</td> 
   <td>字符串匹配</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public String replaceAll(String regex,String replacement)</code></td> 
   <td>普通</td> 
   <td>字符串替换</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public String[] split(String regex)</code></td> 
   <td>普通</td> 
   <td>字符串拆分</td> 
  </tr> 
 </tbody> 
</table>

## 实例 5：使用 String 类修改之前的操作 ##

package self.learn.regularexpression;
    
    public class RegexDemo01 { 
    
    	public static void main(String[] args) { 
    		String str = "A11B3332C456E7789234F".replaceAll("\\d+", "_");     // 字符串替换 
    		boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}");      // 字符串匹配
    		String s[] = "A11B3332C456E7789234F".split("\\d+");               // 字符串拆分
    		System.out.println("字符串替换操作: "+str);
    		System.out.println("字符串验证操作: "+temp);
    		System.out.print("字符串拆分：");
    		for(int i = 0; i < s.length; i++) { 
    			System.out.print(s[i]+" ");
    		}
    	}
    }

#### 运行结果截图: ####

![在这里插入图片描述][20190907171300362.png]  
可以发现，上面的程序运行结果和之前的是一样的，所以建议读者以后最好直接使用 String 类中的方法，这样会比较方便。

[20190907164258278.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/337b027c7dda49f8915633cb0a41dac5.png
[20190907165213841.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e31be80ccfa04398a4793f9766843191.png
[20190907165954821.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/47b4b322690b435d9dbe11e520d71207.png
[20190907171300362.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d32a742319614888a161455b222785ca.png