带你从零学大数据系列之Java篇---第十四章:正则表达式

千锋教育官方

已于 2023-08-28 11:05:58 修改

阅读量984

点赞数

分类专栏：大数据文章标签： java 正则表达式 mysql

于 2020-06-23 11:35:06 首次发布

本文链接：https://blog.csdn.net/GUDUzhongliang/article/details/106919456

版权

大数据专栏收录该内容

48 篇文章 3 订阅

订阅专栏

课程重点:

正则表达式简单理解
正则表达式的简单使用

14.1. 正则表达式的简介

14.1.1. 正则表达式的简介

正则表达式，不是Java特有的。是一套独立的，自成体系的知识点。在很多语言中，都有对正则的使用。

正则表达式，使用来做字符串的校验、匹配的，其实正则只有一个作用: 验证一个字符串是否与指定的规则匹配。

但是，在很多的语言中，都在匹配的基础上，添加了其他的功能。例如Java: 在匹配的基础上，还添加了删除、替换... 功能

14.1.2. 正则表达式的使用

实现相同的功能，用String、StringBuffer、StringBuilder可以实现，用正则表达式也可以实现。

但是在实现过程中，复杂程度是完全不一样的。

/**
 * @Description
 */
public class Regex1 {

    public static void main(String[] args) {
        System.out.println(checkWithRegex("123456"));            // true
        System.out.println(checkWithRegex("1234"));              // false
        System.out.println(checkWithRegex("1234567890987"));     // false
        System.out.println(checkWithRegex("123.456"));           // false
        System.out.println(checkWithRegex("abcdefg"));           // false
        System.out.println(checkWithRegex("0123456"));           // false
    }

    /**
     * 使用正则表达式，验证一个字符串是否是一个合法的QQ号码
     * @param str 字符串
     * @return 验证的结果
     */
    private static boolean checkWithRegex(String str) {
        return str.matches("[1-9]\\d{5,10}");
    }

    /**
     * 验证一个字符串是否是一个合法的QQ号码
     * @param str 字符串
     * @return 验证的结果
     */
    private static boolean check(String str) {
        // 1. 校验长度
        if (str.length() < 6 || str.length() > 11) {
            return false;
        }
        // 2. 校验纯数字组成
        try {
            Long.parseLong(str);
        }
        catch (NumberFormatException e) {
            // 说明不是纯数字，无法转成long型的变量
            return false;
        }
        // 3. 首字符校验
        return str.charAt(0) != '0';
    }
}

14.2. 基本的元字符

14.2.1. 正则表达式的匹配规则

逐个字符进行匹配，判断是否和正则表达式中定义的规则一致。

以下借助 String 类中的 matches 方法进行正则基础的语法讲解。

boolean matches(String regex);
是String类中的非静态方法，使用字符串对象调用这个方法，参数是一个正则表达式。
使用指定的正则表达式，和当前的字符串进行匹配。验证当前的字符串是否和指定的规则是相匹配的。

14.2.2. 元字符

14.2.3. 示例代码

/**
 * @Description 正则表达式的基础语法
 */
public class Regex2 {
    public static void main(String[] args) {
        // 校验规则:
        System.out.println(",ello".matches("[ahj1,8]ello"));
        System.out.println("fello".matches("[a-z]ello"));
        // 需求: 首位字符，可以是任意的小写字母，或者是 HAQ
        System.out.println("Hello".matches("[Ha-zAQ]ello"));
        // 需求: 首位字符，可以是任意的字母，包括大写字母和小写字母
        System.out.println("hello".matches("[a-zA-Z]ello"));
        // 需求: 首位字符，可以是除了h之外的任意字符
        System.out.println("Hello".matches("[^hel]ello"));
        // 需求: 首位字符，不可以是任意的小写字母，但是 h、e、q 除外
        System.out.println("lello".matches("[^a-z[heq]]ello"));

        // 希望首位字符，可以是 h e [
        System.out.println("]ello".matches("[he\\[]ello"));
        // 希望首位字符，可以是 a - z
        System.out.println("hello".matches("[az-]ello"));
        
        System.out.println("hello".matches("hel+o"));
        System.out.println("hello".matches("hel?o"));
        System.out.println("heo".matches("hel*o"));

        System.out.println("hello".matches("hel{3}o"));
        System.out.println("hello".matches("hel{3,}o"));
        System.out.println("hello".matches("hel{3,5}o"));
        
        // 需求: 匹配一个字符串可以是 126 或者是 163 或者是 qq 或者是 QQ
        System.out.println("123".matches("126|163|qq|QQ"));
        // 需求: 匹配一个qq邮箱、126邮箱、163邮箱
        System.out.println("admin@sina.com".matches("admin@(qq|126|163)\\.com"));
    }
}

14.3. String类中的常用的方法

14.3.1. 字符串的匹配

// QQ号的规则：
//      1. 纯数字组成的
//      2. 不能以0作为开头
//      3. 长度在 [6,11]
private static boolean chechQQ(String qqNumber) {
    return qqNumber.matches("[1-9]\\d{5,10}");
}

// 验证邮箱的合法性
//      1. 126
//      2. 前半部分可以是任意的单词字符, 长度限制在 [4,12]
//      3. 以.com作为结尾
private static boolean checkEmail(String email) {
    return email.matches("\\w{4,12}@126\\.com");
}

14.3.2. 字符串的切割

private static void split() {
    // 需求: 将一个存储有所有的姓名的字符串，切割出每一个名字。
    String names = "lily        lucy           polly      Jim       LiLei      HanMeimei";
    // 实现: 借助字符串的一个方法 split(String regex)
    //      将字符串中，满足正则规则的子部分，切割掉
    String[] nameArr = names.split(" +");
    System.out.println(Arrays.toString(nameArr));
}

14.3.3. 字符串的替换

private static void replace() {
    // 需求: 将这个存储有所有的名字的字符串，名字之间的分隔用, 来替代
    String names = "lily        lucy           polly      Jim       LiLei      HanMeimei";
    // 实现: 借助字符串中的一个方法 replaceAll(String regex, String replacement)
    //      将字符串中，满足指定正则的部分，替换成 replacement
    // String result = names.replaceAll(" +", ", ");
    String result = names.replaceFirst(" +", ", ");
    System.out.println(result);
}

private static void example() {
    // 需求: 将一个手机号的中间4位替换成 ****
    //      17788889999 => 177****9999
    String phoneNumber = "17788889999";
    // 在replace方法中，使用$1获取第一个分组的值
    String result = phoneNumber.replaceAll("(1\\d{2})(\\d{4})(\\d{4})", "$1****$3");
    System.out.println(result);
}

14.4. Pattern和Matcher类

14.4.1. 简介

在 java.util.regex 包中

Pattern类： 在Java中，正则表达式的载体。使用正则表达式进行字符串的校验、切割、替换，都需要使用到这个类。

在Java中，使用字符串的形式来写正则表达式。此时，如果需要这个字符串被当做是一个正则表达式使用，必须先由这样的字符串，编译为 Pattern 类的对象。然后才可以使用这个对象的某些方法，进行常见的操作（校验、切割、替换）。

Matcher类： 在Java中，对一个正则校验的结果描述。

14.4.2. 常用方法

find()

从字符串的第0位开始查询，查询是否有满足指定规则的子部分。

当再次调用find()的时候，从上次查询到的位置开始，继续向后查询。

关于查询

无论是 matches，还是find，还是lookingAt，在字符串中进行校验、匹配的时候，是有一个浮标存在的。

14.4.3. 示例代码

Pattern 类的使用：

/**
 * @Description Pattern类 和 Matcher类
 */
public class Regex1 {
    public static void main(String[] args) {
        // 1. 静态的校验
        boolean ret = Pattern.matches("[1-9]\\d{5,10}", "123456");
        System.out.println(ret);

        // 2. 将一个字符串编译为正则表达式对象(Pattern对象)
        Pattern pattern = Pattern.compile(" +");
        // 3. 字符串切割
        String[] array1 = pattern.split("Lily     Lucy    Polly     Jim     Tom");
        System.out.println(Arrays.toString(array1));

        String[] array2 = pattern.split("Lily     Lucy    Polly     Jim     Tom", 0);
        System.out.println(Arrays.toString(array2));
    }
}

Matcher:

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

/**
 * @Description Pattern和Matcher类的综合使用
 */
public class Regex2 {
    public static void main(String[] args) {
        // 1. 准备一个数据源
        String data = "abc123hello world456lily789lucy012uncle111wang";

        // 2. 将一个字符串变异成正则对象
        Pattern pattern = Pattern.compile("\\d+");

        // 3. 使用一个正则和一个字符串进行校验
        Matcher matcher = pattern.matcher(data);

        // 3.1. 获取整体校验的结果
        // 匹配逻辑：
        //      从第0个字符开始，判断每一个字符是否否则当前的正则。
        //      当找到了有不符合当前正则部分的时候，就会停止继续向后查找，直接返回false
        System.out.println(matcher.matches());

        // 3.2. find()
        while (matcher.find()) {
            System.out.print("匹配到了字符串: " + matcher.group() + ", ");
            System.out.println("下标范围: [" + matcher.start() + ", " + matcher.end() + ")");
        }

        // 3.3. lookingAt()
        System.out.println(matcher.lookingAt() + ", " + matcher.group() + ", [" + matcher.start() + ", " + matcher.end() + ")");
    }
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Description 每一个分组内容的获取
 */
public class Regex3 {
    public static void main(String[] args) {
        //
        Pattern pattern = Pattern.compile("(1\\d{2})(\\d{4})(\\d{4})");
        Matcher matcher = pattern.matcher("17788889999");

        // 获取分组的数量
        System.out.println(matcher.groupCount());
        // 获取每一个分组的值之前，先进行整体的匹配
        boolean ret = matcher.matches();
        // 获取到某一个分组的内容
        System.out.println(matcher.group(1));
    }
}

千锋教育官方

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
带你从零学大数据系列之Java篇---第十四章:正则表达式

但是，在很多的语言中，都在匹配的基础上，添加了其他的功能。实现相同的功能，用String、StringBuffer、StringBuilder可以实现，用正则表达式也可以实现。无论是 matches，还是find，还是lookingAt，在字符串中进行校验、匹配的时候，是有一个浮标存在的。正则表达式，使用来做字符串的校验、匹配的，其实正则只有一个作用: 验证一个字符串是否与指定的规则匹配。当再次调用find()的时候，从上次查询到的位置开始，继续向后查询。
复制链接

扫一扫