1. 正则表达式的应用

String 类提供的几个特殊方法

方法声明 功能描述
matches() 判断该字符串是否匹配指定的正则表达式
replaceAll() 将该字符串所有匹配正则表达式的子串替换成指定的字符串
replaceFirst() 将该字符串中第一个匹配正则表达式的子串替换成指定的字符串
split(String regex) 以regex为分隔符，将该字符串分割成多个子串

1.1 匹配功能

  1. public  boolean matches(String regex) // 编译给定正则表达式并尝试将给定输入与其匹配。

校验邮箱

  1. package cn.itcast_02;
  2. import java.util.Scanner;
  3. /*
  4.  * 校验邮箱
  5.  * 
  6.  * 分析：
  7.  *         A:键盘录入邮箱
  8.  *         B:定义邮箱的规则
  9.  *             1517806580@qq.com
  10.  *             liuyi@163.com
  11.  *             linqingxia@126.com
  12.  *             fengqingyang@sina.com.cn
  13.  *             fqy@itcast.cn
  14.  *         C:调用功能，判断即可
  15.  *         D:输出结果
  16.  */
  17. public class RegexTest {
  18.     public static void main(String[] args) {
  19.         //键盘录入邮箱
  20.         Scanner sc = new Scanner(System.in);
  21.         System.out.println("请输入邮箱：");
  22.         String email = sc.nextLine();
  24.         //定义邮箱的规则
  25.         //String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";
  26.         String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";
  28.         //调用功能，判断即可
  29.         boolean flag = email.matches(regex);
  31.         //输出结果
  32.         System.out.println("flag:"+flag);
  33.     }
  34. }

1.2 分割功能

  1. public  String[] split(String regex) // 根据指定的正则表达式分割字符串

代码示例：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

  1. package cn.itcast_03;
  2. import java.util.Arrays;
  3. /*
  4.  * 我有如下一个字符串:"91 27 46 38 50"
  5.  * 请写代码实现最终输出结果是："27 38 46 50 91"
  6.  * 
  7.  * 分析：
  8.  *         A:定义一个字符串
  9.  *         B:把字符串进行分割，得到一个字符串数组
  10.  *         C:把字符串数组变换成int数组
  11.  *         D:对int数组排序
  12.  *         E:把排序后的int数组在组装成一个字符串
  13.  *         F:输出字符串
  14.  */
  15. public class RegexTest {
  16.     public static void main(String[] args) {
  17.         // 定义一个字符串
  18.         String s = "91 27 46 38 50";
  20.         // 把字符串进行分割，得到一个字符串数组
  21.         String[] strArray = s.split(" ");
  23.         // 把字符串数组变换成int数组
  24.         int[] arr = new int[strArray.length];
  26.         for (int x = 0; x < arr.length; x++) {
  27.             arr[x] = Integer.parseInt(strArray[x]);
  28.         }
  30.         // 对int数组排序
  31.         Arrays.sort(arr);
  33.         // 把排序后的int数组在组装成一个字符串
  34.         StringBuilder sb = new StringBuilder();
  35.         for (int x = 0; x < arr.length; x++) {
  36.             sb.append(arr[x]).append(" ");
  37.         }
  38.         //转化为字符串
  39.         String result = sb.toString().trim();
  41.         //输出字符串
  42.         System.out.println("result:"+result);
  43.     }
  44. }

1.3 替换功能

  1. public  String replaceAll(String regex,String replacement)

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

  • 论坛中不能出现数字字符，用*替换
  1. package cn.itcast_04;
  2. /*
  3.  * 替换功能
  4.  *      String类的public String replaceAll(String regex,String replacement)
  5.  *      使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
  6.  */
  7. public class RegexDemo {
  8.     public static void main(String[] args) {
  9.         // 定义一个字符串
  10.         String s = "helloqq12345worldkh622112345678java";
  12.         // 我要去除所有的数字,用*给替换掉
  13.         // String regex = "\\d+";
  14.         // String regex = "\\d";
  15.         //String ss = "*";
  18.         // 直接把数字干掉
  19.         String regex = "\\d+";
  20.         String ss = "";
  22.         String result = s.replaceAll(regex, ss);
  23.         System.out.println(result);
  24.     }
  25. }

1.4 获取功能

Pattern和Matcher类的使用

  1. package cn.itcast_05;
  2. import java.util.regex.Matcher;
  3. import java.util.regex.Pattern;
  4. /*
  5.  * 获取功能
  6.  *        Pattern和Matcher类的使用
  7.  *        
  8.  *        模式和匹配器的基本使用顺序
  9.  */
  10. public class RegexDemo {
  11.     public static void main(String[] args) {
  12.         // 模式和匹配器的典型调用顺序
  13.         // 把正则表达式编译成模式对象
  14.         Pattern p = Pattern.compile("a*b");
  15.         // 通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串
  16.         Matcher m = p.matcher("aaaaab");
  17.         // 调用匹配器对象的功能
  18.         boolean b = m.matches();
  19.         System.out.println(b);
  21.         //这个是判断功能，但是如果做判断，这样做就有点麻烦了，我们直接用字符串的方法做
  22.         String s = "aaaaab";
  23.         String regex = "a*b";
  24.         boolean bb = s.matches(regex);
  25.         System.out.println(bb);
  26.     }
  27. }

1.5 Pattern 匹配模式

Pattern类为正则表达式的编译表示形式。指定为字符串的表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一个模式。

方法声明 功能描述
compile() 把正则表达式编译成匹配模式
matcher() 根据匹配模式去匹配指定的字符串，得到匹配器

1.6 Matcher 匹配器

方法声明 功能描述
matches() 匹配字符串
find() 查找有没有满足条件的子串
group() 获取满足条件的子串
reset() 将Matcher的状态重新设置为最初的状态
reset(CharSequence input) 重新设置Matcher的状态，并且将候选字符序列设置为input后进行Matcher, 这个方法和重新创建一个Matcher一样，只是这样可以重用以前的对象。
start() 返回Matcher所匹配的字符串在整个字符串的的开始下标
start(int group) 指定你感兴趣的sub group,然后返回sup group(子分组)匹配的开始位置。
end() 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
  • 注意事项

Pattern类为正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式

分组：简单的说，分组其实就是为了能够指定同一个规则可以使用多少次。正则表达式中的分组就是整个大的正则表达式和用（）圈起来的内容。

在这个正则表达式”\w(\d\d)(\w+)”中

  • 分组0：是”\w(\d\d)(\w+)”
  • 分组1：是(\d\d)
  • 分组2：是(\w+)

如果我们稍稍变换一下，将原先的正则表达式改为”（\w）(\d\d)(\w+)”，我们的分组就变成了

  • 分组0：是”\w(\d\d)(\w+)”
  • 分组1：是”(\w)”
  • 分组2：是”(\d\d)”
  • 分组3：是”(\w+)”

我们看看和正则表达式”\w(\d\d)(\w+)”匹配的一个字符串A22happy

  • group(0)是匹配整个表达式的字符串的那部分A22happy
  • group(1)是第1组(\d\d)匹配的部分:22
  • group(2)是第2组(\w+)匹配的那部分happy
  1. public static void main(String[] args) {
  2.     String Regex="\\w(\\d\\d)(\\w+)";
  3.     String TestStr="A22happy";
  4.     Pattern p=Pattern.compile(Regex);
  5.     Matcher matcher=p.matcher(TestStr);
  6.     if (matcher.find()) {
  7.         int gc=matcher.groupCount();
  8.         for (int i = 0; i <= gc; i++) {
  9.             System.out.println("group "+i+" :"+matcher.group(i));
  10.         }
  11.     }
  12. }
  • start()方法的使用
  1. public static void testStart(){
  2.     //创建一个 Matcher ，使用 Matcher.start()方法
  3.     String candidateString = "My name is Bond. James Bond.";
  4.     String matchHelper[] ={"          ^","                      ^"};
  5.     Pattern p = Pattern.compile("Bond");
  6.     Matcher matcher = p.matcher(candidateString);
  7.     //找到第一个 'Bond'的开始下标
  8.     matcher.find();
  9.     int startIndex = matcher.start();
  10.     System.out.println(candidateString);
  11.     System.out.println(matchHelper[0] + startIndex);
  12.     //找到第二个'Bond'的开始下标
  13.     matcher.find();
  14.     int nextIndex = matcher.start();
  15.     System.out.println(candidateString);
  16.     System.out.println(matchHelper[1] + nextIndex);        
  17. }

运行结果：

正则表达式的应用 - 图1

  1. /**
  2.   * 测试matcher.group方法
  3.   */
  4. public static void testGroup() {
  5.     // 创建一个 Pattern
  6.     Pattern p = Pattern.compile("Bond");
  7.     // 创建一个 Matcher ，以便使用 Matcher.group() 方法
  8.     String candidateString = "My name is Bond. James Bond.";
  9.     Matcher matcher = p.matcher(candidateString);
  10.     // 提取 group
  11.     matcher.find();
  12.     System.out.println(String.format("group匹配的字符串 : %s",matcher.group()));
  13.     System.out.println(String.format("匹配的开始位置 : %d", matcher.start()));
  14.     System.out.println(String.format("匹配的结束位置 : %d", matcher.end()));
  16.     System.out
  17.             .println("---再次使用matcher.find()方法，看看matcher中group、start、end方法的效果");
  18.     matcher.find();
  19.     System.out.println(String.format("group匹配的字符串 : %s",matcher.group()));;
  20.     System.out.println(String.format("匹配的开始位置 : %d", matcher.start()));
  21.     System.out.println(String.format("匹配的结束位置 : %d", matcher.end()));
  22.     System.out.println(String.format("candidateString字符串的长度 : %d", candidateString.length()));
  23. }

运行结果：

正则表达式的应用 - 图2

  • 获取由三个字符组成的单词
  1. package cn.itcast_05;
  2. import java.util.regex.Matcher;
  3. import java.util.regex.Pattern;
  4. /*
  5.  * 获取功能：
  6.  * 获取下面这个字符串中由三个字符组成的单词
  7.  * da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?
  8.  */
  9. public class RegexDemo2 {
  10.     public static void main(String[] args) {
  11.         // 定义字符串
  12.         String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
  13.         // 规则
  14.         String regex = "\\b\\w{3}\\b";
  16.         // 把规则编译成模式对象
  17.         Pattern p = Pattern.compile(regex);
  18.         // 通过模式对象得到匹配器对象
  19.         Matcher m = p.matcher(s);
  20.         // 调用匹配器对象的功能
  21.         // 通过find方法就是查找有没有满足条件的子串
  22.         // public boolean find()
  23.         // boolean flag = m.find();
  24.         // System.out.println(flag);
  25.         // // 如何得到值呢?
  26.         // // public String group()
  27.         // String ss = m.group();
  28.         // System.out.println(ss);
  29.         //
  30.         // // 再来一次
  31.         // flag = m.find();
  32.         // System.out.println(flag);
  33.         // ss = m.group();
  34.         // System.out.println(ss);
  36.         while (m.find()) {
  37.             System.out.println(m.group());
  38.         }
  40.         // 注意：一定要先find()，然后才能group()
  41.         // IllegalStateException: No match found
  42.         // String ss = m.group();
  43.         // System.out.println(ss);
  44.     }
  45. }
  • 判断身份证：要么是15位，要么是18位，最后一位可以为字母，并写程序提出其中的年月日。
  1. public static void main(String[] args) {
  2.     testID_Card();
  3. }
  5. public static void testID_Card() {
  6.     // 测试是否为合法的身份证号码
  7.     String[] strs = { "130681198712092019", "13068119871209201x",
  8.             "13068119871209201", "123456789012345", "12345678901234x",
  9.             "1234567890123" };
  10.     // 准备正则表达式（身份证有15位和18位两种，身份证的最后一位可能是字母）
  11.     String regex = "(\\d{14}\\w)|\\d{17}\\w";
  12.     // 准备开始匹配，判断所有的输入是否是正确的
  13.     Pattern regular = Pattern.compile(regex); // 创建匹配的规则Patter
  15.     StringBuilder sb = new StringBuilder();
  16.     // 遍历所有要匹配的字符串
  17.     for (int i = 0; i < strs.length; i++) {
  19.         Matcher matcher = regular.matcher(strs[i]);// 创建一个Matcher
  20.         sb.append("身份证:  ");
  21.         sb.append(strs[i]);
  22.         sb.append("   匹配:");
  23.         sb.append(matcher.matches());
  24.         System.out.println(sb.toString());
  25.         sb.delete(0, sb.length());// 清空StringBuilder的方法
  26.     }
  28.     GetBirthDay(strs);
  30. }
  32. private static void GetBirthDay(String[] strs) {
  33.     System.out.println("准备开始获取出生日期");
  34.     // 准备验证规则
  35.     Pattern BirthDayRegular = Pattern.compile("(\\d{6})(\\d{8})(.*)");
  36.     // .*连在一起就意味着任意数量的不包含换行的字符
  37.     Pattern YearMonthDayRegular = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");
  38.     for (int i = 0; i < strs.length; i++) {
  39.         Matcher matcher = BirthDayRegular.matcher(strs[i]);
  41.         if (matcher.matches()) {
  42.             Matcher matcher2 = YearMonthDayRegular.matcher(matcher.group(2));
  43.             if (matcher2.matches()) {
  44.                 System.out.println(strs[i]+"    中的出生年月分解为： "+"年" + matcher2.group(1) + "   月：" + matcher2.group(2) + "  日：" + matcher2.group(3));
  46.             }
  47.         }
  48.     }
  49. }

运行结果：

正则表达式的应用 - 图3

2. 正则表达式工具类

  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;
  4. /**
  5.  * 正则工具类 提供验证邮箱、手机号、电话号码、身份证号码、数字等方法
  6.  */
  7. public final class RegexUtils {
  9.     /**
  10.      * 验证Email
  11.      * 
  12.      * @param email
  13.      *            email地址，格式：zhangsan@sina.com，zhangsan@xxx.com.cn，xxx代表邮件服务商
  14.      * @return 验证成功返回true，验证失败返回false ^ ：匹配输入的开始位置。 \：将下一个字符标记为特殊字符或字面值。
  15.      *         ：匹配前一个字符零次或几次。 + ：匹配前一个字符一次或多次。 (pattern) 与模式匹配并记住匹配。 x|y：匹配 x 或
  16.      *         y。 [a-z] ：表示某个范围内的字符。与指定区间内的任何字符匹配。 \w ：与任何单词字符匹配，包括下划线。
  17.      * 
  18.      *         {n,m} 最少匹配 n 次且最多匹配 m 次 $ ：匹配输入的结尾。
  19.      */
  20.     public static boolean checkEmail(String email) {
  21.         String regex = "^(\\w)+(\\.\\w+)*@(\\w)+((\\.\\w{2,3}){1,3})$";
  22.         return Pattern.matches(regex, email);
  23.     }
  25.     /**
  26.      * 验证身份证号码
  27.      * 
  28.      * @param idCard
  29.      *            居民身份证号码15位或18位，最后一位可能是数字或字母
  30.      * @return 验证成功返回true，验证失败返回false
  31.      */
  32.     public static boolean checkIdCard(String idCard) {
  33.         String regex = "[1-9]\\d{13,16}[a-zA-Z0-9]{1}";
  34.         return Pattern.matches(regex, idCard);
  35.     }
  37.     /**
  38.      * 验证手机号码（支持国际格式，+86135xxxx...（中国内地），+00852137xxxx...（中国香港））
  39.      * 
  40.      * @param mobile
  41.      *            移动、联通、电信运营商的号码段
  42.      *            <p>
  43.      *            移动的号段：134(0-8)、135、136、137、138、139、147（预计用于TD上网卡）
  44.      *            、150、151、152、157（TD专用）、158、159、187（未启用）、188（TD专用）
  45.      *            </p>
  46.      *            <p>
  47.      *            联通的号段：130、131、132、155、156（世界风专用）、185（未启用）、186（3g）
  48.      *            </p>
  49.      *            <p>
  50.      *            电信的号段：133、153、180（未启用）、189
  51.      *            </p>
  52.      *            <p>
  53.      *            虚拟运营商的号段：170
  54.      *            </p>
  55.      * @return 验证成功返回true，验证失败返回false
  56.      */
  57.     public static boolean checkMobile(String mobile) {
  58.         String regex = "(\\+\\d+)?1[34578]\\d{9}$";
  59.         return Pattern.matches(regex, mobile);
  60.     }
  62.     /**
  63.      * 验证固定电话号码
  64.      * 
  65.      * @param phone
  66.      *            电话号码，格式：国家（地区）电话代码 + 区号（城市代码） + 电话号码，如：+8602085588447
  67.      *            <p>
  68.      *            <b>国家（地区） 代码 ：</b>标识电话号码的国家（地区）的标准国家（地区）代码。它包含从 0 到 9
  69.      *            的一位或多位数字， 数字之后是空格分隔的国家（地区）代码。
  70.      *            </p>
  71.      *            <p>
  72.      *            <b>区号（城市代码）：</b>这可能包含一个或多个从 0 到 9 的数字，地区或城市代码放在圆括号——
  73.      *            对不使用地区或城市代码的国家（地区），则省略该组件。
  74.      *            </p>
  75.      *            <p>
  76.      *            <b>电话号码：</b>这包含从 0 到 9 的一个或多个数字
  77.      *            </p>
  78.      * @return 验证成功返回true，验证失败返回false
  79.      */
  80.     public static boolean checkPhone(String phone) {
  81.         // String regex = "(\\+\\d+)?(\\d{3,4}\\-?)?\\d{7,8}$";
  82.         String regex = "^1\\d{10}$";
  83.         return Pattern.matches(regex, phone);
  84.     }
  86.     /**
  87.      * 验证整数（正整数和负整数）
  88.      * 
  89.      * @param digit
  90.      *            一位或多位0-9之间的整数
  91.      * @return 验证成功返回true，验证失败返回false
  92.      */
  93.     public static boolean checkDigit(String digit) {
  94.         String regex = "\\-?[1-9]\\d+";
  95.         return Pattern.matches(regex, digit);
  96.     }
  98.     /**
  99.      * 验证整数和浮点数（正负整数和正负浮点数）
  100.      * 
  101.      * @param decimals
  102.      *            一位或多位0-9之间的浮点数，如：1.23，233.30
  103.      * @return 验证成功返回true，验证失败返回false
  104.      */
  105.     public static boolean checkDecimals(String decimals) {
  106.         String regex = "\\-?[1-9]\\d+(\\.\\d+)?";
  107.         return Pattern.matches(regex, decimals);
  108.     }
  110.     /**
  111.      * 验证空白字符
  112.      * 
  113.      * @param blankSpace
  114.      *            空白字符，包括：空格、\t、\n、\r、\f、\x0B
  115.      * @return 验证成功返回true，验证失败返回false
  116.      */
  117.     public static boolean checkBlankSpace(String blankSpace) {
  118.         String regex = "\\s+";
  119.         return Pattern.matches(regex, blankSpace);
  120.     }
  122.     /**
  123.      * 验证中文
  124.      * 
  125.      * @param chinese
  126.      *            中文字符
  127.      * @return 验证成功返回true，验证失败返回false
  128.      */
  129.     public static boolean checkChinese(String chinese) {
  130.         String regex = "^[\u4E00-\u9FA5]+$";
  131.         return Pattern.matches(regex, chinese);
  132.     }
  134.     /**
  135.      * 验证日期（年月日）
  136.      * 
  137.      * @param birthday
  138.      *            日期，格式：1992-09-03，或1992.09.03
  139.      * @return 验证成功返回true，验证失败返回false
  140.      */
  141.     public static boolean checkBirthday(String birthday) {
  142.         String regex = "[1-9]{4}([-./])\\d{1,2}\\1\\d{1,2}";
  143.         return Pattern.matches(regex, birthday);
  144.     }
  146.     /**
  147.      * 验证URL地址
  148.      * 
  149.      * @param url
  150.      *            格式：http://blog.csdn.net:80/xyang81/article/details/7705960? 或
  151.      *            http://www.csdn.net:80
  152.      * @return 验证成功返回true，验证失败返回false
  153.      */
  154.     public static boolean checkURL(String url) {
  155.         String regex = "(https?://(w{3}\\.)?)?\\w+\\.\\w+(\\.[a-zA-Z]+)*(:\\d{1,5})?(/\\w*)*(\\??(.+=.*)?(&.+=.*)?)?";
  156.         return Pattern.matches(regex, url);
  157.     }
  159.     /**
  160.      * 匹配中国邮政编码
  161.      * 
  162.      * @param postcode
  163.      *            邮政编码
  164.      * @return 验证成功返回true，验证失败返回false
  165.      */
  166.     public static boolean checkPostcode(String postcode) {
  167.         String regex = "[1-9]\\d{5}";
  168.         return Pattern.matches(regex, postcode);
  169.     }
  171.     /**
  172.      * 匹配IP地址(简单匹配，格式，如：192.168.1.1，127.0.0.1，没有匹配IP段的大小)
  173.      * 
  174.      * @param ipAddress
  175.      *            IPv4标准地址
  176.      * @return 验证成功返回true，验证失败返回false
  177.      */
  178.     public static boolean checkIpAddress(String ipAddress) {
  179.         String regex = "[1-9](\\d{1,2})?\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))";
  180.         return Pattern.matches(regex, ipAddress);
  181.     }
  183.     public static boolean checkNickname(String nickname) {
  184.         String regex = "^[a-zA-Z0-9\u4E00-\u9FA5_]+$";
  185.         return Pattern.matches(regex, nickname);
  186.     }
  189.     public static boolean hasCrossSciptRiskInAddress(String str) {
  190.         String regx = "[`~!@#$%^&*+=|{}':;',\\[\\].<>~！@#￥%……&*——+|{}【】‘；：”“’。，、？-]";
  191.         if (str != null) {
  192.             str = str.trim();
  193.             Pattern p = Pattern.compile(regx, Pattern.CASE_INSENSITIVE);
  194.             Matcher m = p.matcher(str);
  195.             return m.find();
  196.         }
  197.         return false;
  198.     }
  199. }