Java正则表达式

最新推荐文章于 2024-07-20 17:30:10 发布
最新推荐文章于 2024-07-20 17:30:10 发布
阅读量455 收藏
点赞数
分类专栏： # Java基础 文章标签： 正则表达式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013028621/article/details/78704123
版权

一、普通字符

普通字符包括以下类别：
1. a-z A-Z 0-9 !#@~等 非特殊含义字符
2. 反斜杠 \:第一个斜杠表示转义，第二个斜杠才是表示”\”字符,由于在java中表示”\”也需要转义，所以在java中是用正则表达式表示一个”\”需要写成”\\”
3. \t 制表符:由于”\t”在java中也表示制表符，所以可以直接使用”\t”,而使用”\t”的时候其中一个”\”代表转义,剩下来的”\t”在正则中正好表示制表符所以它们的效果一样
4. \n 换行符:同上
5. \f 换页符:同上
例子程序：

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * @GITHUB: https://github.com/sahooz
 * @CSDN: http://blog.csdn.net/u013028621
 */
public class NormalCharacter {
    private static final String TARGET = "abcdefgHIJKLMN0123456789!#@~\\\t\n\f";

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }

    /**
     * 测试第三类
     */
    private static void test3() {
        System.out.println("斜杠t的匹配结果:");
        Pattern pattern = Pattern.compile("\t");
        Matcher matcher = pattern.matcher(TARGET);
        System.out.println(matcher.find());
        System.out.println("双斜杠t的匹配结果:");
        pattern = Pattern.compile("\\t");
        matcher = pattern.matcher(TARGET);
        System.out.println(matcher.find());
    }
    /**
     * 测试第二类:"\"
     */
    private static void test2() {
        try {
            System.out.println("双斜杠的匹配结果:");
            Pattern pattern = Pattern.compile("\\"); //会报错,因为经过java转义表示正则里的"\",而正则里的"\"不能单独使用
            Matcher matcher = pattern.matcher(TARGET);
            if(matcher.find())
                System.out.println(matcher.group());
        } catch (Exception e) {
            System.out.println("抛出异常！！");
        }
        System.out.println("四斜杠的匹配结果:");
        Pattern pattern = Pattern.compile("\\\\"); 
        Matcher matcher = pattern.matcher(TARGET);
        if(matcher.find())
            System.out.println(matcher.group());
    }
    /**
     * 测试第一类
     */
    private static void test1() {
        char[] charArray = TARGET.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char c = charArray[i];
            if(c != '\\' && c != '\t' && c != '\n' && c != '\f') {
                Pattern pattern = Pattern.compile(c + "");
                Matcher matcher = pattern.matcher(TARGET);
                if(matcher.find())
                    System.out.print(matcher.group());
            }
        }
        System.out.println();
    }
}

运行结果：
这里写图片描述

二、字符类

字符类相对于普通字符的区别是，它表示的是满足特定条件的一类字符中的一个,主要有以下类别:
1.[abc]: a、b 或 c（简单类）
2.[^abc]: 任何字符，除了 a、b 或 c（否定）
3.[a-zA-Z]: a 到 z 或 A 到 Z，两头的字母包括在内（范围）
4.[a-d[m-p]]: a 到 d 或 m 到 p：[a-dm-p]（并集）
5.[a-z&&[def]]: d、e 或 f（交集）
6.[a-z&&[^bc]]: a 到 z，除了 b 和 c：[ad-z]（减去）
7.[a-z&&[^m-p]]: a 到 z，而非 m 到 p：[a-lq-z]（减去） 

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** 
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class CharacterClasses {
    private static final String TARGET = "abcdefgHIJKLMN0123456789!#@~.";

    public static void main(String[] args) {
        System.out.print("所有属于IJK之中某一个的字符:");
        print("[IJK]");
        System.out.print("所有不属于IJK之中某一个的字符:");
        print("[^IJK]");
        System.out.print("所有属于b到g之中某一个的字符:");
        print("[b-g]");
        System.out.print("所有属于b到g或K到N之中某一个的字符:");
        print("[b-g[K-N]]");
        System.out.print("所有属于b到g或K到N之中某一个的字符:");
        print("[b-gK-N]");
        System.out.print("所有属于b到g且属于e到z之中某一个的字符:");
        print("[b-g&&e-z]");
        System.out.print("所有属于b到g且不属于e到z之中某一个的字符:");
        print("[b-g&&[^e-z]]");
    }
    private static void print(String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(TARGET);
        while(matcher.find())
            System.out.print(matcher.group());
        System.out.println();
    }
}

运行结果:
这里写图片描述

三、预定义字符类

特殊字符有:
1). 通配符，可以表示除换行符以外任意字符(换行符可能匹配，可能不匹配),匹配”.”本身需要使用”.”,
由于在java中”\”需要转义，所以写成”\.”,下同
2)\d 数字字符，[0-9]
3)\D 非数字字符，[^0-9]
4)\w 单词字符，[a-zA-Z_0-9]
5)\W 非单词字符，[^a-zA-Z_0-9]
6)\s 空白字符：[\t\n\x0B\f\r]
7)\S 非空白字符：[^\s]
例子程序:

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class SpecialCharacter {
    private static final String TARGET = "abcdefgHIJKLMN0123456789!#@~.^_\\s\\S\\w\\W\\d\\D\t\n";

    public static void main(String[] args) {
        System.out.println("目标字符串: " + TARGET);
        System.out.print("与通配符.匹配的所有字符:");
        print(".");
        System.out.print("匹配.字符本身:");
        print("\\.");
        System.out.print("匹配所有数字字符:");
        print("\\d");
        System.out.print("匹配所有非数字字符:");
        print("\\D");
        System.out.print("匹配所有单词字符:");
        print("\\w");
        System.out.print("匹配所有非单词字符:");
        print("\\W");
        System.out.print("匹配所有的字符:");
        print("[\\w\\W]");//同理可以使用"[\\s\\S]"
    }

    private static void print(String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(TARGET);
        while(matcher.find())
            System.out.print(matcher.group());
        System.out.println();
    }
}

运行结果：
这里写图片描述
其中空白处其实包含了换行符制表符等。

四、匹配模式与边界匹配器

匹配模式:
1.单行模式(DOTALL): 整个文本视为一个字符串(一行),.能匹配所有字符的模式
2.多行模式(MULTILINE): 整个文本视为以换行符分隔的多行文本
3.大小写敏感模式: 大小写字母视为不一样的字符,比如a不能匹配到A
4.大小写不敏感模式(CASE_INSENSITIVE): 大小写字母视为一样的字符,比如a能匹配到A
默认模式为单行大小写敏感
边界匹配器:不代表任何字符，只表示目标字符(字符串)应该符合某个位置条件
1.^ 行的开头,单行模式下类似于\A
2.$ 行的结尾 ,单行模式下类似于\Z
3.\b 单词边界,也就是单词开始或结束的位置
4.\B 非单词边界,非\b位置
5.\A 输入的开头 ,无论单行多行模式
6.\Z 输入的结尾
例子程序:

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class BoundaryMatchers {

    private static final String TARGET = "Weak mind.\n" +
            "Weak willpower.\n" +
            "What is next?\n" +
            "You cannot positively influence your life when you are not emotionally strong. Strength comes from within.\n" +
            "Regardless of who your parents are and how much your husband earns, you cannot be a strong woman until you learn how to manage your emotions\n";
    public static void main(String[] args) {
        System.out.print("单行模式下^W(位于行开始位置的所有\"W\"字符)匹配的所有字符:");
        print("^W", Pattern.DOTALL);
        System.out.print("多行模式下^W(位于行开始位置的所有\"W\"字符)匹配的所有字符:");
        print("^W", Pattern.MULTILINE);
        System.out.print("多行模式下.$(位于行结束位置的所有字符)匹配的所有字符:");
        print(".$", Pattern.MULTILINE);
        System.out.print("多行模式下\\A.(整个输入的第一个能被\".\"匹配的字符)匹配的所有字符:");
        print("\\AW", Pattern.MULTILINE);
        System.out.print("单行模式下\\A.(整个输入的第一个能被\".\"匹配的字符)匹配的所有字符:");
        print("\\AW", Pattern.DOTALL);
        System.out.print(".\\Z(整个输入的结尾)匹配的所有字符:");
        print(".\\Z", 0/*默认*/);
        System.out.print(".\\b(位于单词边界的前一个字母)匹配的所有字符:");
        print("[a-zA-Z]\\b", 0);        
    }

    private static void print(String regex, int mode) {
        Pattern pattern = Pattern.compile(regex, mode);
        Matcher matcher = pattern.matcher(TARGET);
        while(matcher.find())
            System.out.print(matcher.group());
        System.out.println();
    }
}

运行结果：
这里写图片描述

五、量词与匹配模式

量词与匹配模式(贪婪模式、勉强模式)
贪婪模式: 趋向于最大长度匹配
勉强模式: 趋向于最小长度匹配
贪婪模式量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
勉强模式量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n 次
X{n,}? X，至少 n 次
X{n,m}? X，至少 n 次，但是不超过 m 次
例子程序:

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class Quantifiers {
    private static final String TARGET = "abcdefgHIJKLMN0123456789!#@~.";

    public static void main(String[] args) {
        System.out.println("贪婪模式下[a-zA-Z]{3,5}的匹配结果(所有由3到5个字母组成的子序列):");
        print("[a-zA-Z]{3,5}");
        System.out.println("勉强模式下[a-zA-Z]{3,5}的匹配结果(所有由3到5个字母组成的子序列):");
        print("[a-zA-Z]{3,5}?");
    }
    private static void print(String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(TARGET);
        while(matcher.find())
            System.out.println(matcher.group());
    }
}

运行结果：
这里写图片描述
可以看到，贪婪模式下每次匹配都是尽量选择满足条件的最长的子序列，在不够的情况下，才会匹配较短的序列；在勉强匹配下，匹配的是满足条件的最短的子序列。

六、捕获组

捕获组：用小括号括起来的一个匹配规则为一个捕获组，例如([a-z][0-9])+表示由一个或以上”a到z之间的字母与0到9之间的数字组合”组成的子序列。捕获组按照左边的小括号从1开始进行排序，每个捕获组最后一个匹配结果可以通过Matcher.group(int),没有匹配的时候返回的是null.0代表正则表达式整体的匹配结果，与Matcher.group()等效.
例子程序：

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class CaptureGroup {

    private static final String TARGET = "a0b1c2d3aabbccdde4f5";

    public static void main(String[] args) {

        //下面只有一个捕获组
        Pattern p = Pattern.compile("([a-z][0-9])+[a-z]{2}");
        Matcher m = p.matcher(TARGET);
        while(m.find()){
            for(int i = 0; i<= m.groupCount(); i++)
                System.out.println(m.group(i));
        }
        System.out.println("=======分割线=======");
        //看起好像一样，但是下面是两个捕获组
        p = Pattern.compile("([a-z][0-9])+([a-z]){2}");
        m = p.matcher(TARGET);
        while(m.find()){
            for(int i = 0; i<= m.groupCount(); i++)
                System.out.println(m.group(i));
        }
    }
}

运行结果：
这里写图片描述

七、非捕获组

非捕获组，用于正则表达式匹配规则但不计入最终匹配结果
1.(?=X ) 零宽度正先行断言。仅当子表达式 X在此位置的右侧匹配时才继续匹配。例如，\w+(?=A)表示位于A前面的由一个以上单词字符组成的子序列，但不包括后面的这个A
2.(?!X) 零宽度负先行断言。仅当子表达式 X不在此位置的右侧匹配时才继续匹配。例如，例如，\w+(?!\A)表示不位于A前面的由一个以上单词字符组成的子序列，但不包括后面的这个A
3.(?<=X) 零宽度正后发断言。仅当子表达式 X在此位置的左侧匹配时才继续匹配。例如，(?<=A)99 与跟在 A后面的99的实例匹配
4.(?

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class NonCapturing {
    private static final String TARGET = "abcdAabcd$99A99";

    public static void main(String[] args) {
        System.out.println("位于A前面的由一个以上单词字符组成的子序列");
        print("\\w+(?=A)");
        System.out.println("不位于A前面的由两个以上字母组成的子序列");
        print("[a-zA-Z]{2,}(?!=A)");
        System.out.println("跟在 A后面的99");
        print("(?<=A)99");
        System.out.println("不跟在 A后面的99");
        print("(?<!A)99");
    }

    private static void print(String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(TARGET);
        while(matcher.find())
            System.out.print(matcher.group());
        System.out.println();
    }
}

运行结果：
这里写图片描述

八、反向引用

反向引用: 引用前一个捕获组的匹配结果，形式为\x，x代表捕获组的序号，比如([a-z])\1表示相同的两个小写字母组成的子序列，比如aa,bb,cc等
例子程序

package com.sahooz.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author sahooz
 * github: https://github.com/sahooz
 * CSDN: http://blog.csdn.net/u013028621
 */
public class BackReferences {

    private static final String TARGET = "aabbccdd";

    public static void main(String[] args) {
        print("([a-z])\\1");
    }

    private static void print(String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(TARGET);
        while(matcher.find())
            System.out.println(matcher.group());
    }
}

运行结果：
这里写图片描述

代码

github： https://github.com/sahooz/JavaRegexDemo
CSDN: http://download.csdn.net/download/u013028621/10143506

吹白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的正则表达式
yhb500234的博客
08-26 401
本文简单总结了Java中关于正则表达式的相关内容，需要匹配一些特定字符串和内容时可以高效的利用正则表达式，相关语法需要记忆和多加练习才能更加熟练
java 正则表达式
wanderlustLee的博客
02-26 308
\d 表示匹配一位数字，在java中\表示转义字符，但正则表达式中需要的是\d这个字符，所以需要再加一个\，用\\d来表示。 System.out.println("1".matches("\\d"));//true 中括号[]代表范围，大括号{}代表出现的次数。 [a-z]表示匹配小写字母a到z中的一个字母。 [a-z]{3}表示匹配3个a到z的字母。 System.out.print...
正则表达式[\f\n\r\t\v\s\S...]
9.歌工作室
01-04 5389
等价于 [ \f\n\r\t\v]。\w :表示任意一个单词字符,等同于[a-zA-Z0-9_]–单词指字母/数字/_。\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。\f 匹配一个换页符。等价于 \x0c 和 \cL。\n 匹配一个换行符。等价于 \x0a 和 \cJ。\r 匹配一个回车符。等价于 \x0d 和 \cM。\t 匹配一个制表符。等价于 \x09 和 \cI。\d :表示任意一个数字,等同于[0-9]。
正则表达式的语法
静Yu的博客
02-01 3万+
正则表达式语法简介  正则表达式是独立于任何语言的，虽然不同的 语言中其语法略有不同。  正则表达式的语法可以分为 • 特殊字符 • 边界匹配符 • 逻辑操作符 • 量词等  这些基本的语法规则合成使用，共同构成了正 则表达式强大的表示和匹配功能  一般字符的语法在前一节已经介绍过（例如字符i） 特殊字符的表达  例如，如果我们要查找一个字符串，这个字符 串中至少包含两行（两行可以不相邻），前面 一行中存在两个制表符，它们中间仅仅隔一数 字，后面一行中至少有一个制表符，则正则表 达式可以这样写：
正则表达式
单远涛
06-07 549
简介 正则表达式一种专门用来搜索字符串的方式，通过构建不同的模式，从而在字符串中匹配出自己想要的字符 正则表达式可以在很多种语言中使用，这些语言也专门为正则表达式的使用，提供了不同的语言支持，具体使用详情，请在菜鸟教程中查看 写正则表达式的时候，总是感觉无从下手，不知道什么时候加个正斜杠什么时候加个反斜杠，或者加个r 是干什么的，我相信看完下面你就肯定清楚了 正则表达式中的字母和数...
正则表达式基本知识
qq_27474555的博客
09-18 255
1、正则表达式 正则表达式是由普通字符和特殊字符组成的文字模式；它用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。2、普通字符 普通字符包括没显式指定为元字符的所有可打印和不可打印字符，这包括所有大写和小写字母、所有数字、所有标点符号和一些其它符号； 非打印字符可以是正则表达式的组成部分，下面为非打印字符的转义序列 \cx 匹配由x指明的控制...
java正则表达式验证函数
09-06
Java正则表达式验证函数是Java编程中用于检查字符串是否符合特定模式的一种工具。在Java中，正则表达式（Regular Expression）是一种强大的文本处理工具，可以用来匹配、查找、替换等多种操作。这个函数的目的是简化...
java正则表达式.zip
08-21
Java正则表达式是Java编程语言中用于处理字符串的强大工具，它基于模式匹配的概念，能够高效地进行文本搜索、替换和解析。在Java中，正则表达式主要通过`java.util.regex`包来实现，提供了Pattern和Matcher两个核心...
Java正则表达式验证固定电话号码符合性
08-26
Java正则表达式验证固定电话号码符合性 Java正则表达式验证固定电话号码符合性是验证固定电话号码是否合法的重要步骤。通过使用Java正则表达式，可以实现固定电话号码的验证，确保输入的电话号码符合标准格式。本文...
java正则表达式验证
08-11
java使用正则表达式进行校验验证，主要使用了Pattern和Matcher类，直接main方法运行就可以,亲测有效
java正则表达式匹配网页所有网址和链接文字的示例
09-04
在Java编程中，正则表达式是处理文本模式匹配的强大工具，尤其在处理网页内容时，如提取网址和链接文字。这个示例展示了如何使用Java的正则表达式来匹配网页中的所有网址和链接文字。下面将详细讲解相关知识点。 1....
正则表达式详解
qq_52066954的博客
03-07 5165
【1】为什么需要正则表达式(regular expresssion)？ 针对于复杂文本的处理 【2】正则表达式的优势和用途 正则表达式是一种强大而灵活的文本处理工具，适用于大部分编程语言、数据库、文本编辑器、开发环境等 【3】正则表达式的定义 正则表达式定义文本的规则，可以通过该规则判断什么字符串符合规则 【4】开发中使用正则表达式的流程 1.分析所要匹配的数据，写出测试用的典型数据 2.在工具软件中进行匹配测试 3.在程序中调用通过测试了的正则表达式 【5】正则表达式测试工具R
正则表达式(全)
热门推荐
a_b_e_l_的博客
08-09 24万+
通过上面几个简单的示例，可以了解到常见的基础正则表达式的元字符主要包括以下几个^ 匹配输入字符串的开始位置。除非在方括号表达式中使用，表示不包含该字符集合。要匹配”^”字符本身，请使用"\^"$ 匹配输入字符串的结尾位置。如果设置了RegExp对象的 Multiline属性，则"$”也匹配'\n'或'\r’,。要匹配”$"字符本身，请使用”\$". 匹配除"\r\n"之外的任何单个字符\ 反斜杠，又叫转义字符，去除其后紧跟的元字符或通配符的特殊意义* 匹配前面的子表达式零次或多次。...
正则表达式：\
JEFF_xieyuzhi的博客
10-07 361
正则表达式： 转义字符‘\’ \n ：换行 \r ：行结束 \t ：制表符 要匹配 . ，请使用 \. <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title...
js 正则表达式 regexp \ \n \t \r [] ^ () \s \S \b \B \w \W \d \D 常用正则表达式
weixin_42448623的博客
10-30 7319
正则表达式 的作用 匹配特殊字符或有特殊搭配原则的字符的最佳选择 方法 reg.test(); 判断有没有匹配片段 str.match(); 字符串内检索指定的值 并返回 两种创建方式 直接量(推荐) new ReExp(); var reg = /abc/i;//直接量创建 i 忽视大小写 var reg = new RegExp('abc','i');// var str = 'abcd'; ...
java正则 t_Java中的正则表达式\ t元字符
weixin_39774556的博客
02-28 706
子表达式/元字符“ \ t ”与制表符空间匹配。例子1importjava.util.Scanner;importjava.util.regex.Matcher;importjava.util.regex.Pattern;publicclassRegexExample{publicstaticvoidmain(Stringargs[]){Stringregex="\...
正则表达式的个性化定制：在Perl中实现自定义操作符
最新发布
2401_85342379的博客
07-20 289
Perl语言以其强大的文本处理能力而闻名，其中正则表达式是其核心特性之一。除了Perl内置的正则表达式操作符，开发者还可以自定义正则表达式操作符来扩展其功能。本文将详细介绍如何在Perl中实现自定义的正则表达式操作符，并提供实际的代码示例。在Perl中，正则表达式操作符用于执行模式匹配和相关操作。=~：匹配操作符，用于标量上下文中的正则表达式匹配。：尝试匹配模式，如果匹配成功，则返回真（true）。m/pattern/：与=~相同，但可用于标量或列表上下文。
Java正则表达式完全指南
"Java正则表达式学习手册，介绍了正则表达式的概念、规则和简单转义字符的应用。" 在Java中，正则表达式是一种强大的文本处理工具，用于匹配、查找、替换字符串中的特定模式。这篇学习手册旨在帮助读者理解和掌握...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值