Java正则表达式

前言

关于正则表达式这东西，不用多说，大家都知道，主要用来做校验匹配。这里主要讲Java中正则表达式的用法，也就是Pattern、Matcher的主要用法。代码很简单，一看就懂。

用法

package test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {

     public static void main(String[] args) {
          String str = "abc12dd354fdfdf1.26fds";
          String reg = "\\d+";

          // 完全匹配，也就是字符串与正则完全匹配
          // 字符串自带的matches方法
          boolean matches1 = str.matches(reg);
          // 相当于
          boolean matches2 = Pattern.matches(reg, str);
          // 也相当于
          boolean matches3 = Pattern.compile(reg).matcher(str).matches();

          // 部分匹配，即字符串中有满足正则的就匹配
          Pattern pattern = Pattern.compile(reg);
          Matcher matcher = pattern.matcher(str);
          while(matcher.find()){   
              // 匹配到的字符串的开始下标
              int start = matcher.start();
              // 匹配到的字符串的结束下标
              int end = matcher.end();
              // 匹配的字符串
              String group = matcher.group();       
              // 注意这里的下标是前闭后开的，也就是start<=index<end
              System.out.println(group  + "      位于下标start:"+start+"   end:"+end); 
          }
    }
}

了解到上面的方式之后，可以做的东西就很多了， 比如找到匹配的字符串之后，替换成xx，或者拼接xx之类的处理，自由想象

false false false

12      位于下标start:3   end:5
354      位于下标start:7   end:10
1      位于下标start:15   end:16
26      位于下标start:17   end:19

为什么说

boolean matches1 = str.matches(reg);
相当于
boolean matches2 = Pattern.matches(reg, str);

开始只是猜想，后面查看String源码matches方法，可以看到：

    public boolean matches(String regex) {
        return Pattern.matches(regex, this);
    }

所以说还是猜对了。然后继续看Pattern.matches方法

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

明白了吧，其实平时用的字符串的匹配，实现也是Pattern、Matcher提供的。

既然看了String的源码，那么继续分析一下，

public String[] split(String regex) {
   return split(regex, 0);
}

String平时使用的很多的split方法，继续追踪下去，代码中间部分就不用看了，就是对字符串的一些处理，最后调用的是Pattern.compile(regex).split(this, limit);

public String[] split(String regex, int limit) {
        char ch = 0;
        if (((regex.value.length == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
             (regex.length() == 2 &&
              regex.charAt(0) == '\\' &&
              (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
              ((ch-'a')|('z'-ch)) < 0 &&
              ((ch-'A')|('Z'-ch)) < 0)) &&
            (ch < Character.MIN_HIGH_SURROGATE ||
             ch > Character.MAX_LOW_SURROGATE))
        {
            int off = 0;
            int next = 0;
            boolean limited = limit > 0;
            ArrayList<String> list = new ArrayList<>();
            while ((next = indexOf(ch, off)) != -1) {
                if (!limited || list.size() < limit - 1) {
                    list.add(substring(off, next));
                    off = next + 1;
                } else {    // last one
                    //assert (list.size() == limit - 1);
                    list.add(substring(off, value.length));
                    off = value.length;
                    break;
                }
            }
            // If no match was found, return this
            if (off == 0)
                return new String[]{this};

            // Add remaining segment
            if (!limited || list.size() < limit)
                list.add(substring(off, value.length));

            // Construct result
            int resultSize = list.size();
            if (limit == 0)
                while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
                    resultSize--;
            String[] result = new String[resultSize];
            return list.subList(0, resultSize).toArray(result);
        }
        return Pattern.compile(regex).split(this, limit);
    }

平时看源码看得少，不看不知道，一看吓一跳，其实很多实现都是很多自己用过得东西组装实现的，

比如substring，以前有时候substring之后，忘记用字符串接收了，导致没有截取成功，以为调用了就自动截取了，结果发现，它的实现竟然是这样的，难怪

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

哈哈哈，还是不分析了，继续分析这篇就成了String源码分析了，多看看源码其实可以发现很多东西。