Java正则表达式简单介绍

忘是亡心i 2022-05-16 08:43 139阅读 0赞

正则表达式是计算机科学的一个概念，通常用于检索。替换符合某个规则的文本。使用正则表达式，我们能够以编程的方式，构造复杂的文本模式，并对输入的字符串进行搜索。一旦找到了匹配这些模式的部分，就能对其进行进一步的处理。

# 简单示例 #

public class Main {
        public static void main(String[] args) {
            //匹配带正号的数值
            System.out.println("+123".matches("\\+\\d+"));
            String str = "12321asdf1231dsfe532";
            //按英文字符分割
            for (String tmp : str.split("[a-zA-Z]+")) {
                System.out.println(tmp);
            }
        }
    }

输出

true
    12321
    1231
    532

# 基础 #

正则表达式其实就是以某种方式来描述字符串。与其他的语言有所不同，“\\”在其他语言的正则表达式中通常表示一个普通的反斜杠，而在Java中，其表示一个正则表达式的反斜杠，其后的字符就有特殊意义。举例来说，“\\\\”表示一个普通的反斜杠，“\\d”表示一位数字。其中换行和制表符之类的是特例，直接使用“\\n\\r”即可。

# 创建正则表达式 #

列举部分常用的构造集。

### 字符 ###

<table> 
 <thead> 
  <tr> 
   <th>正则表达式</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>B</td> 
   <td>表示字符B</td> 
  </tr> 
  <tr> 
   <td>\xhh</td> 
   <td>十六进制值为oxhh的字符</td> 
  </tr> 
  <tr> 
   <td>\uhhhh</td> 
   <td>十六进制表示为oxhhhh的Unicode字符</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>制表符</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行符</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
 </tbody> 
</table>

### 字符类 ###

<table> 
 <thead> 
  <tr> 
   <th>正则表达式</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[abc]</td> 
   <td>abc任意字符</td> 
  </tr> 
  <tr> 
   <td>[^abc]</td> 
   <td>abc之外的任意字符</td> 
  </tr> 
  <tr> 
   <td>[a-zA-Z]</td> 
   <td>a到z或A到Z范围内的字符</td> 
  </tr> 
  <tr> 
   <td>[abc[hij]]</td> 
   <td>abchij任意字符</td> 
  </tr> 
  <tr> 
   <td>[a-z&amp;&amp;[hij]]</td> 
   <td>hij任意字符（交集）</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>空白符（空格、tab、换行、换页和回车）</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>非空白符，同[^\s]</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>任意数字，同[0-9]</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>非数字，同[^0-9]</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>词字符[a-zA-Z0-9]</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>非词词汇，同[^\w]</td> 
  </tr> 
 </tbody> 
</table>

### 逻辑操作符 ###

<table> 
 <thead> 
  <tr> 
   <th>正则表达式</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>XY</td> 
   <td>Y跟在X后面</td> 
  </tr> 
  <tr> 
   <td>X|Y</td> 
   <td>X或Y</td> 
  </tr> 
  <tr> 
   <td>(X)</td> 
   <td>捕获组。可以在表达式中用\i引用第i个捕获组</td> 
  </tr> 
 </tbody> 
</table>

### 边界匹配符 ###

<table> 
 <thead> 
  <tr> 
   <th>正则表达式</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>^</td> 
   <td>一行的起始</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td>一行的结束</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>词的边界</td> 
  </tr> 
  <tr> 
   <td>\B</td> 
   <td>非词的边界</td> 
  </tr> 
  <tr> 
   <td>\G</td> 
   <td>前一个匹配的结束</td> 
  </tr> 
 </tbody> 
</table>

### 限定词 ###

<table> 
 <thead> 
  <tr> 
   <th>正则表达式</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>X?</td> 
   <td>一个或零个X</td> 
  </tr> 
  <tr> 
   <td>X*</td> 
   <td>零个或多个X</td> 
  </tr> 
  <tr> 
   <td>X+</td> 
   <td>一个或多个X</td> 
  </tr> 
  <tr> 
   <td>X{n}</td> 
   <td>恰好n次X</td> 
  </tr> 
  <tr> 
   <td>X{n,}</td> 
   <td>至少n次X</td> 
  </tr> 
  <tr> 
   <td>X{n,m}</td> 
   <td>X至少n次，且不超过m次</td> 
  </tr> 
 </tbody> 
</table>

**表达式X通常应该用圆括号括起来，以便它能够按照预期的效果执行。**

# Pattern和Matcher #

Java中除了使用String类来使用正则表达式，还提供了功能更为强大的Pattern和Matcher类。一般的使用方法为：  
1. 使用`Pattern.compile()方法`，根据提供的String类型的正则表达式生成Pattern对象。  
2. 将需要检索的字符串传入Pattern对象的`matcher()方法`，生成Matcher对象。  
3. 使用Matcher对象进行操作。

### 简单示例 ###

public class Main {
        public static void main(String[] args) {
            //获取英文单词
            String str = "apple banana orange";
            Pattern pattern = Pattern.compile("[a-zA-Z]+");
            Matcher matcher = pattern.matcher(str);
            while (matcher.find()) {
                System.out.println(matcher.group() + " start:"
                        + matcher.start() + " end:" + matcher.end());
            }
        }
    }

输出

apple start:0 end:5
    banana start:6 end:12
    orange start:13 end:19

### Matcher ###

##### start()、end() #####

在匹配成功后，start()返回先前匹配的起始位置的索引，而end()返回所匹配的最后字符的索引位置加一的值。

##### matchers() #####

matchers()方法用于判断**整个**输入字符串是否匹配正则表达式。上述例子中执行`System.out.println(matcher.matches());`，将输出`false`。

##### lookingAt() #####

lookingAt()方法用于判断该字符串的起始部分是否匹配模式。上述例子中执行`System.out.println(matcher.lookingAt());`，将输出`true`。

##### find() #####

find()方法类似迭代器中的next()，向前遍历输入字符串。

##### find(int start) #####

find(int start)能够接受一个整数参数，该整数表示字符串中字符的位置，并以其作为搜索起点。将上述例子修改：

public class Main {
        public static void main(String[] args) {
            //获取英文单词
            String str = "apple banana orange";
            Pattern pattern = Pattern.compile("[a-zA-Z]+");
            Matcher matcher = pattern.matcher(str);
            if (matcher.find(2)) {
                System.out.println(matcher.group());
            }
        }
    }

输出

ple

##### 组（group） #####

组是用括号划分的正则表达式，可以根据组的编号来引用某个组。组号为0表示整个正则表达式，组号为1表示被第一对括号括起的组，以此类推。以`A(B(C))D`为例，共三个组，组0为ABCD，组1为BC，组2为C。

##### groupCount() #####

groupCount()返回该匹配器的模式中的分组数目，第0组不包括在内。

##### group() #####

group()返回前一次匹配操作的第0组。

##### group(int i) #####

group(int i)返回在前一次匹配操作期间指定的组。下面是简单的示例，第1组为`\\d+`。

public class Main {
        public static void main(String[] args) {
            String str = "apple123banana";
            Pattern pattern = Pattern.compile("[a-zA-Z]+(\\d+)[a-zA-Z]+");
            Matcher matcher = pattern.matcher(str);
            System.out.println(matcher.groupCount());
            if (matcher.find()) {
                System.out.println(matcher.group(1));
            }
        }
    }

输出

1
    123