正则表达式-java

最新推荐文章于 2024-07-27 13:31:57 发布

ZjfScorpio

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量190

点赞数

分类专栏：面试 javase 文章标签： java 正则表达式 Reg

本文链接：https://blog.csdn.net/zjfahs/article/details/90137493

版权

面试同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

javase

4 篇文章 0 订阅

订阅专栏

1 什么是正则表达式？

正则表达式（Regular Expression）是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

2 用来干什么？

在写程序的过程中，有时会需要匹配、查找、替换或者是判断字符串的出现情况，而且有时不能用简单的纯编码方式解决这些问题，这个时候就会想到要正则表达式，无论是Java， PHH, C#, Python, JavaScript, ActionScript, Perl等语言，都提高了强大的正则表达式支持。

3 怎样使用？

3.1前驱知识

3.1.1三个类

正则表达式java.util.regex 包主要包括以下三个类：

Pattern 类：
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
PatternSyntaxException：
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

3.1.2捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，“o”，和"g"。

捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

((A)(B(C)))
(A)
(B(C))
(C)

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。
还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

3.1.2.1举例

不使用捕获组

import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
  
public class PatternTest {  
  
    public static void main(String[] args) {  
        String text = "<textarea rows=\"20\" cols=\"70\">nexus maven repository index properties updating index central</textarea>";  
        String reg = "<textarea.*?>.*?</textarea>";  
        Pattern p = Pattern.compile(reg);  
        Matcher m = p.matcher(text);  
        while (m.find()) {  
            System.out.println(m.group());  
        }  
    }  
  
}

运行结果：

<textarea rows="20" cols="70">nexus maven repository index properties updating index central</textarea>

使用捕获组

import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
  
public class PatternTest {  
  
    public static void main(String[] args) {  
        String text = "<textarea rows=\"20\" cols=\"70\">nexus maven repository index properties updating index central</textarea>";  
        //下面的正则表达式中共有四个捕获组：(<textarea.*?>)、(.*?)、(</textarea>)和整个匹配到的内容  
        String reg = "(<textarea.*?>)(.*?)(</textarea>)";    
        Pattern p = Pattern.compile(reg);  
        Matcher m = p.matcher(text);  
        while (m.find()) {  
            System.out.println(m.group(0)); // 整个匹配到的内容  
            System.out.println(m.group(1)); // (<textarea.*?>)  
            System.out.println(m.group(2)); // (.*?)  
            System.out.println(m.group(3)); // (</textarea>)  
        }  
    }  
}

运行结果：

<textarea rows="20" cols="70">nexus maven repository index properties updating index central</textarea>  
<textarea rows="20" cols="70">  
nexus maven repository index properties updating index central  
</textarea>

结论：
从上述代码得出结论：正则表达式中每个"()"内的部分算作一个捕获组，每个捕获组都有一个编号，从1,2…，编号0代表整个匹配到的内容。

至于非捕获组，只需要将捕获组中()变为(?:)即可，代码说话：

import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
  
public class PatternTest {  
  
    public static void main(String[] args) {  
        String text = "<textarea rows=\"20\" cols=\"70\">nexus maven repository index properties updating index central</textarea>";  
        // 下面的正则表达式中共有二个捕获组：(.*?)和整个匹配到的内容，两个非捕获组:(?:</textarea>)和(?:<textarea.*?>)  
        String reg = "(?:<textarea.*?>)(.*?)(?:</textarea>)";  
        Pattern p = Pattern.compile(reg);  
        Matcher m = p.matcher(text);  
        while (m.find()) {  
            System.out.println(m.group(0)); // 整个匹配到的内容  
            System.out.println(m.group(1)); // (.*?)  
        }  
    }  
}

运行结果：

<textarea rows="20" cols="70">nexus maven repository index properties updating index central</textarea>  
nexus maven repository index properties updating index central

说明：如果试图运行：System.out.println(m.group(2));将会抛出异常，因为不存在编号为2的捕获组。

3.2使用

3.2.1简单例子

需求：从字符串：{"_type":“FQDN”,"_oid":“51a867e4773da1128b1422ad”} 中取出这段数字：51a867e4773da1128b1422ad
没有用过正则表达式的程序员可能分为两步获取

用String类的indexOf方法获取51a867e4773da1128b1422ad的初始位置
用String类的subString方法取出51a867e4773da1128b1422ad
用这种方法的缺点是代码可阅读性很差，即我们常说的hard code
如果用正则表达式则可以用以下的方法:

                   String reg = "[0-9A-Za-z]{24,}"; // appear at least 24 times ^[0-9A-Za-z]{24,}
                    Pattern pattern = Pattern.compile(reg);
                    Matcher matcher = pattern.matcher(str);
                    if (matcher.find()) {// matcher.matchers() {
                        String fqdnId = matcher.group();
                    }

3.2.2正则表达式语法：

在这里插入图片描述

3.2.3常用正则表达式

验证数字：^[0-9]*$
验证n位的数字：^\d{n}$
验证至少n位数字：^\d{n,}$
验证m-n位的数字：^\d{m,n}$
验证零和非零开头的数字：^(0|[1-9][0-9]*)$
验证有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
验证有1-3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
验证非零的正整数：^\+?[1-9][0-9]*$
验证非零的负整数：^\-[1-9][0-9]*$
验证非负整数（正整数 + 0） ^\d+$
验证非正整数（负整数 + 0） ^((-\d+)|(0+))$
验证长度为3的字符：^.{3}$
验证由26个英文字母组成的字符串：^[a-za-z]+$
验证由26个大写英文字母组成的字符串：^[a-z]+$
验证由26个小写英文字母组成的字符串：^[a-z]+$
验证由数字和26个英文字母组成的字符串：^[a-za-z0-9]+$
验证由数字和26个英文字母9位组成的字符串：^[0-9a-zA-Z]{9}$
验证由数字、26个英文字母或者下划线组成的字符串：^\w+$
验证用户密码:^[a-za-z]\w{5,17}$ 正确格式为：以字母开头，长度在6-18之间，只能包含字符、数字和下划线。
验证是否含有 ^%&',;=?$\" 等字符：[^%&',;=?$\x22]+
验证汉字：^[\u4e00-\u9fa5],{0,}$
验证Email地址：^\w+[-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
验证InternetURL：^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$ ；^[a-za-z]+://(w+(-w+)*)(.(w+(-w+)*))*(?S*)?$
验证电话号码：^(|\d{3,4}-)?\d{7,8}$：--正确格式为：XXXX-XXXXXXX，XXXX-XXXXXXXX，XXX-XXXXXXX，XXX-XXXXXXXX，XXXXXXX，XXXXXXXX。
验证身份证号（15位或18位数字）：^\d{15}|\d{18}$
验证一年的12个月：^(0?[1-9]|1[0-2])$ 正确格式为：“01”-“09”和“1”“12”
验证一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$ 正确格式为：01、09和1、31。
整数：^-?\d+$
非负浮点数（正浮点数 + 0）：^\d+(\.\d+)?$
正浮点数 ： ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
非正浮点数（负浮点数 + 0）： ^((-\d+(\.\d+)?)|(0+(\.0+)?))$
负浮点数： ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
浮点数： ^(-?\d+)(\.\d+)?
匹配所有键盘上可见的非字母和数字的符号：((?=[\x21-\x7e]+)[^A-Za-z0-9])
匹配所有键盘上所有可见的非字母和数字的符号：((?=[\x21-\x7e]+)[^A-Za-z0-9])/g
匹配包括换行符在内的任意字符： ([\s\S]*) 同时，也可以用 “([\d\D]*)”、“([\w\W]*)” 来表示；([\s\S]*?) 加上问号 表示最短匹配
匹配长度为1-20的任意字符：

public class RegexDemo {
    public static void main(String[] args) {
        String pattern = "([\\s\\S]){1,20}";
        Pattern p = Pattern.compile(pattern);
        System.out.print(p.matcher("12345678908-哈哈rrrurr!").matches());
    }
}

参考：
Java - 正则表达式的运用（Pattern模式和Matcher匹配)
JAVA正则表达式-捕获组与非捕获组
 Java正则表达式
 正则表达式-百度百科

ZjfScorpio

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
正则表达式-java

1 什么是正则表达式？正则表达式（Regular Expression）是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。2 用来干什么？在写程序的过程中，有时会需要匹配、查找、替换或者是判断字符串的出现情况，而且有时不能用简单的纯编码方式解决这些问题，这个时候就会想到要正则表达式，无...
复制链接

扫一扫

专栏目录