Java 从入门到进阶之路（十七）

在之前的文章我们介绍了一下 Java 中类的内部类，本章我们来看一下 Java 中的正则表达式。

在任何一种语言中，都绕不开正则表达式，而且大部分语言的正则表达式都有预定义的字符集，且预定义的字符集也都差不多，如下：

上面的预定义字符集，在JavaScript，Java，Python 中其实是通用的，那接下来我们就利用 Java 的语法来对其进行一下解释。

 public class HelloWorld {
     public static void main(String[] args) {
         String regex = ".";
         String string1 = "A";
         String string2 = "AB";
         System.out.println(string1.matches(regex)); // true
         System.out.println(string2.matches(regex)); // false
     }
 }

在上面的代码中，我们定义了一个 . 的正则表达，.  表示任意一个字符，不能多也不能少，如上，我们通过 matches 方法匹配一个 . 时，"A" 我 true，"B" 为 false；那我们就可以一次类推 \d \w \s 同样也是匹配一个字符，并且必须符合其中的规矩。

那我国我们想输出大于一位的该如何做呢，如下：

 public class HelloWorld {
     public static void main(String[] args) {
         // + 表示至少出现一次，可以出现多次
         String regex1 = "[A-Z]+";
         String string1 = "A";
         String string2 = "AB";
         System.out.println(string1.matches(regex1)); // true
         System.out.println(string2.matches(regex1)); // true

         /**
          * {2,3}
          * 逗号前面表示最少出现 2 次
          * 逗号后面表示最多出现 3 次
          *
          * {2,} 表示最少出现 2 次，最多不限
          * {0,2} 如果想表示最多出现次数，最少此时不限，则必须逗号前面为 0，不能为空
          *
          * */
         //
         String regex2 = "[A-Z]{2,3}";
         String string3 = "A";
         String string4 = "AB";
         String string5 = "ABCD";
         System.out.println(string3.matches(regex2)); // false
         System.out.println(string4.matches(regex2)); // true
         System.out.println(string5.matches(regex2)); // false

         // ? 表示至多出现一次
         String regex3 = "[A-Z]?";
         String string6 = "A";
         String string7 = "AB";
         System.out.println(string6.matches(regex3)); // true
         System.out.println(string7.matches(regex3)); // false
     }
 }

在上面的代码中，我们实现了单一字符的次数问题，但是如果想要匹配的并非单一字符，比如 "ABC" 该如何实现呢，如下：

 public class HelloWorld {
     public static void main(String[] args) {
         // () 内的将会被视为一个整体
         String regex1 = "(ABC)+";
         String string1 = "AB";
         String string2 = "ABC";
         System.out.println(string1.matches(regex1)); // false
         System.out.println(string2.matches(regex1)); // true

         // | 表示 或 的意思
         String regex2 = "(ABC|DEF)+";
         String string3 = "ABC";
         String string4 = "ABCDEF";
         System.out.println(string3.matches(regex2)); // true
         System.out.println(string4.matches(regex2)); // true

     }
 }

在上面的代码中，我们发现，我们可以通过 () 将想要匹配的整体内容括起来，这样就解决了匹配非单一字符的问题，并且 | 表示或的意思，可以让我们更有选择性的匹配。

当然正则的匹配远不止上面所讲的这些，这只是写基础用法，当然我们根据这些基础用法其实就可以完成一些我们想要的正则匹配。

接下来我们根据上面所说的做一个简单的邮箱的正则匹配：

123abc@163.com，123456789@qq.com，abc_123@gmail.com.cn

上面的三个邮箱可能是我们常用的邮箱，他们在结构上都满足一些共同的特征：数字或字母下划线 @ 数字或字母下划线 . 数字或字母下划线 . 数字或字母下划线

那我们就可以根据上面的特征来做一个正则的验证：

 public class HelloWorld {
     public static void main(String[] args) {
         /**
          * \w 或 [a-zA-Z0-9_] 都表示任意字母数字或下划线
          * (\.\w) 表示任意一个 .字符串
          * 注意：. 在正则中表示任意一个字符，所以前面需要加 \ 来将其转义
          *
          * */
         // \ 在 Java 中只是个普通的字符，所以在前面加一个 \ 将其转义，简单理解就是正则中如果出现 \ 就在前面再加一个 \
         String regex = "[a-zA-Z0-9_]+@\\w+(\\.[a-zA-Z0-9_]+)+";
         System.out.println(regex); // [a-zA-Z0-9_]+@\w+(\.[a-zA-Z0-9_]+)+
         String mail = "abc123@163.com";
         boolean flag = mail.matches(regex); // true
         if (flag) {
             System.out.println("是邮箱");
         } else {
             System.out.println("不是邮箱");
         }
     }
 }

我们同样可以根据上面的内容来做一个手机号码的正则验证：

 public class HelloWorld {
     public static void main(String[] args) {
         /**
          * 1[0,9]{10} 手机号码以 1 开头，后面为 10 为数字
          * (\+86|0086)?\s* 手机号前面可能会加 86 或 0086 以及 空格 这些
          * + 在正则表达式中有特殊含义，所以加 \ 转义
          * */
         String regex = "(\\+86|0086)?\\s*1[1-9]{10}";
         System.out.println(regex); // (\+86|0086)?\s*1[1-9]{10}
         String phone = "+86 13666666666";
         boolean flag = phone.matches(regex); // true
         if (flag) {
             System.out.println("是电话号码");
         } else {
             System.out.println("不是电话号码");
         }
     }
 }