java 正则表达式

正则表达式语法

这里的表格记录了 java 中可用的所有正则表达式的元字符语法：

子表达式	匹配对应
^	匹配一行的开头
$	匹配一行的结尾
.	匹配除了换行符的任何单个字符，也可以利用 m 选项允许它匹配换行符
[...]	匹配括号内的任意单个字符。
[^...]	匹配不在括号内的任意单个字符。
\A	整个字符串的开始
\z	整个字符串的结束
\Z	整个字符串的结束，除了最后一行的结束符
re*	匹配0或者更多的前表达事件
re+	匹配1个或更多的之前的事件
re?	匹配0或者1件前表达事件
re{ n}	匹配特定的n个前表达事件
re{ n,}	匹配n或者更多的前表达事件
re{ n, m}	匹配至少n最多m件前表达事件
a| b	匹配a或者b
(re)	正则表达式组匹配文本记忆
(?: re)	没有匹配文本记忆的正则表达式组
(?> re)	匹配无回溯的独立的模式
\w	匹配单词字符
\W	匹配非单词字符
\s	匹配空格。等价于 [\t\n\r\f]
\S	匹配非空格
\d	匹配数字. 等价于 [0-9]
\D	匹配非数字
\A	匹配字符串的开始
\Z	匹配字符串的末尾，如果存在新的一行，则匹配新的一行之前
\z	匹配字符串的末尾
\G	匹配上一次匹配结束的地方
\n	返回参考捕获组号“N”
\b	不在括号里时匹配单词边界。在括号里时匹配退格键
\B	匹配非词边界
\n, \t, etc.	匹配换行符，回车符，制表符，等
\Q	引用字符的初始，结束于\E
\E	结束由\Q开始的引用

Matcher 类的方法

这里列出了有用的实例方法

index 方法

index方法提供有用的指标值，精确地显示输入字符串中相匹配的位置：

SN	方法描述
1	public int start()  返回之前匹配开始索引
2	public int start(int group) 返回被之前匹配操作得出的组捕获的子序列
3	public int end() 返回在最后一个字符匹配之后的偏移量
4	public int end(int group)  返回在之前匹配操作得出的组捕获的子序列之后的偏移量

Study 方法

Study 方法根据输入字符串返回一个布尔类型数据来指示该模式是否被找到。

SN	方法描述
1	public boolean lookingAt()  试图匹配输入序列，从模式的起始位置开始
2	public boolean find()  试图找到下一个输入序列的子序列来进行模式匹配
3	public boolean find(int start） 重置匹配，并且试图找到下一个从某个特定位置开始的输入序列的子序列来进行模式匹配
4	public boolean matches()  试图去匹配模式的整个区域

Replacement 方法

Replacement 方法是在一个输入字符串中替换文本的有效方法。

SN	方法描述
1	public Matcher appendReplacement(StringBuffer sb, String replacement) 实现一个无目的的添加和代替步骤
2	public StringBuffer appendTail(StringBuffer sb) 实现一个有目的的添加和代替步骤
3	public String replaceAll(String replacement)  代替每一个输入序列的子序列，与给出的代替字符串的模式匹配
4	public String replaceFirst(String replacement)  代替第一个输入序列的子序列，与给出的代替字符串的模式匹配
5	public static String quoteReplacement(String s) 返回一个特定字符串逐字替换的字符串。这个方法产生了一个字符串将作为文本替换的 Matcher 类的 appendreplacement 方法

start 和 end 方法

下面是一个例子，计算 "cats" 在输入字符串中出现的次数：

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

public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
                                    "cat cat cat cattie cat";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // get a matcher object
       int count = 0;

       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

这是产生的结果：

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

你可以看到这个例子用次边界来确保字母 "c""a""t" 不仅仅是一个长单词子串。它也给出了一些关于在输入字符串中匹配位置的有用的信息。

start方法返回值是之前end方法返回值加1。

matches 和 lookingAt 方法

matches 和 lookingAt 方法都是按照一定的模式匹配输入序列，两种方法不同的是 matches 方法需要匹配整个输入序列，找出其中不同的。

两种方法都总是开始于输入字符串的起始位置。这里是一个例子：

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

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);

       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
   }
}

这是产生的结果：

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst 方法和 replaceAll 方法

replaceFirst 和 replaceAll 方法替换了匹配给定正则表达式的文本。正如它们的名字所表明的，replaceFirst 替换第一个情况，而 replaceAll 替换所有的情况。

这里是解释功能的例子：

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

public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

以上将会产生如下结果：

The cat says meow. All cats say meow.

appendReplacement 和 appendTail 方法

Matcher 类还提供了 appendReplacement 和 appendTail 两种方法来替换文本。

这里是解释功能的例子：

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

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

以上将会产生如下结果：

-foo-foo-foo-

PatternSyntaxException Class 方法

PatternSyntaxException 是一个未检查的、在正则表达式模式指示语法错误的特例。PatternSyntaxException 类提供了以下的方法来帮助你找出问题所在：

SN	方法描述
1	public String getDescription() 检索错误的描述
2	public int getIndex()  检索误差指标
3	public String getPattern()  检索错误的正则表达式模式
4	public String getMessage()  返回一个包含语法错误的描述及其指标的多行字符串、错误的正则表达式模式以及显示模式里误差指标

 

java 常用正则表达式

package com.modules.plateform.tool;

import java.util.regex.Pattern;
/**
 * 账户相关属性验证工具
 *
 */
public class AccountValidatorUtil {
    /**
     * 正则表达式：验证用户名
     */
    public static final String REGEX_USERNAME = "^[a-zA-Z]\\w{5,20}$";
 
    /**
     * 正则表达式：验证密码
     */
    public static final String REGEX_PASSWORD = "^[a-zA-Z0-9]{6,20}$";
 
    /**
     * 正则表达式：验证手机号
     */
    public static final String REGEX_MOBILE = "^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";
 
    /**
     * 正则表达式：验证邮箱
     */
    public static final String REGEX_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
 
    /**
     * 正则表达式：验证汉字
     */
    public static final String REGEX_CHINESE = "^[\u4e00-\u9fa5],{0,}$";
 
    /**
     * 正则表达式：验证身份证
     */
    public static final String REGEX_ID_CARD = "(^\\d{18}$)|(^\\d{15}$)";
 
    /**
     * 正则表达式：验证URL
     */
    public static final String REGEX_URL = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";
 
    /**
     * 正则表达式：验证IP地址
     */
    public static final String REGEX_IP_ADDR = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";
 
    /**
     * 校验用户名
     * 
     * @param username
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isUsername(String username) {
        return Pattern.matches(REGEX_USERNAME, username);
    }
 
    /**
     * 校验密码
     * 
     * @param password
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isPassword(String password) {
        return Pattern.matches(REGEX_PASSWORD, password);
    }
 
    /**
     * 校验手机号
     * 
     * @param mobile
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isMobile(String mobile) {
        return Pattern.matches(REGEX_MOBILE, mobile);
    }
 
    /**
     * 校验邮箱
     * 
     * @param email
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isEmail(String email) {
        return Pattern.matches(REGEX_EMAIL, email);
    }
 
    /**
     * 校验汉字
     * 
     * @param chinese
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isChinese(String chinese) {
        return Pattern.matches(REGEX_CHINESE, chinese);
    }
 
    /**
     * 校验身份证
     * 
     * @param idCard
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isIDCard(String idCard) {
        return Pattern.matches(REGEX_ID_CARD, idCard);
    }
 
    /**
     * 校验URL
     * 
     * @param url
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isUrl(String url) {
        return Pattern.matches(REGEX_URL, url);
    }
 
    /**
     * 校验IP地址
     * 
     * @param ipAddr
     * @return
     */
    public static boolean isIPAddr(String ipAddr) {
        return Pattern.matches(REGEX_IP_ADDR, ipAddr);
    }
}