java正则表达式

hi，我是程序员王也，一个资深Java开发工程师，平时十分热衷于技术副业变现和各种搞钱项目的程序员~，如果你也是，可以一起交流交流。

今天我们聊聊Java中的正则表达式~

1. 引言

1.1 正则表达式的定义和用途

正则表达式（Regular Expression），简称regex，是一种用于字符串搜索和操作的强大工具。它使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式广泛应用在文本处理、数据验证、模式匹配等领域，是编程中不可或缺的一部分。

正则表达式的主要用途包括：

• 文本搜索：找出匹配某个模式的字符串。
• 文本替换：替换文本中的字符串为另一个字符串。
• 数据验证：验证输入数据是否符合预定的格式，如邮箱、电话号码等。

1.2 Java中正则表达式的实现

在Java中，正则表达式通过java.util.regex包中的Pattern和Matcher类来实现。Pattern类编译正则表达式，而Matcher类用于执行具体操作，如搜索和替换。

示例代码

以下是一些基础的Java代码示例，展示如何在Java中使用正则表达式。

使用Pattern和Matcher进行模式匹配

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

public class RegexExample {
    public static void main(String[] args) {
        // 定义一个正则表达式，匹配以"java"开头的字符串
        String regex = "java.*";
        Pattern pattern = Pattern.compile(regex);

        // 使用Matcher类来执行搜索操作
        String content = "I love programming in java and javascript";
        Matcher matcher = pattern.matcher(content);

        // 检查是否找到匹配项
        if (matcher.find()) {
            System.out.println("找到匹配项: " + matcher.group());
        } else {
            System.out.println("没有找到匹配项");
        }
    }
}

在这个例子中，我们首先定义了一个正则表达式regex，用于匹配任何以"java"开头的字符串。然后，我们使用Pattern.compile方法编译正则表达式，并用matcher对象来搜索content字符串。如果找到匹配项，matcher.find()方法将返回true，并通过matcher.group()获取匹配的字符串。

使用String类的正则表达式方法

Java的String类也提供了一些直接使用正则表达式的方法，如matches、replaceFirst和replaceAll。

public class StringRegexMethodsExample {
    public static void main(String[] args) {
        String text = "My email is example@example.com";
        // 使用String的matches方法检查字符串是否符合正则表达式的模式
        boolean isEmailValid = text.matches(".*email is [a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$");
        System.out.println("邮箱格式是否正确: " + isEmailValid);

        // 使用replaceFirst和replaceAll方法替换字符串
        String phone = "Call me at 123-456-7890";
        String replacedPhone = phone.replaceAll("-", "");
        System.out.println("替换后的电话号码: " + replacedPhone);
    }
}

2. 正则表达式基础

2.1 常用字符和元字符

正则表达式由一系列字符组成，其中一些特殊字符被称作元字符，因为它们表示正则表达式中的特殊指令或模式。以下是一些常用的字符和元字符：

• .：匹配除换行符之外的任何单个字符。
• *：匹配前面的字符零次或多次。
• +：匹配前面的字符一次或多次。
• ?：匹配前面的字符零次或一次，或表示非贪婪匹配。
• ^：匹配输入字符串的开始位置。
• $：匹配输入字符串的结束位置。
• []：字符集，匹配括号内的任意一个字符。
• ()：分组，将多个字符或表达式组合成一个单元，可以与量词（如*、+、?）结合使用。

示例代码

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

public class RegexBasicsExample {
    public static void main(String[] args) {
        // 使用.来匹配任意单个字符
        String anyCharRegex = ".";
        Pattern anyCharPattern = Pattern.compile(anyCharRegex);
        Matcher anyCharMatcher = anyCharPattern.matcher("Hello World!");

        while (anyCharMatcher.find()) {
            System.out.println(anyCharMatcher.group());
        }

        // 使用*来匹配前面的字符零次或多次
        String zeroOrMoreRegex = "e*";
        Pattern zeroOrMorePattern = Pattern.compile(zeroOrMoreRegex);
        Matcher zeroOrMoreMatcher = zeroOrMorePattern.matcher("hello");

        if (zeroOrMoreMatcher.find()) {
            System.out.println(zeroOrMoreMatcher.group());
        }

        // 使用[]来定义字符集
        String charClassRegex = "[aeiouAEIOU]";
        Pattern charClassPattern = Pattern.compile(charClassRegex);
        Matcher charClassMatcher = charClassPattern.matcher("Hello World!");

        while (charClassMatcher.find()) {
            System.out.println(charClassMatcher.group());
        }

        // 使用()来分组
        String groupRegex = "(Hello|Goodbye)";
        Pattern groupPattern = Pattern.compile(groupRegex);
        Matcher groupMatcher = groupMatcher.matcher("Hello to the World! Goodbye cruel world!");

        while (groupMatcher.find()) {
            System.out.println(groupMatcher.group());
        }
    }
}

在这个示例中，我们展示了如何使用.来匹配任意单个字符，*来匹配前面的字符零次或多次，[]来定义字符集以匹配括号内的任意一个字符，以及()来分组字符或表达式。

2.2 基本语法和规则

正则表达式的语法和规则决定了如何解释正则表达式中的字符。以下是一些基本的语法规则：

• 字面量字符：大多数字符在正则表达式中直接表示其字面量意义。
• 特殊字符转义：如果需要匹配正则表达式中的特殊字符（如*、+、?等），需要在它们前面加上反斜线\进行转义。
• 量词：可以与字符或分组结合使用，表示匹配的次数。例如，a*表示匹配零个或多个a。
• 选择：使用|表示选择，匹配|前后任意一个表达式。
• 锚点：^和$分别表示字符串的开始和结束。

示例代码

public class RegexSyntaxExample {
    public static void main(String[] args) {
        // 使用转义字符匹配特殊字符
        String specialCharRegex = "\\.";
        Pattern specialCharPattern = Pattern.compile(specialCharRegex);
        Matcher specialCharMatcher = specialCharPattern.matcher("End of sentence. And new sentence.");

        if (specialCharMatcher.find()) {
            System.out.println("找到特殊字符: " + specialCharMatcher.group());
        }

        // 使用选择操作符
        String choiceRegex = "hello|hi";
        Pattern choicePattern = Pattern.compile(choiceRegex);
        Matcher choiceMatcher = choicePattern.matcher("hello to the world!");

        if (choiceMatcher.find()) {
            System.out.println("找到匹配项: " + choiceMatcher.group());
        }

        // 使用锚点
        String startWithRegex = "^hello";
        Pattern startWithPattern = Pattern.compile(startWithRegex);
        Matcher startWithMatcher = startWithPattern.matcher("hello world");

        if (startWithMatcher.find()) {
            System.out.println("字符串以'hello'开头: " + startWithMatcher.group());
        }
    }
}

在这个示例中，我们展示了如何使用反斜线\转义特殊字符.，使用选择操作符|来匹配多个选项，以及使用锚点^来匹配字符串的开始位置。

3. Java中使用正则表达式

在Java中，正则表达式的使用主要通过Pattern和Matcher类来实现。这两个类提供了丰富的方法来编译正则表达式、执行匹配操作以及处理匹配结果。

3.1 Pattern和Matcher类

Pattern类负责编译正则表达式，其compile方法可以将一个正则表达式字符串转换成一个Pattern对象。Matcher类则是用于执行具体操作的类，如搜索和替换。

示例代码

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

public class PatternMatcherExample {
    public static void main(String[] args) {
        String text = "This is a test text with some test words.";
        String regex = "test";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

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

        // 使用matches()方法检查整个字符串是否匹配正则表达式
        boolean isMatch = matcher.matches();
        System.out.println("整个字符串是否匹配: " + isMatch);

        // 使用lookingAt()方法检查字符串是否有匹配正则表达式的前缀
        boolean isLookingAt = matcher.lookingAt();
        System.out.println("字符串是否有匹配的前缀: " + isLookingAt);
    }
}

在这个例子中，我们首先通过Pattern.compile编译了一个正则表达式regex，然后创建了一个Matcher对象。接着，我们使用find方法在循环中查找所有匹配项。matches方法用于检查整个字符串是否与正则表达式匹配，而lookingAt方法则检查字符串是否有匹配正则表达式的前缀。

3.2 常用方法和示例

以下是一些Pattern和Matcher类中常用的方法及其示例：

示例代码

public class RegexMethodsExample {
    public static void main(String[] args) {
        String input = "The quick brown fox jumps over the lazy dog";
        String regex = "\\b\\w+\\b"; // 匹配单词边界上的单词

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);

        // 使用find()方法查找并打印所有匹配项
        while (matcher.find()) {
            System.out.println(matcher.group());
        }

        // 使用groupCount()获取捕获组的数量
        int groupCount = matcher.groupCount();
        System.out.println("捕获组的数量: " + groupCount);

        // 使用start()和end()获取匹配项的索引
        if (matcher.find()) {
            int startIndex = matcher.start();
            int endIndex = matcher.end();
            System.out.println("匹配项从索引 " + startIndex + " 到 " + endIndex);
        }

        // 使用region()限制搜索范围
        matcher.region(20, input.length()); // 设置搜索区域为字符串的后半部分
        if (matcher.find()) {
            System.out.println("在限制区域内找到的匹配项: " + matcher.group());
        }

        // 使用replaceFirst()和replaceAll()进行替换操作
        String phoneRegex = "\\d{3}-\\d{3}-\\d{4}";
        String phoneInput = "My phone number is 123-456-7890";
        String replacedPhone = phoneInput.replaceAll(phoneRegex, "****-****-****");
        System.out.println("替换后的电话号码: " + replacedPhone);
    }
}

在这个例子中，我们展示了find、matches、lookingAt、groupCount、start、end和region方法的用法，以及如何使用replaceFirst和replaceAll方法进行字符串替换操作。

4. 高级正则表达式应用

在Java中，除了基础的正则表达式操作，还有一些高级特性可以用于更复杂的文本处理任务。

4.1 分组和捕获

分组是正则表达式中的一个概念，它允许对正则表达式的部分进行分组，并在匹配时捕获这部分内容。分组使用圆括号()来表示。

示例代码

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

public class GroupCaptureExample {
    public static void main(String[] args) {
        String text = "John Doe <john.doe@example.com>";
        String regex = "(\\w+)\\s(\\w+)\\s<(.+)>"; // 分组捕获名字、姓氏和邮箱

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {
            System.out.println("全名: " + matcher.group(0));
            System.out.println("名字: " + matcher.group(1));
            System.out.println("姓氏: " + matcher.group(2));
            System.out.println("邮箱: " + matcher.group(3));
        }
    }
}

在这个例子中，我们使用三个分组来捕获名字、姓氏和邮箱地址。每个分组由圆括号定义，并且我们可以通过matcher.group(n)来获取第n个分组的匹配内容。

4.2 条件和非捕获组

条件和非捕获组允许基于前面的匹配来决定是否匹配某些内容。非捕获组使用(?:...)来表示，它与普通分组类似，但不会捕获匹配的文本。

示例代码

public class NonCaptureGroupExample {
    public static void main(String[] args) {
        String text = "The cat is black, and the dog is brown.";
        String regex = "(?:the\\s)?(\\w+)\\s(is\\s)?(\\w+)\\."; // 匹配"The cat is black."或"cat is brown."

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("找到匹配项: " + matcher.group(0));
        }
    }
}

在这个例子中，我们使用非捕获组(?:the\s)?来匹配可能存在的"the "，但这部分不会作为捕获组返回。

4.3 正向前瞻和正向回顾

正向前瞻（Positive Lookahead）和正向回顾（Positive Lookbehind）是正则表达式中的零消耗断言，它们允许你在一个不被消耗的位置（即匹配过程中不会移动位置）检查匹配条件。

示例代码

public class LookaheadLookbehindExample {
    public static void main(String[] args) {
        String text = "I have 2 apples, and he has 5 oranges.";
        String regexWithLookahead = "(\\d+)(?=\\sapples)"; // 匹配苹果前面的数字
        String regexWithLookbehind = "(?<=\\d+\\s)oranges"; // 匹配在数字和空格后的"oranges"

        Pattern patternWithLookahead = Pattern.compile(regexWithLookahead);
        Matcher matcherWithLookahead = patternWithLookahead.matcher(text);

        Pattern patternWithLookbehind = Pattern.compile(regexWithLookbehind);
        Matcher matcherWithLookbehind = patternWithLookbehind.matcher(text);

        // 正向前瞻
        if (matcherWithLookahead.find()) {
            System.out.println("使用正向前瞻匹配的数字: " + matcherWithLookahead.group(1));
        }

        // 正向回顾
        if (matcherWithLookbehind.find()) {
            System.out.println("使用正向回顾匹配的单词: " + matcherWithLookbehind.group(1));
        }
    }
}

在这个例子中，我们使用正向前瞻来匹配"apples"前面的数字，使用正向回顾来匹配在数字和空格后的"oranges"。

5. 实际应用案例分析

在实际的软件开发中，正则表达式被广泛应用于各种场景，包括文本验证、数据清洗、网络爬虫和日志分析等。以下是几个实际应用案例的分析，以及相应的Java代码示例。

5.1 文本验证和搜索

在用户输入验证、搜索查询优化等场景中，正则表达式可以用来验证输入是否符合特定的格式要求，或者从一段文本中搜索特定的模式。

示例代码

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

public class TextValidationExample {
    public static void main(String[] args) {
        String input = "user@example.com";
        String emailRegex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*" +
                            "@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";

        Pattern pattern = Pattern.compile(emailRegex);
        Matcher matcher = pattern.matcher(input);

        boolean isValid = matcher.matches();
        System.out.println("输入是否为有效的邮箱地址: " + isValid);
    }
}

在这个例子中，我们使用一个正则表达式来验证一个字符串是否符合电子邮件地址的常见格式。

5.2 数据清洗和格式化

在数据清洗过程中，正则表达式可以用来移除或替换数据中的噪声和不一致性，确保数据的整洁和统一。

示例代码

public class DataCleaningExample {
    public static void main(String[] args) {
        String rawText = "John Doe: 123-45-6789";
        String cleanedText = rawText.replaceAll("[^\\w\\s]", " ").trim(); // 移除非字母和非空格字符

        System.out.println("清洗后的文本: " + cleanedText);
    }
}

在这个例子中，我们使用replaceAll方法和正则表达式[^\\w\\s]来移除字符串中的所有非字母和非空格字符。

5.3 网络爬虫和日志分析

在网络爬虫开发和日志分析中，正则表达式可以用来从网页内容或日志文件中提取有用的信息。

示例代码

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

public class WebCrawlingExample {
    public static void main(String[] args) {
        String htmlContent = "<div class='title'>Page Title</div>" +
                             "<div class='summary'>This is a summary of the page.</div>";
        String titleRegex = "<div class='title'>(.*?)</div>"; // 使用非贪婪匹配
        String summaryRegex = "<div class='summary'>(.*?)</div>";

        Pattern titlePattern = Pattern.compile(titleRegex);
        Pattern summaryPattern = Pattern.compile(summaryRegex);

        Matcher titleMatcher = titlePattern.matcher(htmlContent);
        Matcher summaryMatcher = summaryPattern.matcher(htmlContent);

        if (titleMatcher.find()) {
            System.out.println("页面标题: " + titleMatcher.group(1));
        }

        if (summaryMatcher.find()) {
            System.out.println("页面摘要: " + summaryMatcher.group(1));
        }
    }
}

在这个例子中，我们使用正则表达式来从HTML内容中提取页面标题和摘要。

通过这些实际应用案例，我们可以看到正则表达式在处理字符串和文本数据时的强大能力。掌握正则表达式对于任何Java开发者来说都是一项非常有用的技能。