Java中的正则表达式_java 正则表达式^.*-CSDN博客

本文详细介绍了Java中的正则表达式，包括相关API的使用、正则表达式的语法以及实例演示。讲解了元字符、限定符、选择匹配符、特殊字符、定位符、分组组合符等内容，并通过代码示例展示了贪婪匹配与非贪婪匹配的区别。此外，还提到了PatternSyntaxException类在处理正则表达式错误时的作用。

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

其实万变不离其宗，你要去学会掌握方法，然后去一个个自己去测试然后转化成自己所熟知的东西，我也是一个java的学习者，我们一起加油哦，好了不讲鸡汤了，开始我们要讲的正则表达式吧。

Java中的正则表达式

正则表达式
Java中的相关API
正则表达式语法

正则表达式（regular expression）：描述了一种字符串匹配的模式

正则表达式作为一个模板，与所搜索的字符串进行匹配。

常用于：字符串的匹配、查找、替换、分割等。

正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。
正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

正则表达式实例

一个字符串其实就是一个简单的正则表达式，例如 **Hello World** 正则表达式匹配 "Hello World" 字符串。

**.**（点号）也是一个正则表达式，它匹配任何一个字符如："a" 或 "1"。

java.util.regex 包提供了相关类

Pattern：模式类。正则表达式的编译表示形式
Matcher：匹配器。用于匹配字符序列与正则表达式模式的类
PatternSyntaxException：正则表达式模式中放入语法错误

String 类中与正则相关的方法

public boolean matches(String regex);告知此字符是否匹配给定的正则表达式
String[] split(String regex);根据给定正则表达式的匹配拆分此字符串
String replaceAll(String regex,String replacement);使用给定的replacement 替换此字符串所有匹配=给定的正则表达式的子字符串

Pattern类常用的方法

public static Pattern complie(String regex)

将给定的正则表达式编译到模式中
public static Pattern compile (String regex, in flags)

将给定的正则表达式编译到具有给定标志的模式中

flags: 参数表示匹配时的选项，常用的flags参数值有：
1. CASE_INSENSITIVE:启用不区分大小写的匹配。
2. COMMENTS:模式中允许空白和注释。
3. MULTILINE: 启用多行模式
public Macher matcher(CharSequence input)

生成一个给定命名的Matcher对象
static boolean matches(String regex, CharSequence input)

直接判断字符序列input是否匹配正则表达式regex。

该方法适合于正则表达式中只会使用一次的情况

Matcher类常用的方法

pulic boolean matches()

尝试将整个输入序列与该模式匹配。(开头到结尾)
public boolean find()

扫描输入序列以查找与该模式匹配的下一个子序列
public String replaceAll(String replacement)

替换模式与给定替换字符串相匹配的输入序列的每个子序列
public String replaceFirst(String replacement)

替换模式与给定替换字符串相匹配的输入序列的第一个序列

正则表达式的语法：

正则表达式的模式串：是由普通字符（如字符a到z）以及一些特殊字符（称为元字符）组成
元字符从功能上分为：限定符、选择匹配符、特殊字符、字符匹配符、定位符、分组组合符、反向引用符。

看完下面的这些你一定会掌握正则表达式：

下面的方法自己一点要去多敲跟多练然后自己想想总结归纳成自己的

我给你们写的只有方法，代码需要你们自己在自己电脑上IDE工具里面去测试，自己写一个main方法然后去调用我写的方法就ok了。

元字符-- 限定符限制某个字符出现的次数

*  所修饰的字符出现0-n次
+  所修饰的字符出现1-n次
?  所修饰的字符出现0-1次   可以修饰贪婪匹配变成非贪婪匹配
{x,y}  所修饰的字符出现的次数 最小x次，最大y次
{x,}   所修饰的字符出现次数 最小x次 最大不限

实例：

public static void test2(String str){
    Matcher m = Pattern.compile("a{0,8}bc").matcher(str);
    System.out.println(m.matches());
}

public  static void test(String str){
    Pattern pn =Pattern.compile("abc");
    Matcher m=pn.matcher(str);
    boolean b=m.find();
    System.out.println("是否存在abc==="+b);
    String s=null;
    while ("abc".equals(s==m.group())){
        System.out.println("返回匹配内容："+s);
    }
}

然后我们讲一下贪婪匹配和非贪婪匹配

贪婪匹配：在满足模式串的前提下  能够尽量多的去匹配符合模式的字符  （默认）
非贪婪匹配： ？在满足模式的前提下  尽量少的去匹配符合模式串的字符  将？紧跟限定符后

注意：贪婪和非贪婪只能匹配最后一个字符

实例：

//贪婪匹配
 public static void test3(){
        String str ="aaaaaa";
        Matcher m = Pattern.compile("a+").matcher(str);
        if(m.find()){
            System.out.println(m.group());
        }
    }
//运行结果为：aaaaaa

//非贪婪匹配
public static void test3(){
        String str ="aaaaaa";
        Matcher m = Pattern.compile("a+?").matcher(str);
        if(m.find()){
            System.out.println(m.group());
        }
    }
//运行结果：a

看完这两个实例相信你们一定会掌握贪婪和非贪婪匹配啦

3.元字符 – 选择匹配符 |

表示 | 符号两端的内容时 or 的关系
只能关联其左右两端的一个字符串

实例：

public static void test4(){
        String str = "qava";
        Pattern p = Pattern.compile("(q|j)ava");
        Pattern p1 = Pattern.compile("q|java");
        System.out.println(p.matcher(str).matches());
        System.out.println(p1.matcher(str).matches());
    }
//运行结果
true
false
一定要明白|两端的是字符串不要混淆了，因为第一个输出 true 是因为我给它加了个()也就是组，所以能匹配到qava这个字符串。
 第二个输出是它找到了"q"和"java"这两个字符串，所有就没有找到和"qava"这个字符串一样，所以输出就为 false5

4.元字符 – 特殊字符

ASCII 可以使用  使用十六进制  \x65
    Unicode \u0062
    校验当前字符串中出现汉字 \u4e00 - \u9f5a
    元字符转译 成普通字符 \? \. \* \+  后期可以由其他方式进行转换

实例：

public static void test5(){
        // \x62 -- b
        String str = "你好?";
        Matcher m = Pattern.compile("你好\\?").matcher(str);
        System.out.println(m.matches());
    }
//运行结果
true

5.元字符 — 字符匹配符（需要获取某个字符或者某个范围内容）

[a] -- a这个字符
[a-z]  某一个字符的内容区间
一个[]只能对应一个字符位
[^a-z] 获取当前区间的补集
写在[] 中的元字符  都会当次普通字符来使用
.   匹配所有字符  除了 \n
\d  数字
\D  所有非数字内容
匹配所有内容 [\d\D] [\s\S]

实例：

  public static void test6(){
        String str = "nlh+_";
        Matcher m = Pattern.compile("\\D+").matcher(str);
        System.out.println(m.matches());
    }
//运行结果
true

6.元字符 – 定位符（限定字符出现的位置）

^ 指定当前的起始位置  出现在单词的开始位置
$ 指定当前匹配的结束位置  出现在字符的最后一位
\b  指定当前字符出现在单词的边际处 \b(or)\b
\B  指定当前字符出现在非单词边际处 \B(or)\B

实例：

public static void test7(){
        String str = "Hellor World";
        Pattern p = Pattern.compile("^abc+$");
        //matches  默认就是从头至尾进行完全匹配
        System.out.println(p.matcher(str).find());
    }
//运行结果
false

7.元字符 – 分组符

所有的元字符修饰的都是单个字符  如果想匹配成组出现的单词  则必须使用分组符来进行限定
abcabcabcabc  (abc)+
分组的内容可以看做一个单独的不可拆分的整体
（） 捕获性分组   将当前分组的内容 会存储在一个临时缓存中  后期可以直接使用该缓存的内容
(?)  非捕获性分组 只进行内容分组 不进行内容缓存
(?:)
(?=)
捕获性分组中的内容 可以通过\n  n表示组的序号  序号从1开始
分组的序号 是看左括号出现的顺序

实例：

public static void test8(){
        String str = "abcdef123helloabcdef123";
        Matcher m = Pattern.compile("((abc(def(123)))hello)\\2").matcher(str);
        System.out.println(m.matches());

    }
//运行结果
true

8.反向引用符 — 和捕获性分组结合使用

在完成正则模式串分组之后  可以通过反向引用符来获取 捕获性分组中的内容
$组号

实例：

public static void test9(){
        //重复去重问题
        String str = "你你你你好呀，我我我我要要买一碗面面面面条";

        Matcher m = Pattern.compile("(.)\\1+").matcher(str);
        String s = m.replaceAll("$1");
        System.out.println(s);
    }
//运行结果
你好呀，我要买一碗面条

最后：再来说一下PatternSyntaxException 类的方法

PatternSyntaxException 是一个非强制异常类，它指示一个正则表达式模式中的语法错误。
PatternSyntaxException 类提供了下面的方法来帮助我们查看发生了什么错误。

序号	方法及说明
1	public String getDescription() 获取错误的描述。
2	public int getIndex() 获取错误的索引。
3	public String getPattern() 获取错误的正则表达式模式。
4	public String getMessage() 返回多行字符串，包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示。