Java字符串 正则表达式详解

在日常Java后端开发过程中，免不了对数据字段的解析，自然就少不了对字符串的操作，这其中就包含了正则表达式这一块的内容，这里面涉及Java包中Pattern类和Macher类，本篇博客就针对这一块内容和常见的用法进行总结，本博客主要的参考资料是《Java编程思想》第4版。

以一个问题引出本博客的内容。问题是：检查一个字符串是否以大写字母开头，以句号结尾。

String len="^[A-Z].*[\\.]$";
System.out.println("Taaa.".matches(len));//true
System.out.println("taaa.".matches(len));//false
System.out.println("Taaa".matches(len));//false

1.*[\.] 就 是 正 则 表 达 式 ， 用 来 匹 配 字 符 串 。 代 表 一 行 的 起 始 ， [ A − Z ] 表 是 A 到 Z 任 何 的 字 母 ， 就是正则表达式，用来匹配字符串。^代表一行的起始，[A-Z]表是A到Z任何的字母， 就是正则表达式，用来匹配字符串。代表一行的起始，[A−Z]表是A到Z任何的字母，表示的一行的结束。

一、规则表

规则表定义正则表达式该怎么写。这类东西不需要刻意去记，用的时候去写就好，用多了自然就记住了。

1.字符

2.字符类 .

3.边界匹配符

4.逻辑操作符

5.量词

二、Pattern类

1.Pattern类的实例获取—compile方法

1.下面主要是Pattern类源码下一些重要的方法

private Pattern(String p, int f) {
   pattern = p;
   flags = f;
// to use UNICODE_CASE if UNICODE_CHARACTER_CLASS present
   if ((flags & UNICODE_CHARACTER_CLASS) != 0)
       flags |= UNICODE_CASE;
// Reset group index count
   capturingGroupCount = 1;
   localCount = 0;
if (!pattern.isEmpty()) {
       try {
           compile();
       } catch (StackOverflowError soe) {
           throw error("Stack overflow during pattern compilation");
       }
   } else {
       root = new Start(lastAccept);
       matchRoot = lastAccept;
   }
}

从Pattern类代码可以看出构造器是私有的，故无法使用new去获得Pattern类对象实例。

仔细查询Pattern类下代码后发现通过静态方法compile去获取Pattern类的实例对象。

public static Pattern compile(String regex) {
   return new Pattern(regex, 0);
}

通过compile方法生成一个Pattern类实例对象，然后将想要匹配的字段传入Pattern对象的matcher()方法，matcher()方法会返回生成一个Matcher类实例对象，这个对象也有很多对应的方法。所以Matcher类也是无法通过new去创建一个实例的，而是通过matcher方法

public Matcher matcher(CharSequence input) {
   if (!compiled) {
       synchronized(this) {
           if (!compiled)
               compile();
       }
   }
   Matcher m = new Matcher(this, input);
   return m;
}

public static boolean matches(String regex, CharSequence input) {
   Pattern p = Pattern.compile(regex);
   Matcher m = p.matcher(input);
   return m.matches();
}

所以之前博客开头那个问题，也可以用另外两种方式实现：

方式一：

Pattern len = Pattern.compile("^[A-Z].*[\\.]$");
Matcher matcher = len.matcher("Taaa.");
boolean matches = matcher.matches();
System.out.println(matches);

当是从源码中可以看出matches方法是类静态方法，所以没必要使用Macher类实例对象来调用方法。可以使用：

方式二：

System.out.println(Pattern.matches("^[A-Z].*[\\.]$","Taaa."));

2.split方法

下面是Split方法的源码：

public String[] split(CharSequence input, int limit) {
   int index = 0;
   boolean matchLimited = limit > 0;
   ArrayList<String> matchList = new ArrayList<>();
   Matcher m = matcher(input);
// Add segments before each match found
   while(m.find()) {
       if (!matchLimited || matchList.size() < limit - 1) {
           if (index == 0 && index == m.start() && m.start() == m.end()) {
               // no empty leading substring included for zero-width match
               // at the beginning of the input char sequence.
               continue;
           }
           String match = input.subSequence(index, m.start()).toString();
           matchList.add(match);
           index = m.end();
       } else if (matchList.size() == limit - 1) { // last one
           String match = input.subSequence(index,
                                            input.length()).toString();
           matchList.add(match);
           index = m.end();
       }
   }
// If no match was found, return this
   if (index == 0)
       return new String[] {input.toString()};
// Add remaining segment
   if (!matchLimited || matchList.size() < limit)
       matchList.add(input.subSequence(index, input.length()).toString());
// Construct result
   int resultSize = matchList.size();
   if (limit == 0)
       while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
           resultSize--;
   String[] result = new String[resultSize];
   return matchList.subList(0, resultSize).toArray(result);
}

方法解析：

input：要拆分的字符序列；

limit：结果阈值；根据指定模式拆分输入序列。

limit参数作用：

limit参数控制应用模式的次数，从而影响结果数组的长度。

如果 n 大于零，那么模式至多应用 n- 1 次，数组的长度不大于 n，并且数组的最后条目将包含除最后的匹配定界符之外的所有输入。

如果 n 非正，那么将应用模式的次数不受限制，并且数组可以为任意长度。

如果 n 为零，那么应用模式的次数不受限制，数组可以为任意长度，并且将丢弃尾部空字符串。

详细讲解：假设 input=“boo:and:foo”，匹配符为"o"，可知模式最多可应用4次，数组的长度最大为5；

1、当limit=-2时，应用模式的次数不受限制且数组可以为任意长度；推测模式应用4次，数组的长度为5，数组为{“b”,"",":and:f","",""}；

2、当limit=2时，模式至多应用1次，数组的长度不大于 2，且第二个元素包含除最后的匹配定界符之外的所有输入；推测模式应用1次，数组的长度为2，数组为{“b”,“o:and:foo”}；

3、当limit=7时，模式至多应用6次，数组的长度不大于 7；推测模式应用4次，数组的长度为5，数组为{“b”,"",":and:f","",""}；

4、当limit=0时，应用模式的次数不受限制，数组可以为任意长度，并且将丢弃尾部空字符串；推测模式应用4次，数组的长度为3，数组为{“b”,"",":and:f"}。

这里m.find像迭代器，遍历输入字符串

3.Pattern中匹配标记参数

Pattern.CASE_INSENSITIVE、Pattern.COMMENTS、Pattern.MULTILINE这三个比较常用。

三、Matcher类

对照Matcher构造器源码，可知构造器将Pattern对象的引用赋于Matcher中变量parentPattern，目标字符串赋于变量text；并创建了数组groups和locals 。

数组groups是组使用的存储。存储的是当前匹配的各捕获组的first和last信息。

groups[0]存储的是组零的first，groups[1]存储的是组零的last，groups[2]存储的是组1的first，groups[3]存储的是组1的last，依次类推。

Matcher类的方法非常多，这里就不对每个方法的源码进行详细的解读了，后续如果有空会深入研究一下。将常用方法总结如下：

总结

本篇文章就到这里了，希望能够给你带来帮助！

来源：https://blog.csdn.net/weixin_41938314/article/details/120124014