正则表达式的理解学习

于 2022-08-01 14:38:55 发布
阅读量303 收藏
点赞数
分类专栏： JAVA基础 文章标签： 正则表达式 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49137582/article/details/126100959
版权

文章目录

基本介绍

一个正则表达式，就是用某种模式去匹配字符串的一个公式，很多人因为他们看上去比较古怪而且复杂所以不敢去使用，不过，经过练习后，就觉得这些复杂的表达式写起来还是相当简单的，而且，一旦你弄懂他们，你就能把数小时辛苦而且易错的文本处理工作缩短在几分钟（甚至几秒钟）内完成

这里要特别强调，正则表达式不是只有java才有，实际上很多编程语言都支持正则表达式进行字符串操作！比如：javascript,php,java…

代码示例：（带你了解正则表达式）

public class Regexp_ {
    public static void main(String[] args) {
        String str = "1998年12月8日，第二代Java平台的企业版J2EE发布。" +
                "1999年6月，Sun公司发布了第二代Java平台（简称为Java2）" +
                "的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型版）" +
                "，应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard " +
                "Edition，Java 2平台的标准版），应用于桌面环境；J2EE（" +
                "Java 2Enterprise Edition，Java 2平台的企业版），" +
                "应用于基于Java的应用服务器。Java 2平台的发布，是Java发展" +
                "过程中最重要的一个里程碑，标志着Java的应用开始普及。";
        //提取文中的所有英文单词
        //（1）传统方式：采用遍历方式，代码量大，效率不高
        //（2）正则表达式技术
        //1.先创建一个Pattern对象，模式对象，可以理解成为就是一个正则表达式对象
        //Pattern pattern = Pattern.compile("[a-zA-Z]+");
        //数字
        //Pattern pattern = Pattern.compile("[0-9]+");
        //数字和英文单词
        Pattern pattern = Pattern.compile("([0-9]+)|([a-zA-Z]+)");
        //2.创建一个匹配器对象
        //理解： matcher 匹配器按照 pattern(模式/样式)，到str中去匹配
        //找到返回true，否则就返回false
        Matcher matcher = pattern.matcher(str);
        //3.可以开始循环匹配
        while (matcher.find()){
            //匹配内容，文本，放到 matcher.group(0) 中
            System.out.println("找到："+matcher.group(0));
        }
    }
}

正则表达式底层实现

为让大家对正则表达式底层实现有一个直观的映像，给大家举个实例

给你一段字段串（文本），请找出所有四个数字连在一起的子串，比如：应该找到 1998 1999 3443 9889 ===> 分析底层实现

public class RegTheory {
    public static void main(String[] args) {
        String str = "1998年12月8日，第二代Java平台的企业版J2EE发布。" +
                "1999年6月，Sun公司发布了第二代Java平台（简称为Java2）" +
                "的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型版）" +
                "，应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard " +
                "Edition，Java 2平台的标准版），应用于桌面环境；J2EE（" +
                "Java 2Enterprise Edition，Java 2平台的企业版），" +
                "应用于基于Java的应用服务器3443。Java 2平台的发布，是Java发展" +
                "过程中最重要的一个里程碑，标志着Java的应用开始普及9889。";
        //说明
        //1. \\d  表示一个任意的数字（0-9）
        String regStr = "\\d\\d\\d\\d";
        //2.创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3.创建匹配器
        //说明 ：创建匹配器 matcher ，按照正则表达式的规则，去匹配 str字符串
        Matcher matcher = pattern.matcher(str);
        //开始匹配
        /*
        * matcher.find() 完成的任务
        1. 根据指定的规则，定位满足规则的子字符串（比如1999）
        2. 找到后，将 子字符串的**开始的索引**记录到 matcher 对象的属性
          int[] groups;  groups[0]=0（groups[0]的值会改变，每一个符合规则的子字符串开始的索引）
          把该子字符串的结束的 **索引+1**的索引值 记录到groups[1]
          * （groups[1]的值会改变，每一个符合规则的子字符串结束的索引+1）=4
        3. 同时记录oldLast 的值为 子字符串的结束的 索引+1 的索引值 ，
          即4。即下次执行find()方法时，就从35开始匹配
        *
        *
        *matcher.group(0) 完成的任务
        public String group(int group) {
            if (first < 0)
                throw new IllegalStateException("No match found");
            if (group < 0 || group > groupCount())
                throw new IndexOutOfBoundsException("No group " + group);
            if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
                return null;
            return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
        }
        1. 根据groups[0]=0 和 groups[1]=4 的记录的位置，
        *从content 开始截取子字符串返回的值 就是  [0,4)   左闭右开，
        *即包含  0  但是不包含   4
        2. 如果再次执行find方法，仍然按照上面分析来执行
        * */
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

什么是分组：正则表达式中有 小括号() 就表示分组，比如：(\d\d)(\d\d) ，第一个（）就表示第1组，第二个（）就表示第2组…以此类推，

那么分组后的底层又是怎么样的呢

public class RegTheory {
    public static void main(String[] args) {
        String str = "1998年12月8日，第二代Java平台的企业版J2EE发布。" +
                "1999年6月，Sun公司发布了第二代Java平台（简称为Java2）" +
                "的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型版）" +
                "，应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard " +
                "Edition，Java 2平台的标准版），应用于桌面环境；J2EE（" +
                "Java 2Enterprise Edition，Java 2平台的企业版），" +
                "应用于基于Java的应用服务器3443。Java 2平台的发布，是Java发展" +
                "过程中最重要的一个里程碑，标志着Java的应用开始普及9889。";
        //说明
        //1. \\d  表示一个任意的数字（0-9）
        String regStr = "(\\d\\d)(\\d\\d)";
        //2.创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3.创建匹配器
        //说明 ：创建匹配器 matcher ，按照正则表达式的规则，去匹配 str字符串
        Matcher matcher = pattern.matcher(str);
        //开始匹配
        /*
        * matcher.find() 完成的任务
        1. 根据指定的规则，定位满足规则的子字符串（比如1999）
        2. 找到后，将 子字符串的**开始的索引**记录到 matcher 对象的属性
          int[] groups;  groups[0]=0（groups[0]的值会改变，每一个符合规则的子字符串开始的索引）
          把该子字符串的结束的 **索引+1**的索引值 记录到groups[1]
          （groups[1]的值会改变，每一个符合规则的子字符串结束的索引+1）=4
          也就是说：groups[0]和groups[1]的值，还是按照原来的规则赋值
          但是，由于这里有了分组，需要记录 每个分组后子字符串的值
          groups[2]：记录第一个分组，子字符串开始的索引值  =0
          groups[3]：记录第一个分组，子字符串结束的索引+1 的值  =2
          
          groups[4]：记录第二个分组，子字符串开始的索引值  =2
          groups[5]：记录第二个分组，子字符串结束的索引+1 的值  =4
          
          ...以此类推
          
        3. 同时记录oldLast 的值为 子字符串的结束的 索引+1 的索引值 ，
          即4。即下次执行find()方法时，就从35开始匹配
        *
        *
        *matcher.group(0) 完成的任务
        public String group(int group) {
            if (first < 0)
                throw new IllegalStateException("No match found");
            if (group < 0 || group > groupCount())
                throw new IndexOutOfBoundsException("No group " + group);
            if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
                return null;
            return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
        }
        1. 根据groups[0]=0 和 groups[1]=4 的记录的位置，
        *从content 开始截取子字符串返回的值 就是  [0,4)   左闭右开，
        *即包含  0  但是不包含   4
        2. 如果再次执行find方法，仍然按照上面分析来执行
        * */
        while (matcher.find()){
            //如果正则表达式有()，即分组
            //取出匹配的规则如下
            //但是不能 取 没有的分组
            System.out.println(matcher.group(0));//输入 0 表示输出整个字符串
            System.out.println("该字符串第一组的值："+matcher.group(1));//输入 1 表示输出该字符串中的第一组
            System.out.println("该字符串第二组的值："+matcher.group(2));//输入 2 表示输出该字符串中的第二组
            //...以此类推
        }
    }
}

在这里插入图片描述

正则表达式语法

如果想要灵活的运用正则表达式，必须了解其中各种元字符的功能，元字符从功能上大致分为：

  1. 限定符
  2. 选择匹配符
  3. 分组组合和反向引用符
  4. 特殊字符
  5. 字符匹配符
  6. 定位符

元字符-转义号 \

\符号 说明：在我们使用正则表达式取检索某些特殊字符的时候，需要用到转义符号，否则检索不到结果，甚至会报错的，案例：用 $ 去匹配 “abc$(” 会怎么样?

用 ( 去匹配 “abc$(” 会怎么样?

提示：在java的正则表达式中，两个\代表其它语言中的\

常见的需要用到转移符号的字符有以下几种：. * + ( ) $ / \ ? [ ] ^ { }

单独一个 . 点 不加转义符，匹配的是所有字符

public class RegExp01 {
    public static void main(String[] args) {
        String content = "abc$(abc(123(";
        //String str = "$";没有匹配到结果
        //String str = "(";//直接报错
        
        //String str = "\\$";
        String str = "\\(";
        Pattern pattern = Pattern.compile(str);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

元字符-字符匹配符

符号符号示例解释
[]可接受的字符列表[efgh]e、f、g、h中的任意一个字符
[^]不接受的字符列表[^abc]除abc之外的任意一个字符，包括数字和特殊符号
-连字符A-Z任意单个大写字母

表格中有一些 括号 不完整，是因为这个软件所导致

符号含义示例说明匹配输入
.匹配除\n以外的任何字符，使用时，需要\.a…b以a开头，b结尾，中间包括2个任意字符的长度为4的字符串aaab,aegb,a78b,a#*b
\\d匹配单个数字字符，相当于[0-9]\\d{3}(\\d)?包含3个或4个数字的字符串123，9876
\\D匹配单个非数字字符，相当于[^0-9\\D(\\d)*以单个非数字字符开头，后接任意个数字字符串a，A342
\\w匹配单个数字、大小写字母和下划线字符，相当于[0-9a-zA-Z_\\d{3}\\w{4}以3个数字字符开头的长度为7的数字字母字符串234abcd,12354jk
\\W匹配单个非数字，大小写字母字符，相当于[^0-9a-zA-Z_\\W+\\d{2}以至少1个非数字开头字母字符开头，2个数字字符结尾的字符串#29，#?@10
\\s匹配任何空白字符(空格，制表符等)\\sljk kjk
\\S匹配任何非空白字符和\s刚好相反\\Sjkjklj ghjj

java正则表达式默认是区分字母大小写的，如何实现不区分大小写

  • (?i)abc：表示abc都不区分大小写
  • a(?i)bc：表示bc不区分大小写
  • a((?i)b)c：表示只有b不区分大小写
  • Pattern pat = Pattren.compile(regEX,Pattern.CASE_INSENSITIVE);

元字符-选择匹配符

在匹配某个字符串的时候是选择性的，即：既可以匹配这个，又可以匹配那个，这时你需要用到哦 选择匹配符 |

符号符号示例解释
|匹配“|”之前或之后的表达式ab|cdab或者cd

元字符-限定符

用于指定前面的字符和组合项连续出现多少次

符号含义示例说明匹配输入
*指定字符重复0次或n次（无要求）(abc)*仅包含任意个abc的字符串，等效于\w*abc,abcabc
+指定字符重复1次或n次（至少一次）m+(abc)*以至少1个m开头，后接任意个abc的字符串m,mabc,mabcabc
?指定字符重复0次或1次（最多一次）m+abc?以至少1个m开头，后接ab或abc的字符串mab,mabc,mmmab,mmabc
{n}只能输入n个字符[abcd]{3}由abcd中字母组成的任意长度为3的字符串abc,dbc,adc
{n,}指定至少n个匹配[abcd]{3,}由abcd中字母组成的任意长度不小于3的字符串aab,cdb,adabc
{n,m}指定至少n个但不多于m个匹配[abcd]{3,5}由abcd中字母组成的任意长度不小于1，不大于5的字符串abc,abcd,aaaaa,bcdab

注意：java匹配默认是贪婪匹配，即尽可能的匹配多的部分

比如：a{3,4} aaaaaa12

会匹配出aaaa，而不是aaa和aaa

元字符-定位符

定位符，规定要匹配的字符串出现的位置，比如在字符串的开始还是在结束的位置，这个也是相当有用的，必须掌握

符号含义示例说明匹配输入
^指定起始字符^ [0-9]+[a-z]*以至少一个数字开头，后接任意个小写字母的字符串123，5aa
$指定结束字符^ [0-9]\\-[a-z]+$以1个数字开头后连字符“-”，并以至少1个小写字母结尾的字符串1-a
\\b匹配目标字符串的边界han\\b这里说的字符串的边界指的是子串间由空格，或者是目标字符串的结束位置hanshunpingsphan nnhan
\\B匹配目标字符串的非边界han\\B和\b的含义刚刚相反hanshunpingsphan nnhan

分组

常用分组
常用分组构造形式说明
(pattern)非命名捕获，捕获匹配的子字符串，编号为 0 的第一个捕获是由整个正则表达式模式匹配的文本，其它捕获结果则根据左括号的顺寻从 1 开始自动编号
(?pattren)命名捕获，将匹配的子字符串捕获到一个组名称或编号名称中，用于name的字符串不能包含任何标点符号，并且不能以数字开头，可以使用单引号替代尖括号，例如 (?‘name’)
String str = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
sout(matcher.group(1));
sout(matcher.group("g1"));
//命名之后就会两种获取分组后子字符串的方法，没有命名只能通过顺序来获取
特别分组

这种分组，后面就只能通过matcher.group(0)方式来获取到值，不能通过matcher.group(1),matcher.group(2)…等等，因为不是捕获分组

常用分组构造形式说明
(?:pattern)匹配pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配，这对于用"or"字符(|)组合模式部件的情况很有用，例如：‘industr(?:y|ies)’是比’industry|industries’更经济的表达式
(?=pattern)它是一个非捕获匹配，例如：‘Windows(?=95|98|NT|2000)‘匹配’Windows 2000’中的’Windows’，但是不匹配’Windows 3.1’中的’Windows’
(?!pattern)该表达式匹配不处于匹配 pattren 的字符串的起始点的搜索字符串，它是一个非捕获匹配，例如：‘Windows(?!95|98|NT|2000)‘匹配’Windows 3.1’中的’Windows’，但是不匹配’Windows 2000’中的’Windows’
public class RegExp01 {
    public static void main(String[] args) {
        String content = "hello韩顺平教育 jack韩顺平老师 韩顺平同学hello";
        //String regStr = "韩顺平教育|韩顺平老师|韩顺平同学"
        //String regStr = "韩顺平(?:教育|老师|同学)";

        //只匹配韩顺平后面是  教育或者老师 的 韩顺平 的字符串
        //String regStr = "韩顺平(?=教育|老师)";

        //不匹配韩顺平后面是  教育或者老师 的 韩顺平 的字符串
        String regStr = "韩顺平(?!教育|老师)";
        
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while(matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

注意：在 限定符（* + ? {n} {n,} {n,m}） 后面加上一个问号（?）表示非贪婪匹配

应用实例

  1. 汉字
  2. 邮政编码：要求：是1-9开头的一个六位数，比如：123890
  3. QQ号码：要求：是1-9开头的一个(5位数-10位数)，比如：12389，1345678
  4. 手机号码：要求：必须以13，14，15，18开头的11位数，比如13588889999
  5. URL：如：https://www.bilibili.com/video/BV1fh411y7R8?from=search&seid=183160912083761326
public class RegExp01 {
    public static void main(String[] args) {
        String content = "韩顺平教育";
        String content1 = "123455";
        String content4 = "https://www.bilibili.com/video/BV1fh411y7R8?from=search&seid=183160912083761326";
//汉字
        //^[Α-￥]+$的意思是，从开头到结尾 这一整段内容，都要符合中间的这个规则 [Α-￥]+
        //这里的意思是把 韩顺平教育  和  [Α-￥]+ 进行匹配
        //并且有 ^ 和 $ 的话，指定的长度至少是要和  content 的长度一样，不能小于这个长度
        String regStr = "^[\u0391-\uffe5]+$";
        //这里的 ^和$ 指的是 content 的开始和结束，是整个字符串,因为这里有个 + 号
//邮政编码，是1-9开头的一个六位数
        String regStr1 = "^[1-9]\\d{5}$";
//qq号码，是1-9开头的一个5位数-10位数
        String regStr2 = "^[1-9]\\d{4,9}$";
//手机号码，13 14 15 18开头的十一位数
        String regStr3 = "^1[3|4|5|8]\\d{9}$";
//url，需要注意，[]中的符号，代表的是本身
        String regStr4 = "^([https|http]://)(([\\w-]+\\.)+[\\w])+(\\/[\\w-?=&/%.#]*)?$";
        Pattern pattern = Pattern.compile(regStr4);
        Matcher matcher = pattern.matcher(content4);
        if(matcher.find()){
            System.out.println("满足格式");
            System.out.println(matcher.group(0));
        }else{
            System.out.println("不满足格式");
        }
    }
}

正则表达式三个常用的类

java.util.regex包主要包括以下三个类Pattren类，Matcher类和PatternSyntaxException

Pattern类

Pattren 对象是一个正则表达式对象，Pattren类没有公共构造方法，要创建一个Pattern 对象，调用其公共静态方法，它返回一个Pattern 对象，该方法接收一个正则表达式作为它的一个参数，比如：Pattern r = Pattern.compile(pattern)

  • Pattern类的方法 matches，整体匹配，看content的内容，是否符合regStr的规则，有点类似 ^ $
String content = "hello abc hello 韩顺平教育";
String regStr = "hello";
String regStr = "hello.*";//true
boolean matches = Pattern.matches(regStr,content);
sout("整体匹配="+matches);//false

如果我们只需要匹配内容是否符合规则，而不需要找到匹配的内容，可以这样使用

Matcher类

Matcher 对象是对输入字符串进行解释和匹配的引擎，与Pattern 类一样，Matcher也没有公共构造方法，你需要调用Pattern对象的matcher方法来获取一个Matcher对香港

方法及说明：

  • public int start()：返回以前匹配的初始索引
  • public int start(int group)：返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
  • public int end(int group)：返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量
  • public int end()：返回最后匹配字符之后的偏移量
  • public boolean find()：尝试查找与该模式匹配的输入序列的下一个子序列
  • public boolean find(int start)：重置匹配器，然后尝试查找匹配该模式，从指定索引开始的输入序列的下一个子序列
  • public boolean matches()：尝试将整个区域与模式匹配
  • public String replaceAll(String replacement)：替换模式与给定替换字符串想匹配的输入序列的第一个子序列

PattrenSyntaxException

PatternSyctaxEcxeption是一个非强制异常类，它表示一个正则表达式模式中的语法错误

分组，捕获，反向引用

给你一段文本，请你找出所有四个数字连在一起的子串，并且这四个数字要满足第一位和低四位相同，第二位和第三位相同，比如：1221，5775…

要解决前面的问题，我们需要了解正则表达式的几个概念：

  1. 分组：我们可以用圆括号组成一个比较复杂的匹配模式，那么一个圆括号的部分我们可以看做是一个子表达式/分组
  2. 捕获：把正则表达式中子表达式/分组匹配的内容，保存到内存中以数字编号或显式命名的组名，方便后面引用，从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推，组0表示的是整个正则式
  3. 反向引用：圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以式在正则表达式内部，也可以是在正则表达式外部，内部反向引用\\分组号，外部反向引用$分组号

案例：

  1. 要匹配两个连续的相同数字：(\\d)\\1
  2. 要匹配五个连续的相同数字：(\\d)\\1{4}
  3. 要匹配个位与千位相同，十位与百位相同的数 5225 ，1551 ：(\\d)(\\d)\\2\\1;
  4. 请在字符串中检索·商品编号，形式如：12321-333999111这样的号码，要求：满足前面是一个五位数，然后一个-号，然后是一个九位数，连续的每三位都相同：\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}
  5. 把“我…我要…学学学学…编程java!”，通过正则表达式修改成“我要学编程java”：(.)\\1{2,}
//老韩思路：先把点去掉
        //String regStr = "\\.+"
        //再把重复的 . 去掉
        String content = "我...我要...学学学学...编程java!";
        //String regStr1 = "(.)\\1{2,}";//我.我要.学.编程java!
        String regStr = "\\.+";//我.我要.学.编程java!
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while(matcher.find()){
            content = matcher.replaceAll("");
            System.out.println(content);
        }
        String regStr1 = "(.)\\1+";//我.我要.学.编程java!
        Pattern pattern1 = Pattern.compile(regStr1);
        Matcher matcher1 = pattern1.matcher(content);
        while(matcher1.find()){
            content = matcher1.replaceAll("$1");
            System.out.println(content);
        }

String类中使用正则表达式

  • String 类 public String replaceAll(String regex,String replacement)
String content = "jdk1.3 jdk1.4";
content = content.replaceAll("jdk1\\.3|jdk1\\.4","jdk");
sout(content);
  • 判断功能，String 类 public boolean matches(String regex){}
//要求：验证一个手机号，必须是以138、139开头的
String content = "13564564565";
if(content.matches("1(38|39)\\d{8}")){
    sout("验证成功");
}else{
    sout("验证失败");
}
  • 分割功能，String类 public String[](String regex)
String content = "hello#abc-jack12smith~北京";
//要求按照 # - ~ 数字 来分割
String[] split = content.split("#|-|~|\\d+");
//iter,增强for循环输出split数组

使用案例

规定电子邮件规则为

  1. 只能有一个@
  2. @前面是用户名，可以是a-z A-Z 0-9 _ -字符
  3. @后面是域名，并且域名只能是英文字母，比如sohu.com或者tsinghug.org.cn
  4. 写出对应的正则表达式，验证输入的字符串是否满足规则
String regStr = "^[\\w-]+@([a-zA-Z]+\\.)+[a-zA-Z]+$"

要求验证是不是整数或者小数

提示：这个题要考虑整数和负数

String regStr = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";

对一个url进行解析

https://www.sohu.com:8080/abc/index.htm

  1. 要求得到协议是什么？https
  2. 域名是什么？www.sohu.com
  3. 端口是什么？8080
  4. 文件名是什么？index.htm
String content = "https://www.sohu.com:8080/abc/index.htm";
        String a = "";
        String b = "";
        String c = "";
        String d = "";
        String[] split = content.split("[:/]");
        for (int i = 0; i < split.length; i++) {
            a = split[0];//协议
            b = split[3];//域名
            c = split[4];//端口号
            d = split[split.length-1];//文件名
        }
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
//老韩的方法是使用分组捕获，然后分组输出，matcher.group(1),matcher.group(2),matcher.group(3),matcher.group(4)
爱学习的大雄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
正则表达式（韩）
cygzsw的博客
09-06 1005
正则表达式 介绍 一个正则表达式，就是用某种模式去匹配字符串的一个公式，很多人因为他们看上去比较古怪而且复杂所以不敢去使用，不过，经过练习后，就觉得这些复杂的表达式写起来还是相当简单的，而且，一旦你弄懂他们，你就能把数小时辛苦而且易错的文本处理工作缩短在几分钟（甚至几秒钟）内完成 这里要特别强调，正则表达式不是只有java才有，实际上很多编程语言都支持正则表达式进行字符串操作！比如：javascript,php,java… public class Regexp_ { public static
日语韩语等常用正则表达式(笔记)
热门推荐
coder_chenz的博客
03-15 1万+
在遇到需要用正则校验数据时，往往是在网上去找很久，结果找来的还是不很符合要求。所以我最近把开发中常用的一些正则表达式整理了一下，在这里分享一下。就当作笔记1.基础\d 匹配一个数字字符。等价于[0-9]。grep 要加上-P，perl正则支持 \D 匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持 \f 匹配一个换页符。等价于\x0c和\cL。
hangul-regex:韩文的新正则表达式系统（韩文字符）
04-12
制作韩文正则表达式 @ naem1023在贝加尔湖（Baikal.ai）疯狂 要求 的Python 3 Requirements.txt中的模块 python3 -m pip install -r requirements.txt 如何使用 $ python3 hangeul_regex.py {Hangeul Regex} 韩文正则表达式类型 <发病，细胞核，尾气> 起病时，细胞核，尾气可为空。 空表示所有发作，核或尾气。 例如。 <ㄱ，ㅏ，>的意思是'가，갂，간....'。 “ @”起病空虚。 必须在发作时使用。 例如。 <，ㅏ，@>的意思是“가，까，나，다....”。 必须用引号引起来。 python3 hangeul_regex.py "<ㄱ,,>" 选项 '-m' 使用多线程。 默认选项使用单线程。 推荐在输入韩文正则表达式大于2时使用。 例如。 <ㄱ,,> <ㄴ
正则表达式韩语日语
sinat_34080511的博客
07-13 6501
韩语匹配 [가-힣]+This matches every character from U+AC00 to U+D7A3 日语匹配
正则表达式匹配：中、日、韩文
JonnyJiang-zh的博客
07-01 1601
/[\u2E80-\u2FDF\u3040-\u318F\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7FF].*/.exec("뭐해?‘라는 두 글자에")[0] 结果： “뭐해?‘라는 두 글자에” /[\u2E80-\u2FDF\u3040-\u318F\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FFF\uA960-\uA97F\uAC00-
正则表达式学习视频
06-01
通过这个视频教程，无论是初学者还是有一定经验的开发者，都可以深入理解正则表达式的强大功能，提升处理文本数据的能力。无论是在前端的JavaScript还是后端的Java开发中，正则表达式都将是你不可或缺的工具。
正则表达式必知必会v_1.0.pdf
01-02
正则表达式的语法比较容易理解，但学习正则表达式的主要困难在于如何灵活运用这些规则来达到查找和替换的目的。 匹配单个字符 在正则表达式中，可以使用句点（.）来匹配任意单个字符。句点在正则表达式中被称为元...
学习正则表达式：轻松学习正则表达式
02-09
术语“正则表达式”很容易理解，因此您通常会发现缩写为“ regex”或“ regexp”的术语。 假设您正在编写应用程序，并且想为用户选择用户名设置规则。 我们要允许用户名包含字母，数字，下划线和连字符。 我们还...
Python基础入门知识之正则表达式学习 正则表达式30分钟入门教程 共21页.pdf
最新发布
06-04
为了进一步学习，可以查阅Python官方文档的`re`模块，以及各种正则表达式在线教程和练习网站。 通过这个简短的教程，你应该对Python中的正则表达式有了初步的了解。继续实践和探索，将有助于你更好地掌握这一强大...
正则表达式chm学习教程
12-20
在学习正则表达式时，常常需要通过实践来加深理解。`chm` 格式的文档通常包含丰富的实例和交互式练习，可以帮助读者更好地掌握各种正则表达式语法和技巧。通过本教程，你将学会如何构建简单的正则表达式，理解复杂的...
正则表达式
12-16
正则表达式1、 掌握正则表达式的基本用法 1.2. 正则表达式简介 1、 正则表达式是一个强大的字符串处理工具，可以对字符串进行、查找、提取、分割、替换等操作。它简单而且实用，是一个用于匹配字符串的模板，我们定义的任意的一个字符串都可以看成是一个正则表达式。 2、 String类也提供了几个和正则表达式有关的几个特殊方法 1） Boolean matches(String regex)：判断该字符串是否匹配指定的正则表达式。 2） String replaceAll(String regex,String replacement)：返回该字符串中所有匹配正则表达式的子串，然后替换成replacement指定的字符串。 3） String replaceFirst(String regex,String replacement);返回该字符串中第一个匹配正则表达式的子串替换成replacement 后的新字符串。 4） String[] split(String regex)根据给定正则表达式拆分该字符串后得到的字符串数组。 3、 创建正则表达式： 正则表达式中使用的常见字符： 1） \t:制表符(‘\u0009’). 2） \n:换行(‘\u000A’)。 3） \r:回车(‘\u000d’) 4） …… 除此之外正则表达式中有一些特殊的字符，这些字符在正则表达式中有特殊的用途，如前面介绍的反斜线(\),如果需要匹配这些字符，必须首先将这些字符转义，也就是再前面添加一个反斜线(\).正则表达式中的特殊字符： 1）$:匹配一行的结尾。要匹配$自身用\$ 2）^:匹配一行的开头。要匹配^字符本身用\^. 3）():标记子表达式的开始位置和结束位置，要匹配这些字符用\(,\). 4）[]:确定中括号表达式的开始位置和结束位置。 例如：字符集 [abc]:表示内容可能是a、b、c字母中的任意一个。 [^abc]：表示内容不是a、b、c字母的任意一个 [a-zA-Z]:全部的英文字母 [0-9]:全部的数字 5）{}:用于标记字表达式的出现额度。 {n}:出现正好n次。 {n,m}:出现n~m次 {n,}:出现n次以上。 6）*：指定前面表达式可以出现零次或多次。 7）+：指定前面表达式可以出现一次或多次。 8）?: 指定前面表达式可以出现零次或1次。 9）.:匹配换行符\n之外的任何字符。 10)\:用于转义下一个字符 11)|:指定两项之间任选一项，如果要匹配|,请使用\| 上面的正则表达式依然匹配单个字符，这是因为还未在正则表达式中使用”通配符”，“通配符”是可以匹配多个字符的特殊字符。正则表达式中”通配符”远远超出了普通通配符的功能，它们被称为预定义字符：例如 1).:可以匹配任何字符 2)\d:匹配数字 3)\D:匹配非数字 4)\s:匹配所有空白字符，包括空格、制表符、回车符、换页符、换行符等 5)\S:匹配所有非空白字符 6)\w:匹配所有单词字符，包括0~9所有数字，26个英文字母和下划线(_) 7)\W:匹配所有非单词字符。 说明：上面的预定义字符：d是digit的意思，代表数字；s是space的意思，代表空白；w是word的意思，代表单词。d、s、w的大写形式恰好匹配与之相反的字符。 例如 ：c\wt 可以匹配cat,cbt,c0t,c9t等 \d\d\d-\d\d\d\-\d\d\d可以匹配000-000-000形式的电话号码。 \\d{3}-\\d{3}-\\d{3} 正则表达式还支持圆括号表达式，圆括号表达式用于将多个表达式组成一个子表达式，圆括号中可以使用或运算符(|)，例如正则表达式 “(public|protected|private)”用于匹配Java三个访问控制符其中之一。 4、 使用正则表达式 一旦程序中定义了正则表达式之后，就可以使用Pattern和Matcher来使用正则表达式。 Pattern对象是正则表达式编译后在内存中的表示形式，因此，正则表达式字符串必须先编译为Pattern对象，然后再利用该Pattern对象创建对应的Matcher对象，执行匹配所涉及的状态保留在Matcher对象中，多个Matcher对象可共享同一个Pattern对象。 例如：典型的调用顺序 //将一个字符串编译成Pattern对象 Pattern p=Pattern.complie(“a*b”); //使用Pattern对象创建Matcher对象 Matcher m=p.matcher(“aaaab”); Boolean b=m.matchers();//返回true. 上面的Pattern对象可以重复使用多次，如果某个正则表达式仅需一次使用，可直接使用Pattern类的静态matches方法，此方法自动把指定字符串编译成匿名的Pattern对象，并执行匹配。 Boolean b=Pattern.matches(“a*b”,”aaaab”);//返回true. 5、
正则表达式正则表达式
01-10
正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式
识别韩语的正则表达式
09-24 879
收集一个识别韩语的正则表达式，[\uac00-\ud7ff]，改正则表达式在javascript中已经通过验证,<script type="text/javascript">var testString = "China中国중국상하이上海";var koreanReg = /[\uac00-\ud7ff]/gi;alert(testString.match(kore...
【字符集】正则
qfzhangwei的专栏
11-23 593
1 -------------------------------字符集 双字节字符编码范围： 1. GBK (GB2312/GB18030) \x00-\xff GBK双字节编码范围 \x20-\x7f ASCII \xa1-\xff 中文gb2312 \x80-\xff 中文 gbk 2. UTF-8 (Unicode) \u4e00-\u9fa5 (中文) \x3130-\x318...
fei 正则表达式_正则表达式 匹配 中文/日文/韩文
weixin_39955938的博客
12-22 1080
包含中日韩文但不包含其标点符号等的部分的正则表达式/[\u2E80-\u2FDF\u3040-\u318F\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7FF]/有中日韩文字区域细分(我们需要的打√)2E80-2FDF 中文偏旁部首 √2FF0-2FFF 表意描述字符，看起来像一堆虚线框3000...
正则表达式a开头b结尾_MySQL（基础正则表达式）
weixin_28748867的博客
01-23 7948
什么是正则表达式嘞，引用一段百度百科的一段话；正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。在我的理解中：正则表达式的意思是我可以快速把相同特征的内容都筛选出来。选出来之后就可以同类型进行操作。之前在做AI电话的时候，话术管理中就有正则表...
韩语
weixin_33967071的博客
01-04 101
http://www.korean.go.krhttp://sunlina.anyp.cn/10.aspx
正则表达式：查找某字符串开始和某字符串结束的字符串
sensor_WU 博客
10-29 5976
正则表达式：查找某字符串开始和某字符串结束的字符串 a.*?b 查找以a开始，并且以b结束的字符串 例如： 字符串为：上海12345abcd.opi,.<>北京 patten ：上海.*?北京 结果：上海12345abcd.opi,.<>北京 如果不需要包含a,b (?<=a).*?(?=b) 例如： 字符串为：上海12345abcd.opi,.<>北京 patten ：（?<=上海).*?(?=北京) 结果：12345abcd.opi,.<> 以
PHP正则表达式学习与应用实用指南
总的来说，学习PHP正则表达式需要从基本语法入手，理解其常用模式和功能，并逐步掌握其高级功能。通过不断的练习和实践，用户可以更加熟练地运用PHP正则表达式，从而提高程序的效率和可靠性。在实际开发中，PHP正则...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的大雄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值