精华内容
下载资源
问答
  • 001.匹配一个或者多个的空格的正则表达式: \\s+ 例: String[] ...匹配二个或多个空格正则表达式 : \\s{2,} 例:String str = new String("i am a good boy! "); String replaceAll = str.r...

    001.匹配一个或者多个的空格的正则表达式:    \\s+

     例:   String[] newStr = str.trim().split("\\s+");


    002.匹配二个或多个空格的正则表达式 :   \\s{2,}

     例:String str = new String("i am   a   good     boy!    ");
         String replaceAll = str.replaceAll("\\s{2,}", " ").trim();
       

    展开全文
  • 1.正则表达式到底是什么东西? 正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)是用于描述字符串规则的工具。换句话说,正则表达式就是记录文本规则的代码。 正则表达式语言由两种...

    1.正则表达式到底是什么东西?

    正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)是用于描述字符串规则的工具。换句话说,正则表达式就是记录文本规则的代码。

    正则表达式语言由两种基本字符类型组成原义(正常)文本字符元字符(metacharacter)。元字符使正则表达式具有处理能力。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符,可以用来规定其前导字符(即位于元字符前面的字符)在目标对象中的出现模式。

    在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard),也就是 * 和 ? 。如果你想查找某个目录下的所有的Word文档的话,你会搜索*.doc。在这里,*会被解释成任意的字符串。和通配符类似,正则表达式也是用来进行文本匹配的工具,只不过比起通配符,它能更精确地描述你的需求——当然,代价就是更复杂——比如你可以编写一个正则表达式,用来查找所有以0开头,后面跟着2-3个数字,然后是一个连字号“-”,最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

    2.常用正则表达式符号

    (1)常用的元字符
    \b 代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格,标点符号或者换行来分隔的,但是\b并不匹配这些单词分隔字符中的任何一个,它只匹配一个位置。
    . 匹配除了换行符以外的任意字符。
    \d 匹配一位数字(0,或1,或2,或……)。
    \s 匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等。
    \w 匹配字母或数字或下划线或汉字等。
    ^ 匹配字符串的开始。
    $ 匹配字符串的结束。有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项,^和$的意义就变成了匹配行的开始处和结束处。

    (2)常用的限定符
    * 代表数量——指定 * 前边的内容可以连续重复使用任意次以使整个表达式得到匹配。
    .* 连在一起就意味着任意数量的不包含换行的字符。
    + 是和 * 类似的元字符,不同的是: * 匹配重复任意次(可能是0次),而+则匹配重复1次或更多次。
    ? 重复零次或一次
    {n} 重复n次
    {n,} 重复n次或更多次
    {n,m} 重复n到m次
    [] 匹配没有预定义元字符的字符集合。
    例如:
    [0-9] 代表一位数字,与\d就是完全一致的;
    [a-z0-9A-Z_] 完全等同于\w(如果只考虑英文的话)。
    [.?!] 匹配标点符号( . 或 ? 或 ! )

    (3)常用的反义代码
    \W 匹配任意不是字母,数字,下划线,汉字的字符
    \S 匹配任意不是空白符的字符
    \D 匹配任意非数字的字符
    \B 匹配不是单词开头或结束的位置
    [^x] 匹配除了x以外的任意字符
    [^aeiou] 匹配除了aeiou这几个字母以外的任意字符

    (4)常用分组语法
    捕获:
    (exp) 匹配exp,并捕获文本到自动命名的组里
    (?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name’exp)
    (?:exp) 匹配exp,不捕获匹配的文本,也不给此分组分配组号
    零宽断言:
    (?=exp) 匹配exp前面的位置
    (?<=exp) 匹配exp后面的位置
    (?!exp) 匹配后面跟的不是exp的位置
    (?<!exp) 匹配前面不是exp的位置
    注释:
    (?#comment) 这种类型的分组不对正则表达式的处理产生任何影响,用于提供注释让人阅读

    (5)懒惰限定符
    *? 重复任意次,但尽可能少重复
    +? 重复1次或更多次,但尽可能少重复
    ?? 重复0次或1次,但尽可能少重复
    {n,m}? 重复n到m次,但尽可能少重复
    {n,}? 重复n次以上,但尽可能少重复

    3.正则表达式详细介绍

    字符转义
    如果你想查找元字符本身的话,比如查找 . ,或者 * ,是没办法直接指定它们的,因为它们会被解释成别的意思。这时你就得使用 \ 来取消这些字符的特殊意义。因此,应该使用 \. 和 \* 。当然,要查找 \ 本身,得用 \\。
    例如:china\.net 匹配 china.net,C:\\Windows匹配C:\Windows。

    分枝条件
    正则表达式里的分枝条件指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,匹配分枝条件时,将会从左到右地测试每个条件,如果满足了某个分枝的话,就不会去再管其它的条件了。具体方法是用 | 把不同的规则分隔开。

    我们来看一个复杂的表达式:\(?0\d{2}[) -]?\d{8}
    “(” 和 “)” 也是元字符,所以在这里需要使用转义。这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。我们对它进行一些分析吧:首先是一个转义字符 \( ,它能出现0次或1次(?),然后是一个0,后面跟着2个数字(\d{2}),然后是 ) 或 - 或空格中的一个,它出现1次或不出现(?),最后是8个数字(\d{8})。

    不幸的是,刚才那个表达式也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题,我们需要用到分枝条件。正则表达式里的分枝条件指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,具体方法是用|把不同的规则分隔开。听不明白?没关系,看例子:
    0\d{2}-\d{8}|0\d{3}-\d{7} 这个表达式能匹配两种以连字号分隔的电话号码:一种是三位区号,8位本地号(如010-12345678),一种是4位区号,7位本地号(0376-2233445)。

    (0\d{2})[- ]?\d{8}|0\d{2}[- ]?\d{8} 这个表达式匹配3位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。

    \d{5}-\d{4}|\d{5} 这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字,或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题:使用分枝条件时,要注意各个条件的顺序。如果你把它改成\d{5}|\d{5}-\d{4}的话,那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时,将会从左到右地测试每个条件,如果满足了某个分枝的话,就不会去再管其它的条件了。

    分组
    我们已经提到了怎么重复单个字符(直接在字符后面加上限定符就行了);但如果想要重复多个字符又该怎么办?你可以用小括号来指定子表达式(也叫做分组),然后你就可以指定这个子表达式的重复次数了,你也可以对子表达式进行其它一些操作。例如:
    (\d{1,3}.){3}\d{1,3} 是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配1到3位的数字,(\d{1,3}.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})。
    不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:(2[0-4]\d|25[0-5]|[01]?\d\d?).){3}(2[0-4]\d|25[0-5]|[01]?\d\d?
    (PS: IP地址中每个数字都不能大于255。IP 地址里的数字可以包含有前导 0 (leading zeroes),所以01.02.03.04 这样前面带有0的数字, 是正确的IP地址。)

    反义
    有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义。
    常用的反义正则表达式:
    \W 匹配任意不是字母,数字,下划线,汉字的字符
    \S 匹配任意不是空白符的字符
    \D 匹配任意非数字的字符
    \B 匹配不是单词开头或结束的位置
    [^x] 匹配除了x以外的任意字符
    [^aeiou] 匹配除了aeiou这几个字母以外的任意字符
    例子:\S+ 匹配不包含空白符的字符串。
    <a[^>]+> 匹配用尖括号括起来的以a开头的字符串。

    后向引用
    后向引用用于重复搜索前面某个分组匹配的文本。使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组的左括号为标志,第一个出现的分组的组号为1,第二个为2,以此类推。例如,\1代表分组1匹配的文本。

    请看一个较为复杂的示例:
    \b(\w+)\b\s+\1\b 可以用来匹配重复的单词,像go go, 或者kitty kitty。这个表达式首先是一个单词,也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b),这个单词会被捕获到编号为1的分组中,然后是1个或几个空白符(\s+),最后是分组1中捕获的内容,也就是前面匹配的那个单词(\1)。

    你也可以自己指定子表达式的组名。要指定一个子表达式的组名,请使用这样的语法:(?<Word>\w+)(或者把尖括号换成 ’ 也行:(?‘Word’\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容,你可以使用\k<Word>,所以上一个例子也可以写成这样:\b(?<Word>\w+)\b\s+\k<Word>\b。

    (?:exp) 不会改变正则表达式的处理方式,只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面,也不会拥有组号。你可以使用(?:exp)这样的语法来剥夺一个分组对组号分配的参与权。

    常用的捕获正则表达式 :
    (exp) 匹配exp,并捕获文本到自动命名的组里
    (?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name’exp)
    (?:exp) 匹配exp,不捕获匹配的文本,也不给此分组分配组号

    零宽断言
    零宽断言指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。
    它用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们像\b,^,$那样用于指定一个位置,这个位置应该满足一定的条件(即断言),因此被称为零宽断言。

    下面给出几个例子:
    (?=exp) 也叫零宽度正预测先行断言,它断言自身出现的位置的后面能匹配表达式exp。比如:
    \b\w+(?=ing\b),匹配以ing结尾的单词的前面部分(除了ing以外的部分),例如查找I’m singing while you’re dancing.时,它会匹配sing和danc。
    (?<=exp) 也叫零宽度正回顾后发断言,它断言自身出现的位置的前面能匹配表达式exp。比如:
    (?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分),例如在查找reading a book时,它匹配ading。
    (?<=\s)\d+(?=\s) 匹配以空白符间隔的数字(再次强调,不包括这些空白符)。

    常用的零宽断言正则表达式:
    (?=exp) 匹配exp前面的位置
    (?<=exp) 匹配exp后面的位置
    (?!exp) 匹配后面跟的不是exp的位置
    (?<!exp) 匹配前面不是exp的位置

    负向零宽断言
    前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现,但并不想去匹配它时怎么办?例如,如果我们想查找这样的单词–它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样:
    \b\w*q[^u]\w*\b 匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐,直接就观察出来了),你会发现,如果q出现在单词的结尾的话,像Iraq,Benq,这个表达式就会出错。这是因为[^u]总要匹配一个字符,所以如果q是单词的最后一个字符的话,后面的[^u]将会匹配q后面的单词分隔符(可能是空格,或者是句号或其它的什么),后面的\w*\b将会匹配下一个单词,于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题,因为它只匹配一个位置,并不消费任何字符。

    下面给出几个例子:
    (?!exp) 零宽度负预测先行断言,断言此位置的后面不能匹配表达式exp。例如:\d{3}(?!\d) 匹配三位数字,而且这三位数字的后面不能是数字;\b((?!abc)\w)+\b 匹配不包含连续字符串abc的单词。
    (?<!exp) 零宽度负回顾后发断言,断言此位置的前面不能匹配表达式exp。例如:(?<![a-z])\d{7} 匹配前面不是小写字母的七位数字。

    一个更复杂的例子:
    (?<=<(\w+)>).*(?=<\/\1>) 匹配不包含属性的简单HTML标签内里的内容。(?<=<(\w+)>)指定了这样的前缀:被尖括号括起来的单词(比如可能是<\b>),然后是 .* (任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/,它用到了前面提过的字符转义;\1则是一个反向引用,引用的正是捕获的第一组,前面的(\w+)匹配的内容,这样如果前缀实际上是<\b>的话,后缀就是</b>了。整个表达式匹配的是< b>和</b>之间的内容(再次提醒,不包括前缀和后缀本身)。

    注释
    (?#comment) 这种类型的分组不对正则表达式的处理产生任何影响,用于提供注释让人阅读
    小括号的另一种用途是通过语法(?#comment)来包含注释。例如:2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。

    贪婪与懒惰
    当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。以这个表达式为例:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。

    有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样 .*? 就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:

    a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab(第一到第三个字符)和ab(第四到第五个字符)。

    常用的懒惰正则表达式:
    *? 重复任意次,但尽可能少重复
    +? 重复1次或更多次,但尽可能少重复
    ?? 重复0次或1次,但尽可能少重复
    {n,m}? 重复n到m次,但尽可能少重复
    {n,}? 重复n次以上,但尽可能少重复

    本文部分引自:https://deerchao.net/tutorials/regex/regex.htm
    推荐一款在线的正则表达式调试工具:https://regex101.com/

    展开全文
  • 多个空格正则表达式

    万次阅读 2018-03-15 20:13:40
    //表示一个或多个空格正则表达式       str = str.trim();   //去掉字符串开头和结尾的空格       String str1 = str.replaceAll(regex,  "" );   //去掉所有的空格       String str2 = str....

    一、借鉴别人:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public class Test {
        public static void main(String[] args) {
             
            String str = "  kk kkk klaf    fsaff fsge tg sagh ger fsaga   ";
            //测试的字符串
             
            String regex = "\\s+";
            //表示一个或多个空格的正则表达式
             
            str = str.trim();
            //去掉字符串开头和结尾的空格
             
            String str1 = str.replaceAll(regex, "");
            //去掉所有的空格
             
            String str2 = str.replaceAll(regex, " ");
            //把一个或多个空格替换成一个空格
             
            System.out.println(str);
            System.out.println(str1);
            System.out.println(str2);
        }
    }

    输出结果如下:

    1
    2
    3
    kk kkk klaf    fsaff fsge tg sagh ger fsaga
    kkkkkklaffsafffsgetgsaghgerfsaga
    kk kkk klaf fsaff fsge tg sagh ger fsaga


    总结:

        \s* 表示若干个空格(可以是0个)。

        \s+ 表示一个或多个空格


    二、我的案例:

        有个txt文本,里面有一些字符串,以空格隔开,现在想要读取其中的文本,组成一个数据结构。。

    我们发现,里面每行数据是一组,整体又是一组,,字符串之间有若干空格,如LinkedList<LinkedList<String>>


    代码:

    public LinkedList<LinkedList<String>> getContentFromTxt(String filePath) {
        LinkedList<LinkedList<String>> linkedList = new LinkedList<LinkedList<String>>();
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(filePath));
            String lineString = "";
            String[] lineArray = null;
            String regex = "\\s+";
            while ((lineString = bufferedReader.readLine())!=null) {
                lineArray = lineString.split(regex);
                if(lineArray.length < 1){
                    continue;
                }
                LinkedList<String> innerList = new LinkedList<>();
                for (String str : lineArray) {
                    if("".equals(str) || str==null){
                        continue;
                    }
                    innerList.add(str);
                }
                linkedList.add(innerList);
            }
            bufferedReader.close();
            fileReader.close();
        }catch (Exception e){
            System.err.println("异常");
        }
        return linkedList;
    }
    运行结果:



    展开全文
  • 正则表达式教程及常用正则表达式

    千次阅读 2016-12-07 01:22:52
    正则表达式教程、常用正则表达式以及正则表达式测试工具

    什么是正则表达式

    在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。

    正则表达式元素介绍

    元字符

    1.元字符\b是正则表达式规定的一个特殊代码(好吧,某些人叫它元字符,metacharacter),代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格,标点符号或者换行来分隔的,但是\b并不匹配这些单词分隔字符中的任何一个,它只匹配一个位置。
    2.元字符\d是个新的元字符,匹配一位数字(0,或1,或2,或……)。
    3.元字符\s匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等。
    4.元字符\w匹配字母或数字或下划线或汉字等。
    5.元字符.是另一个元字符,匹配除了换行符以外的任意字符。
    6.元字符-不是元字符,只匹配它本身——连字符(或者减号,或者中横线,或者随你怎么称呼它)。
    7.元字符^和元字符$都匹配一个位置,这和 \b有点类似。^匹配你要用来查找的字符串的开头,$匹配结尾。比如一个网站如果要求你填写的QQ号必须为5位到12位数字时,可以使用:^\d{5,12}$

    这里写图片描述

    元字符释义

    1.0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串:以0开头,然后是两个数字,然后是一个连字号-,最后是8个数字(也就是中国的电话号码。当然,这个例子只能匹配区号为3位的情形)。
    为了避免那么多烦人的重复,我们也可以这样写这个表达式:0\d{2}-\d{8}。这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)。
    2.\ba\w*\b匹配以字母a开头的单词——先是某个单词开始处(\b),然后是字母a,然后是任意数量的字母或数字(\w*),最后是单词结束处(\b)。
    3.\b\w{6}\b 匹配刚好6个字符的单词。
    4.^\d{5,12}$, 因为使用了^$,所以输入的整个字符串都要用来和\d{5,12}来匹配,也就是说整个输入必须是5到12个数字,因此如果输入的QQ号能匹配这个正则表达式的话,那就符合要求了。
    和忽略大小写的选项类似,有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项,^$的意义就变成了匹配行的开始处和结束处。

    转义字符

    如果你想查找元字符本身的话,比如你查找 ., ,或者*,就出现了问题:你没办法指定它们,因为它们会被解释成别的意思。这时你就得使用\来取消这些字符的特殊意义。因此,你应该使用\.\*。当然,要查找\本身,你也得用\\

    例如:www.baidu.com匹配www.baidu.com,C:\Windows匹配C:\Windows。

    限定符

    你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码,例如*,{5,12}等
    这里写图片描述

    限定符释义

    1.元字符*同样是元字符,不过它代表的不是字符,也不是位置,而是数量——它指定*前边的内容可以连续重复使用任意次以使整个表达式得到匹配。因此,.*连在一起就意味着任意数量的不包含换行的字符。
    2.\d+匹配1个或更多连续的数字。这里的+是和*类似的元字符,不同的是*匹配重复任意次(可能是0次),而+则匹配重复1次或更多次。
    3.这里的{5,12}和前面介绍过的{2}是类似的,只不过{2}匹配只能不多不少重复2次,{5,12}则是重复的次数不能少于5次,不能多于12次,否则都不匹配。
    4.Windows\d+匹配Windows后面跟1个或更多数字
    5.^\w+匹配一行的第一个单词(或整个字符串的第一个单词,具体匹配哪个意思得看选项设置)

    字符类

    要想查找数字,字母或数字,空白是很简单的,因为已经有了对应这些字符集合的元字符,但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办?
    很简单,你只需要在方括号里列出它们就行了,[aeiou]就匹配任何一个英文元音字母
    [.?!]匹配标点符号.,?,!这三个中的任何一个。
    我们也可以轻松地指定一个字符范围,如[0-9]代表的含意与\d就是完全一致的:一位数字
    同理[a-z0-9A-Z_]也完全等同于\w(如果只考虑英文的话)。
    \(?0\d{2}[) -]?\d{8}是一个更复杂的表达式, ()也是元字符,后面的分组节里会提到,所以在这里需要使用转义。
    这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。我们对它进行一些分析吧:首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0,后面跟着2个数字(\d{2}),然后是)或-或空格中的一个,它出现1次或不出现(?),最后是8个数字(\d{8})。

    反义

    有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义

    这里写图片描述

    \S+匹配不包含空白符的字符串。
    <a[^>]+>匹配用尖括号括起来的以a开头的字符串。

    条件分支

    刚才那个表达式也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题,我们需要用到分支条件。正则表达式里的分枝条件指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,具体方法是用|把不同的规则分隔开。
    0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能匹配两种以连字号分隔的电话号码:一种是三位区号,8位本地号(如010-12345678),一种是4位区号,7位本地号(0376-2233445)。
    \(?0\d{2}\)?[- ]?\d{8}|0\d{2}[- ]?\d{8}这个表达式匹配3位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。
    \d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字,或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题:使用分支条件时,要注意各个条件的顺序。如果你把它改成\d{5}|\d{5}-\d{4}的话,那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分支条件时,将会从左到右地测试每个条件,如果满足了某个分支的话,就不会去再管其它的条件了。

    分组

    我们已经提到了怎么重复单个字符(直接在字符后面加上限定符就行了);但如果想要重复多个字符又该怎么办?你可以用小括号来指定子表达式(也叫做分组),然后你就可以指定这个子表达式的重复次数了,你也可以对子表达式进行其它一些操作(后面会有介绍)。
    (\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配1到3位的数字,(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})。
    不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)
    理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?,这里我就不细说了,你自己应该能分析得出来它的意义。

    分组之后向引用

    使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组的左括号为标志,第一个出现的分组的组号为1,第二个为2,以此类推。
    后向引用用于重复搜索前面某个分组匹配的文本。例如,\1代表分组1匹配的文本。

    分组之后向引用释义

    \b(\w+)\b\s+\1\b可以用来匹配重复的单词,像go go, 或者kitty kitty。这个表达式首先是一个单词,也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b),这个单词会被捕获到编号为1的分组中,然后是1个或几个空白符(\s+),最后是分组1中捕获的内容(也就是前面匹配的那个单词)(\1)。
    你也可以自己指定子表达式的组名。要指定一个子表达式的组名,请使用这样的语法:(?<Word>\w+)(或者把尖括号换成’也行:(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容,你可以使用\k<Word>,所以上一个例子也可以写成这样:\b(?<Word>\w+)\b\s+\k<Word>\b

    小括号的其他用法

    使用小括号的时候,还有很多特定用途的语法。下面列出了最常用的一些:

    这里写图片描述

    我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式,只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面,也不会拥有组号。

    零宽断言

    接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们像\b,^,$那样用于指定一个位置,这个位置应该满足一定的条件(即断言),因此它们也被称为零宽断言。

    零宽断言释义

    1.(?=exp)也叫零宽度正预测先行断言,它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b),匹配以ing结尾的单词的前面部分(除了ing以外的部分),如查找I’m singing while you’re dancing.时,它会匹配sing和danc。
    2.(?<=exp)也叫零宽度正回顾后发断言,它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分),例如在查找reading a book时,它匹配ading。
    3.假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了),你可以这样查找需要在前面和里面添加逗号的部分:(?<=\d)\d{3})+\b,用它对1234567890进行查找时结果是234567890。
    4.下面这个例子同时使用了这两种断言:(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调,不包括这些空白符)。

    负向零宽断言

    前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现,但并不想去匹配它时怎么办?例如,如果我们想查找这样的单词–它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样:
    \b\w*q[^u]\w*\b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐,直接就观察出来了),你会发现,如果q出现在单词的结尾的话,像Iraq,Benq,这个表达式就会出错。这是因为[^u]总要匹配一个字符,所以如果q是单词的最后一个字符的话,后面的[^u]将会匹配q后面的单词分隔符(可能是空格,或者是句号或其它的什么),后面的\w*\b将会匹配下一个单词,于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题,因为它只匹配一个位置,并不消费任何字符。现在,我们可以这样来解决这个问题:\b\w*q(?!u)\w*\b
    零宽度负预测先行断言(?!exp),断言此位置的后面不能匹配表达式exp。例如:\d{3}(?!\d)匹配三位数字,而且这三位数字的后面不能是数字;\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词。

    同理,我们可以用(?<!exp),零宽度负回顾后发断言来断言此位置的前面不能匹配表达式exp:(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。

    一个更复杂的例子:(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容。(?<=<(\w+)>)指定了这样的前缀:被尖括号括起来的单词(比如可能是<b>),然后是.*(任意的字符串),最后是一个后缀(?=</\1>)。注意后缀里的\/,它用到了前面提过的字符转义;\1则是一个反向引用,引用的正是捕获的第一组,前面的(\w+)匹配的内容,这样如果前缀实际上是<b>的话,后缀就是</b>了。整个表达式匹配的是<b></b>之间的内容(再次提醒,不包括前缀和后缀本身)。

    注释

    小括号的另一种用途是通过语法(?#comment)来包含注释。例如:2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)
    要包含注释的话,最好是启用“忽略模式里的空白符”选项,这样在编写表达式时能任意的添加空格,Tab,换行,而实际使用时这些都将被忽略。启用这个选项后,在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如,我们可以前面的一个表达式写成这样:

    (?<=    # 断言要匹配的文本的前缀
          <(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
          )       # 前缀结束
          .*      # 匹配任意文本
          (?=     # 断言要匹配的文本的后缀
          <\/\1>  # 查找尖括号括起来的内容:前面是一个"/",后面是先前捕获的标签
          )       # 后缀结束
    

    贪婪与懒惰

    当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。以这个表达式为例:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。
    有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:
    a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab(第一到第三个字符)和ab(第四到第五个字符)。
    这里写图片描述

    处理选项

    上面介绍了几个选项如忽略大小写,处理多行等,这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项:
    这里写图片描述

    一个经常被问到的问题是:是不是只能同时使用多行模式和单行模式中的一种?答案是:不是。这两个选项之间没有任何关系,除了它们的名字比较相似(以至于让人感到疑惑)以外。

    平衡组/递归匹配

    有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构,这时简单地使用\(.+\)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式,懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等,比如( 5 / ( 3 + 2 ) ) ),那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的,配对的括号之间的内容呢?
    为了避免(\(把你的大脑彻底搞糊涂,我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy这样的字符串里,最长的配对的尖括号内的内容捕获出来?

    这里需要用到以下的语法构造:
    (?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
    (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容,如果堆栈本来为空,则本分组的匹配失败
    (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话,继续匹配yes部分的表达式,否则继续匹配no部分
    (?!) 零宽负向先行断言,由于没有后缀表达式,试图匹配总是失败

    我们需要做的是每碰到了左括号,就在压入一个"Open",每碰到一个右括号,就弹出一个,到了最后就看看堆栈是否为空--如果不为空那就证明左括号比右括号多,那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符),尽量使整个表达式得到匹配。

    <                         #最外层的左括号
        [^<>]*                #最外层的左括号后面的不是括号的内容
        (
            (
                (?'Open'<)    #碰到了左括号,在黑板上写一个"Open"
                [^<>]*       #匹配左括号后面的不是括号的内容
            )+
            (
                (?'-Open'>)   #碰到了右括号,擦掉一个"Open"
                [^<>]*        #匹配右括号后面不是括号的内容
            )+
        )*
        (?(Open)(?!))         #在遇到最外层的右括号前面,判断黑板上还有没有没擦掉的"Open";如果还有,则匹配失败
    
    >                         #最外层的右括号
    

    平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签:<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>

    其他

    这里写图片描述

    20个常用的正则表达式

    1.校验密码强度

    密码的强度必须是包含大小写字母和数字的组合,不能使用特殊字符,长度在8-10之间。

    ^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
    

    2.校验中文

    字符串仅能是中文。

    ^[\u4e00-\u9fa5]{0,}$
    

    3.由数字、26个英文字母或下划线组成的字符串

    ^\w+$
    

    4.校验E-Mail地址

    同密码一样,下面是E-mail地址合规性的正则检查语句。

    [\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?
    

    5.校验身份证号码

    下面是身份证号码的正则校验。15或18位。

    15位:

    ^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$
    

    18位:

    ^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$
    

    6.校验日期

    “yyyy-mm-dd“格式的日期校验,已考虑平闰年。

    ^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$
    

    7.校验金额

    金额校验,精确到2位小数。

    ^[0-9]+(.[0-9]{2})?$
    

    8.校验手机号

    手机号以13、14、15、 17、18开头,九个 \d 数字字符

    ^1[34578]\\d{9}$
    

    9.判断IE的版本

    IE目前还没被完全取代,很多页面还是需要做版本兼容,下面是IE版本检查的表达式。

    ^.*MSIE[5-8](?:\.[0-9]+)?(?!.*Trident\/[5-9]\.0).*$
    

    10.校验IP-v4地址

    IP4正则语句。

    \b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b
    

    11.校验IP-v6地址

    IP6正则语句。

    (([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))
    

    12.检查URL的前缀

    应用开发中很多时候需要区分请求是HTTPS还是HTTP,通过下面的表达式可以取出一个url的前缀然后再逻辑判断。

    if(!s.match(/^[a-zA-Z]+:\/\//))
    {
    s='http://'+s;
    }
    

    13.提取URL链接

    下面的这个表达式可以筛选出一段文本中的URL。

    ^(f|ht){1}(tp|tps):\/\/([\w-]+\.)+[\w-]+(\/[\w-./?%&=]*)?
    

    14.文件路径及扩展名校验

    验证windows下文件路径和扩展名(下面的例子中为.txt文件)

    ^([a-zA-Z]\:|\\)\\([^\\]+\\)*[^\/:*?"<>|]+\.txt(l)?$
    

    15.提取ColorHexCodes

    有时需要抽取网页中的颜色代码,可以使用下面的表达式。

    ^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
    

    16.提取网页图片

    假若你想提取网页中所有图片信息,可以利用下面的表达式。

    \]*[src]*=*[\"\']{0,1}([^\"\'\>]*)
    

    17.提取页面超链接

    提取html中的超链接。

    (]*)(href="https?:\/\/)((?!(?:(?:www\.)?'.implode('|(?:www\.)?',$follow_list).'))[^"]+)"((?!.*\brel=)[^>]*)(?:[^>]*)>
    

    18.查找CSS属性

    通过下面的表达式,可以搜索到相匹配的CSS属性。

    ^\s*[a-zA-Z\-]+\s*[:]{1}\s[a-zA-Z0-9\s.#]+[;]{1}
    

    19.抽取注释

    如果你需要移除HMTL中的注释,可以使用如下的表达式。

    <br>
    

    20.匹配HTML标签

    通过下面的表达式可以匹配出HTML中的标签属性。

    <\/?\w+((\s+\w+(\s*=\s*(?:".*?"|'.*?'|[\^'">\s]+))?)+\s*|\s*)\/?>
    

    正则表达式简单说明

    /**
     *  语法:
     .       匹配除换行符以外的任意字符
     \w      匹配字母或数字或下划线或汉字
     \s      匹配任意的空白符
     \d      匹配数字
     \b      匹配单词的开始或结束
     ^       匹配字符串的开始
     $       匹配字符串的结束
     *       重复零次或更多次
     +       重复一次或更多次
     ?       重复零次或一次
     {n} 	重复n次
     {n,} 	重复n次或更多次
     {n,m} 	重复n到m次
     \W      匹配任意不是字母,数字,下划线,汉字的字符
     \S      匹配任意不是空白符的字符
     \D      匹配任意非数字的字符
     \B      匹配不是单词开头或结束的位置
     [^x] 	匹配除了x以外的任意字符
     [^aeiou]匹配除了aeiou这几个字母以外的任意字符
     *?      重复任意次,但尽可能少重复
     +?      重复1次或更多次,但尽可能少重复
     ??      重复0次或1次,但尽可能少重复
     {n,m}? 	重复n到m次,但尽可能少重复
     {n,}? 	重复n次以上,但尽可能少重复
     \a      报警字符(打印它的效果是电脑嘀一声)
     \b      通常是单词分界位置,但如果在字符类里使用代表退格
     \t      制表符,Tab
     \r      回车
     \v      竖向制表符
     \f      换页符
     \n      换行符
     \e      Escape
     \0nn 	ASCII代码中八进制代码为nn的字符
     \xnn 	ASCII代码中十六进制代码为nn的字符
     \unnnn 	Unicode代码中十六进制代码为nnnn的字符
     \cN 	ASCII控制字符。比如\cC代表Ctrl+C
     \A      字符串开头(类似^,但不受处理多行选项的影响)
     \Z      字符串结尾或行尾(不受处理多行选项的影响)
     \z      字符串结尾(类似$,但不受处理多行选项的影响)
     \G      当前搜索的开头
     \p{name} 	Unicode中命名为name的字符类,例如\p{IsGreek}
     (?>exp) 	贪婪子表达式
     (?<x>-<y>exp) 	平衡组
     (?im-nsx:exp) 	在子表达式exp中改变处理选项
     (?im-nsx)       为表达式后面的部分改变处理选项
     (?(exp)yes|no) 	把exp当作零宽正向先行断言,如果在这个位置能匹配,使用yes作为此组的表达式;否则使用no
     (?(exp)yes) 	同上,只是使用空表达式作为no
     (?(name)yes|no) 如果命名为name的组捕获到了内容,使用yes作为表达式;否则使用no
     (?(name)yes) 	同上,只是使用空表达式作为no
     
     捕获
     (exp)               匹配exp,并捕获文本到自动命名的组里
     (?<name>exp)        匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp)
     (?:exp)             匹配exp,不捕获匹配的文本,也不给此分组分配组号
     零宽断言
     (?=exp)             匹配exp前面的位置
     (?<=exp)            匹配exp后面的位置
     (?!exp)             匹配后面跟的不是exp的位置
     (?<!exp)            匹配前面不是exp的位置
     注释
     (?#comment)         这种类型的分组不对正则表达式的处理产生任何影响,用于提供注释让人阅读
     
     *  表达式:\(?0\d{2}[) -]?\d{8}
     *  这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。
     *  我们对它进行一些分析吧:
     *  首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0,后面跟着2个数字(\d{2}),然后是)或-或空格中的一个,它出现1次或不出现(?),
     *  最后是8个数字(\d{8})
     */
    

    验证数字的正则表达式集

    验证数字:^[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个英文字母或者下划线组成的字符串:^\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{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+)?
    

    正则表达式在线测试工具

    1.regex101
    2.正则表达式测试器
    3.Javascript正则表达式在线测试工具

    参考资料及推荐阅读:
    1.正则表达式语言 - 快速参考(中文)
    2.快速学习指南(英文)
    3.专业的正则表达式教学网站(英文)
    4.正则表达式30分钟入门教程
    5.知道这20个正则表达式,能让你少写1,000行代码

    展开全文
  • JAVA正则表达式匹配多个空格

    万次阅读 2017-09-22 19:59:46
    需求针对tab键带来的多个空格问题,有时候我们针对带空格的一行数据要进行切割,如果有多个空格就会出现就会切割空格出现,我们想把空格都去掉,所以需要用到某些方法。解决方案利用正则表达式来匹配空格\\s+首先...
  • 正则表达式,python正则表达式

    万次阅读 2020-04-01 17:36:26
    一、正则表达式主要元素 1)^ $ * ? + {3} {3,} {3,6} | 2) [] [^] [a-z] . 3) \s \S \w \W 4)[\u4E00-\u9FA5] () \d 先看看单个字符含义 字符 含义 ^ 以开头什么,如:^1[3456789]\d{9},以1开头...
  • java正则表达式详解

    万次阅读 多人点赞 2019-04-02 16:35:46
    一、正则表达式术语 1)元字符 : 非一般字符,具有某种意义的字符。如 : \bX : \b边界符, 以 X开始的单词 2)正则表达式语法大全 字符 说明 \ 将下一字符标记为特殊字符...
  • 正则表达式在线生成工具 http://tools.jb51.net/regex/create_reg 正则表达式详解 https://www.cnblogs.com/mingxiastory/p/5426913.html java正则表达式 ...java验证手机号和邮箱格式...
  • 匹配空格正则表达式
  • js正则表达式 以https://开头。空格,换行结尾,能够提取字符串中多个符合的部分
  • 如果你不熟悉这术语,那么“正则表达式”(Regular Expression)就是一字符构成的串,它定义了一用来搜索匹配字符串的模式。  正则表达式30分钟入门教程  常用正则表达式  许多语言,包括...
  • 正则表达式(一)认识正则表达式

    千次阅读 2014-03-13 01:39:03
    因为周二机试的题目就是写一关于邮箱验证的正则表达式。让我看到了公司对正则表达式的重视。现在有必要系统学习一下:我现在学习正则表达式主要看的书籍是:正则表达式经典实例和精通正则表达式,和正则表达式30...
  • JS正则表达式完整版

    万次阅读 多人点赞 2018-07-17 13:14:13
    第一章 正则表达式字符匹配攻略 1 两种模糊匹配 2. 字符组 3. 量词 4. 多选分支 5. 案例分析 第1章 小结 第二章 正则表达式位置匹配攻略 1. 什么是位置呢? 2. 如何匹配位置呢? 3. 位置的特性 4. 相关...
  • 正则表达式-正则表达式的元字符

    千次阅读 2016-10-21 18:57:57
    元字符是使用正则表达式不同于普通字符的地方,也是正则表达式能够发挥强大作用、具有强大表达能力的法宝。那么什么是元字符呢?元字符是一些在正则表达式中有特殊用途、不代表它本身字符意义的一组字符。利用元字符...
  • 表 1-1 常见正则表达式符号和特殊字符 表 示 法 描 述 正则表达式示例 符号 literal 匹配文本字符串的字面值 literal foo re1|re2 匹配正则表达式 re1 或者 re2 foo|bar . 匹配任何字符(除了\n 之外) b....
  • 今天小编就为大家分享一篇python 使用正则表达式按照多个空格分割字符的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 为什么要用正则表达: ...正则表达式就是一字符串格式的规则。 如何定义正则表达式。 var reg=/正则表达式/; //正则要用双 / / 包 起来 var result=reg.test(“字符串”);//验证字符串是否满足...
  • 不少编程高手说计算机领域称得上伟大的发明技术不,但正则表达式绝对算一。我姑且相信一回,来准备精通一下。 第一章正则表达式介绍  正则表达式相当于一我们要找的文本内容抽象集合模型,就是说我先建...
  • 正则表达式的切割:是指,我们按照正则表达式的规则对字符串来进行一些复杂的切割比方说现在我想按照多个空格来进行切割String str = "zhangsan lisei wangwu"; String reg = "\\s+"; //\\s在...
  • String line = "sss \t ddd aa \t ee"; String ln = line.replace("\t"," "... //把一个或多个空格替换成一个空格 String[] lns = ln.split(" ");  
  • 正则表达式(简称RE)本质上可以看作一小的、高度专业化的编程语言,在Python中可以通过re模块使用它。使用正则表达式,你需要为想要匹配的字符串集合指定一套规则,字符串集合可以包含英文句子、e-mail地址、TeX...
  • 在上一篇博文中,冷月带大家初步了解了正则表达式...表示一个正则表达式的开始和结束,一般用特殊符号来表示。简单来说就是用特殊符号把内容包住。 /……/ {……}我们来看一段示例代码: <?php var example...
  • 由于工作中用到正则表达式,一直没有好好学习正则表达式。在网上找到了原版的精通正则表达式(第三版)电子版,抽时间详细学习,下面对最近学到的做总结。 最近在进行安全检查漏洞修补,在做XSS攻击过滤器时,...
  • PLSQL中与正则表达式相关的运算函数主要有以下四: REGEXP_LIKE:返回指定字符串是否符合给定的正则表达式; REGEXP_SUBSTR:返回在指定字符串中截取出的符合给定正则表达式的子串; REGEXP_INSTR:...
  • jmeter里接口请求结束后,如果后续接口请求想要获取本次返回结果的内容,就需要正则表达式提取器来获取参数,当然也可以用json path extractor来提取(这简单一些)。不过Jmeter里很地方的约束条件和断言都是...
  • 目录介绍前言1. 什么是正则表达式?2. 基本匹配3. 元字符3.1. 英文句号3.2. 字符集3.2.1. 否定字符集3.3. 重复3.3.1. 星号(*)3.3.2. 加号(+)3.3.3. 问号(?)3.4. 花括号3.5. 字符组3.6. 分支结构3.7. 转义特殊字符3.8...
  • 该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行匹配。 这里说一下正则表达式表示空的方法: 在写个正则表达式的时候需要控制输入的字符串为...
  • 本次我们讲讲re正则表达式。那讲到re正则表达式的话,难免就需要跟其他的解析库做下对比。如下表 lxml库、正则表达式和BeautifulSoup库对比 工具 解析速度 难度 BeautifulSoup4 最慢 最简单 lxml 快 简单 ...
  • 使用Matcher类,最重要的一概念必须清楚:组(Group),在正则表达式中 ()定义了一组,由于一个正则表达式可以包含很的组,所以下面先说说怎么划分组的, 以及这些组和组的下标怎么对应的. 下面我们看看一小例子,...
  • 这些函数的第一参数是正则表达式字符串,其他参数跟模式对象同名的方法采用一样的参数;返回值也一样,同样是返回 None 或者匹配对象。 >>> print(re.match(r'From\s+', 'From_FishC.c

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 132,991
精华内容 53,196
关键字:

多个空格的正则表达式