Java 正则表达式详细实例解析

案例1：判断字符串是否是abc

package Regex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * 1.正则对应的类是Pattern(翻译：模式)而不是Rxgex，我们用到的方法都在Pattern类里面

 * 2.案例1：判断字符串是否是abc

 */

public class PatternDemo01 {

    public static void main(String[] args) {

        String str = "abc";

        // 根据以前的方法进行判断

        // System.out.println(str.equals("abc"));

        /**

         * 用正则表达式来判断

         * 1.compile(String regex)    将给定的正则表达式编译到模式中。

         * 2.matcher(CharSequence input)    创建匹配给定输入与此模式的匹配器。

         * 3.matches()    尝试将整个区域与模式匹配。

         */

        // 首先要编译正则规则形式

        Pattern p = Pattern.compile("abc");

        // 将正则进行匹配

        Matcher m = p.matcher(str);

        // 进行判断

        boolean b = m.matches();

        System.out.println(b);

    }

}

案例2：判断一个字符串

package Regex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * 案例2：判断一个字符串

 * 由3个字母组成

 * 第一个字母是 a/b/c

 * 第二个字母是 d/e/f/g

 * 第三个字母是 x/y/z

 */

public class PatternDemo02 {

    public static void main(String[] args) {

        String str = "agx";

        // 指定判断规则(中括号内字符顺序随便)

        Pattern p = Pattern.compile("[abc][edgf][xzy]");

        // 进行规则匹配

        Matcher m = p.matcher(str);

        // 进行判断

        boolean b = m.matches();

        System.out.println(b);

    }

}

案例3：判断一个字符串

package Regex;

/**

 * 案例3：判断一个字符串

 * 由3个字母组成

 * 第一个字母是 a/b/c

 * 第二个字母是 d/e/f/g

 * 第三个字母是 x/y/z

 */

public class PatternDemo03 {

    public static void main(String[] args) {

        String str = "agx";

        // 将原来的3个步骤封装到一步进行判断

        System.out.println(str.matches("[abc][defg][zyx]"));

    }

}

案例4：字符类

[abc]    a、b 或 c（简单类）
[^abc]    任何字符，除了 a、b 或 c（否定）
[a-zA-Z]    a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]    a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]    d、e 或 f（交集）
[a-z&&[^bc]]    a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]    a 到 z，而非 m 到 p：[a-lq-z]（减去）

package Regex;

/**

 * [abc]     a、b 或 c（简单类）

 * [^abc]     任何字符，除了 a、b 或 c（否定）

 * [a-zA-Z]     a 到 z 或 A 到 Z，两头的字母包括在内（范围）

 */

public class PatternDemo04 {

    public static void main(String[] args) {

        // 判断由一个字母组成的字符串

        String str1 = "D";

        System.out.println(str1.matches("[a-zA-Z]"));

        // 判断由一个数字组成的字符串

        String num = "2";

        System.out.println(num.matches("[0-9]"));

        // 判断由一个字符组成的字符串，但不是 a/b/c

        String str2 = "/";

        System.out.println(str2.matches("[^a-c]"));

    }

}

案例5：预定义字符类

package Regex;

/**

 * 案例5：预定义字符类

 * .     任何一个字符（与行结束符可能匹配也可能不匹配）

 */

public class PatternDemo05 {

    public static void main(String[] args) {

        // 判断一个由a开头的由两个字符组成的字符串

        String str1 = "af";

        System.out.println(str1.matches("a."));

        // 判断是否是一个 .

        // Java 用\\进行转义

        String str2 = ".";

        System.out.println(str2.matches("\\."));

        // 匹配一个 \

        String str3 = "\\";

        System.out.println(str3.matches("\\\\"));

    }

}

案例6：判断小数

package Regex;

/**

 * 案例6：Greedy 数量词

 * X+     代表 X至少出现一次或多次    >=1

 *

 *         Reluctant 数量词

 * X*     代表X出现零次或多次      >=0

 *

 * X?    表示X至多出现一次

 */

public class PatternDemo06 {

    public static void main(String[] args) {

        // 判断由a开头，至少有三个字符组成的字符串

        String str1 = "asdfuj312s";

        System.out.println(str1.matches("a.+"));

        // 判断由小写字母开头，数字结尾的字符串

        String str2 = "a3";

        System.out.println(str2.matches("[a-z].*[0-9]"));

        // 判断由a开头至多有2个字符组成的字符串

        String str3 = "a";

        System.out.println(str3.matches("a.?"));

        // 判断小数

        String str4 = "0.4";

        System.out.println(str4.matches("[0-9]+\\.\\d+"));

        System.out.println(str4.matches("0\\.\\d+") || str4.matches("[1-9]\\d*\\.\\d+"));

    }

}

案例7：密码校验：8-20位，小写字母/大写字母/数字中的至少两种

package Regex;

/**

 * 案例7：

 * X{n}     X，恰好 n 次

 * X{n,}     X，至少 n 次

 * X{n,m}     X，至少 n 次，但是不超过 m 次

 */

public class PatternDemo07 {

    public static void main(String[] args) {

        // 判断由5个小写字母组成的字符串

        String str1 = "gjhad";

        System.out.println(str1.matches("[a-z]{5}"));

        // 判断由至少5个小写字母组成的字符串

        String str2 = "sdfguhvujhsdfkgvjhsdf";

        System.out.println(str2.matches("[a-z]{5,}"));

        // 判断由8-12个小写字母组成的字符串

        String str3 = "weqrtyuio";

        System.out.println(str3.matches("[a-z]{8,12}"));

        // 练习：密码校验：8-20位，小写字母/大写字母/数字中的至少两种

        String str4 = "qwe123SAD";

        check(str4);

    }

    public static boolean check(String str) {

        // 判断输入的密码是否出现规定以外的字符

        if(!str.matches("[a-zA-Z0-9]{8,20}"))

            return false;

        // 记录出现几种字符

        int count = 0;

        // 如果出现小写字母

        if(str.matches(".*[a-z].*"))

        count++;

        // 如果出现大写字母

        if(str.matches(".*[A-Z].*"))

        count++;

        // 如果出现数字

        if(str.matches(".*[0-9].*")) // str.matches(".*\\d.*")

        count++;

        // 如果count < 2

        if(count < 2) {

            System.out.println("密码错误！");

            return false;

        }else

            return true;

    }

}

案例8：()捕获组

package Regex;

/**

 * 案例8：

 * 1.()捕获组

 * 2.正则表达式会对其中的捕获组进行自动编号

 * 3.从1开始编号

 * 4.\\n 表示引用前边编号为n的捕获组

 *

 */

public class PatternDemo08 {

    public static void main(String[] args) {

        /**

         * 捕获组的编号是从捕获组的左半边括号出现的位置开始计算的

         * (A((BC)(D))E)(F)

         * 1号：A((BC)(D))E

         * 2号：(BC)(D)

         * 3号：BC

         * 4号：D

         * 5号：F

         */

        String str1 = "abfdabasdf";

        System.out.println(str1.matches(".*(ab).*\\1.*"));

        // 匹配至少由两个字符组成的字符串

        System.out.println(str1.matches("(.){2,}"));

    }

}

案例9：运用捕获组判断叠字

package Regex;

/**

 * 案例9：

 * 运用捕获组判断叠字

 */

public class PatternDemo09 {

    public static void main(String[] args) {

        // 匹配AAA形式的叠字字符串

        String str1 = "aaa";

        System.out.println(str1.matches("(.)\\1+"));

        // 匹配AABB形式的叠字字符串

        String str2 = "AABB";

        System.out.println(str2.matches("(.)\\1(.)\\2"));

        // 匹配ABAB形式的叠字字符串

        String str3 = "ABAB";

        System.out.println(str3.matches("(..)\\1"));

    }

}

案例10：邮箱格式校验

package Regex;

/**

 * 案例10：邮箱格式校验

 *

 */

public class PatternDemo10 {

    public static void main(String[] args) {

        String str1 = "42513@qq.com";

        String str2 = "cjjsdfasf@sina.com.cn";

        String str3 = "24eqwe";

        check(str1);

        check(str2);

        check(str3);

    }

    public static void check(String str) {

        // 以.cn结尾的邮箱

        if(str.matches("[a-zA-Z0-9]{6,36}@[a-zA-Z0-9]{3,10}(\\.com)?(\\.cn)")

                ||str.matches("[a-zA-Z0-9]{3,10}@[a-zA-Z0-9]{1,36}(\\.com)")) {

            System.out.println("ok");

        }else

            System.out.println("no");

    }

}

案例11：利用正则表达式替换字符串内指定字符

package Regex;

/**

 * 利用正则表达式替换字符串内指定字符

 *

 */

public class PatternDemo11 {

    public static void main(String[] args) {

        String str = "261refdae612c,./d/";

        // 将字符串内所有数字替换为-

        System.out.println(str.replaceAll("\\d", "-"));

        // 将字符串内所有非数字去掉

        System.out.println(str.replaceAll("\\D", ""));

    }

}

案例12：输入一个字符串，统计字符串中每一个字符出现的次数

package Regex;

/**

 * 输入一个字符串，统计字符串中每一个字符出现的次数

 *

 */

public class PatternDemo12 {

    public static void main(String[] args) {

        String str = "sdafv187623rtajhsd";

        fin(str);

    }

    public static  void fin(String str) {

        // 获取第一个字符

        char c = str.charAt(0);

        // 将第一个字符都替换为空

        String str1 = str.replaceAll("" + c, "");

        // 计算两个字符串的长度

        int len = str.length() - str1.length();

        System.out.println(str.charAt(0) + ":" + len);

        // 如果替换后的字符串长度大于0.说明还没有统计完，再次调用统计方法

        if(str1.length() > 0)

        fin(str1);

    }

}

案例13：交换字符串中指定位置的字符

package Regex;

/**

 * 交换字符串中指定位置的字符

 *

 */

public class PatternDemo13 {

    public static void main(String[] args) {

        String str = "I Like Beijing.";

        System.out.println(str.replaceAll("(I )(Like )(Beijing.)", "$3$2$1"));

    }

}

案例14：将叠字替换为单字

package Regex;

/**

 * 将叠字替换为单字

 */

public class PatternDemo14 {

    public static void main(String[] args) {

        String str = "AAAAABBBBBDDDDDGGGGG";

        System.out.println(str.replaceAll("(.)\\1+", "$1"));

    }

}

案例15：计算字符串的平均长度

package Regex;

/**

 * 计算字符串的平均长度

 *

 */

public class PatternDemo15 {

    public static void main(String[] args) {

        String str = "aaabbbdjhjjjjkkkkk(((jjjooo";

        fin(str);

    }

    public static void fin(String str) {

        // 字符串长度

        double len = str.length();

        // 将叠字换成单字

        String str1 = str.replaceAll("(.)\\1+", "a");

        // 统计单字组成的长度

        double len1 = str1.length();

        double n = len / len1;

        System.out.println(n);

    }

}

案例16：以数字作为切割符将字符切开

package Regex;

import java.util.Arrays;

/**

 * 以数字作为切割符将字符切开

 * 作为切割符的符号会被切掉

 * 在字符串最尾部的切割符会整个切掉

 */

public class PatternDemo16 {

    public static void main(String[] args) {

        String str = "2iasug8jhfch9sjba90";

        /**

         * 1.split(String regex)

         *       根据给定正则表达式的匹配拆分此字符串。

         * 2.toString(Object[] a)

         *   返回指定数组内容的字符串表示形式。

         */

        // str1是字符串数组

        String[] str1 = str.split("\\d");

        // 将字符串数组抓换成字符串

        System.out.println(Arrays.toString(str1));

    }

}

巴特西