Java 正则表达式

又该洗头了

于 2024-04-08 21:22:10 发布

阅读量975

点赞数 28

文章标签： java 正则表达式 mysql

本文链接：https://blog.csdn.net/weixin_74521994/article/details/137523352

版权

本文介绍了Java中的正则表达式概念，包括模式定义、Pattern和Matcher类的使用、字符类、逻辑运算符、数量词以及预定义字符的应用。通过实例展示了如何在Java中构建和使用正则表达式进行字符串处理。

摘要由CSDN通过智能技术生成

概念

Java正则表达式是一种用于处理字符串的强大工具，它可以用来匹配、查找、替换和分割字符串。在Java中，正则表达式主要通过java.util.regex包中的Pattern和Matcher类来实现。

具体来说，Java正则表达式的概念包括以下几个关键点：

模式定义：正则表达式使用单个字符串来描述一系列符合某个语句规则的字符串，定义了字符串的模式。
编译表示：Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。这个对象是正则表达式的编译表示，可以多次使用来创建 Matcher 对象。
匹配操作：Matcher 类用于对字符串进行匹配操作。通过调用 Pattern 对象的 matcher 方法并传入要匹配的字符串，可以创建一个 Matcher 对象。然后可以使用 Matcher 对象的方法来进行查找、分组等操作。
功能应用：正则表达式通常被用来检索、替换那些符合某个模式的字符串。例如，可以用来验证输入的格式、提取特定的信息或者批量修改文本数据。
代码简写：在代码中，正则表达式常简写为 regex、regexp 或 RE。
示例构建：可以通过一些示例来了解如何在Java中构建正则表达式，并根据特定的模式表示一组字符串。

以下是一个简单的Java正则表达式示例：

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

public class Main {
    public static void main(String[] args) {
        // 定义一个正则表达式
        String regex = "\\d+"; // 匹配一个或多个数字

        // 创建一个Pattern对象
        Pattern pattern = Pattern.compile(regex);

        // 要匹配的字符串
        String input = "abc123def456";

        // 创建一个Matcher对象
        Matcher matcher = pattern.matcher(input);

        // 使用find()方法查找匹配的子串
        while (matcher.find()) {
            System.out.println("找到匹配的子串： " + matcher.group());
        }
    }
}

运行上述代码，将输出：

//找到匹配的子串： 123
//找到匹配的子串： 456

字符类

正则表达式中的字符类是一个特殊的构造，它允许你匹配一组字符中的任意一个。在Java的正则表达式中，字符类是通过方括号[]来定义的。以下是一些关于字符类的详细信息：

定义字符类：通过将一系列字符放在方括号[]内，可以创建一个字符类。例如，[abc]将匹配任何一个字符'a'、'b'或'c'。
范围表示：可以在字符类中使用连字符-来表示一个字符范围。例如，[a-z]将匹配任何小写字母。
预定义字符类：Java正则表达式提供了一些预定义的字符类，如\d匹配任何数字字符，\w匹配任何字母数字字符等。
否定字符类：如果在字符类的开头使用了脱字号^，则表示匹配不在方括号内的任何字符。例如，[^aeiou]将匹配任何非元音字母。
字符类的使用：字符类可以与其他正则表达式元素结合使用，以构建更复杂的模式。例如，\d{3}-\d{2}-\d{4}可以用于匹配社会安全号码的格式。

语法示例：

[abc]：代表a或者b，或者c字符中的一个。
[^abc]：代表除a,b,c以外的任何字符。
[a-z]：代表a-z的所有小写字符中的一个。
[A-Z]：代表A-Z的所有大写字符中的一个。
[0-9]：代表0-9之间的某一个数字字符。
[a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
[a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。

代码展示：

public static void main(String[] args) {
        //public boolean matches(String regex):判断是否与正则表达式匹配，匹配返回true
        // 只能是a b c
        System.out.println("-----------1-------------");
        System.out.println("a".matches("[abc]")); // true
        System.out.println("z".matches("[abc]")); // false

        // 不能出现a b c
        System.out.println("-----------2-------------");
        System.out.println("a".matches("[^abc]")); // false
        System.out.println("z".matches("[^abc]")); // true
        System.out.println("zz".matches("[^abc]")); //false
        System.out.println("zz".matches("[^abc][^abc]")); //true

        // a到zA到Z(包括头尾的范围)
        System.out.println("-----------3-------------");
        System.out.println("a".matches("[a-zA-z]")); // true
        System.out.println("z".matches("[a-zA-z]")); // true
        System.out.println("aa".matches("[a-zA-z]"));//false
        System.out.println("zz".matches("[a-zA-Z]")); //false
        System.out.println("zz".matches("[a-zA-Z][a-zA-Z]")); //true
        System.out.println("0".matches("[a-zA-Z]"));//false
        System.out.println("0".matches("[a-zA-Z0-9]"));//true


        // [a-d[m-p]] a到d，或m到p
        System.out.println("-----------4-------------");
        System.out.println("a".matches("[a-d[m-p]]"));//true
        System.out.println("d".matches("[a-d[m-p]]")); //true
        System.out.println("m".matches("[a-d[m-p]]")); //true
        System.out.println("p".matches("[a-d[m-p]]")); //true
        System.out.println("e".matches("[a-d[m-p]]")); //false
        System.out.println("0".matches("[a-d[m-p]]")); //false

        // [a-z&&[def]] a-z和def的交集。为:d，e，f
        System.out.println("----------5------------");
        System.out.println("a".matches("[a-z&[def]]")); //false
        System.out.println("d".matches("[a-z&&[def]]")); //true
        System.out.println("0".matches("[a-z&&[def]]")); //false

        // [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
        System.out.println("-----------6------------_");
        System.out.println("a".matches("[a-z&&[^bc]]"));//true
        System.out.println("b".matches("[a-z&&[^bc]]")); //false
        System.out.println("0".matches("[a-z&&[^bc]]")); //false

        // [a-z&&[^m-p]] a到z和除了m到p的交集。(等同于[a-1q-z])
        System.out.println("-----------7-------------");
        System.out.println("a".matches("[a-z&&[^m-p]]")); //true
        System.out.println("m".matches("[a-z&&[^m-p]]")); //false
        System.out.println("0".matches("[a-z&&[^m-p]]")); //false

    }

逻辑运算符

正则表达式中的逻辑运算符用于将多个模式组合在一起，以匹配更复杂的字符串。在Java的正则表达式中，逻辑运算符包括以下几种：

或运算符：使用竖线|表示或运算符。例如，a|b可以匹配字符'a'或'b'。
与运算符：使用点号.表示与运算符。例如，a.b可以匹配任何包含字符'a'和'b'的字符串。
零次或多次运算符：使用星号*表示零次或多次运算符。例如，a*可以匹配零个或多个字符'a'。
一次或多次运算符：使用加号+表示一次或多次运算符。例如，a+可以匹配一个或多个字符'a'。
零次或一次运算符：使用问号?表示零次或一次运算符。例如，a?可以匹配零个或一个字符'a'。
指定次数运算符：使用花括号{}表示指定次数运算符。例如，a{3}可以匹配三个字符'a'。

简单示例

public static void main(String[] args) {
		String str = "had";
		
		//1.要求字符串是小写辅音字符开头，后跟ad
		String regex = "[a-z&&[^aeiou]]ad";
		System.out.println("1." + str.matches(regex));
		
		//2.要求字符串是aeiou中的某个字符开头，后跟ad
		regex = "[a|e|i|o|u]ad";//这种写法相当于：regex = "[aeiou]ad";
		System.out.println("2." + str.matches(regex));
	}

预定义字符

正则表达式中存在一些预定义字符，它们可以匹配特定的字符集合。

以下是一些常用的预定义字符及其含义：

\d：匹配任意数字字符，相当于字符类 [0-9]。
\D：匹配任意非数字字符，相当于字符类 [^0-9]。
\s：匹配任意空白字符，包括空格、制表符、换页符等，相当于字符类 [f \r\t\v]。
\S：匹配任意非空白字符，相当于字符类 [^ \f r\t\v]。
w：匹配任意字母、数字或下划线字符，相当于字符类 [A-Za-z_0-9]。
\W：匹配任意非字母、数字或下划线的字符，相当于字符类 [^A-Za-z_0-9]。
.：通常用于匹配除换行符之外的任意单个字符。但在一些情况下，它可以配置为匹配包括换行符在内的任意字符。
^：表示字符串的开始位置。
$：表示字符串的结束位置。

这些预定义字符在编写正则表达式时非常有用，因为它们提供了一种简洁且易于理解的方式来匹配常见的字符集。例如，要验证一个字符串是否全由数字组成，可以使用 ^\d+$，这表示从字符串开始到结束只包含一个或多个数字字符。同样地，要查找以字母开头的单词，可以使用 \b\w+\b，其中 \b 表示单词边界。

代码示例：

public static void main(String[] args) {
        //.表示任意一个字符
        System.out.println("你".matches("..")); //false
        System.out.println("你".matches(".")); //true
        System.out.println("你a".matches(".."));//true

        // \\d 表示任意的一个数字
        // \\d只能是任意的一位数字
        // 简单来记:两个\表示一个\
        System.out.println("a".matches("\\d")); // false
        System.out.println("3".matches("\\d")); // true
        System.out.println("333".matches("\\d")); // false

        //\\w只能是一位单词字符[a-zA-Z_0-9]
        System.out.println("z".matches("\\w")); // true
        System.out.println("2".matches("\\w")); // true
        System.out.println("21".matches("\\w")); // false
        System.out.println("你".matches("\\w"));//false

        // 非单词字符
        System.out.println("你".matches("\\W")); // true
        System.out.println("---------------------------------------------");
        // 以上正则匹配只能校验单个字符。


        // 必须是数字 字母 下划线 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必须是数字和字符 必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
		
	}

数量词

正则表达式中的数量词用于指定某个字符或字符集出现的次数。具体包括以下几种：

星号（*）：匹配前一个字符0次或多次。例如，a*可以匹配字符串"aaa"中的每个'a'，也可以匹配空字符串，因为星号允许0次匹配。
加号（+）：匹配前一个字符1次或多次。与星号不同，加号不允许0次匹配，至少需要匹配1次。
问号（？）：匹配前一个字符0次或1次。它使得前面的字符变为可选的，即该字符可以出现一次或者不出现。
花括号（{m}）：匹配前一个字符恰好m次。例如，d{3}将匹配任何三个连续的数字字符。
花括号（{m,n}）：匹配前一个字符至少m次，但不超过n次。例如，\d{2,4}将匹配任何2到4个连续的数字字符。

示例：

public static void main(String[] args) {
		 // 必须是数字 字母 下划线 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必须是数字和字符 必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
	}

又该洗头了

关注

28
点赞
踩
14

收藏

觉得还不错? 一键收藏
2
评论
Java 正则表达式

正则表达式中存在一些预定义字符，它们可以匹配特定的字符集合。\d：匹配任意数字字符，相当于字符类[0-9]。\D：匹配任意非数字字符，相当于字符类[^0-9]。\s：匹配任意空白字符，包括空格、制表符、换页符等，相当于字符类[f \r\t\v]。\S：匹配任意非空白字符，相当于字符类。w：匹配任意字母、数字或下划线字符，相当于字符类。\W：匹配任意非字母、数字或下划线的字符，相当于字符类。：通常用于匹配除换行符之外的任意单个字符。但在一些情况下，它可以配置为匹配包括换行符在内的任意字符。
复制链接

扫一扫