精华内容
下载资源
问答
  • 正则表达式 最近学习的编译原理,基于NFA实现了正则表达式,代码刚写完,具体内容参考博客 ,欢迎查阅。已实现NFA转DFA,详见博客 。 目前还是demo,算是刚把引擎的骨架组装起来,后续继续完善代码。...
  • Java中的DFA regex引擎。 Pom设定 < groupId>top.yatt.dfargx < artifactId>dfargx < version>0.2.1 介绍 这是Java DFA regex引擎的实现。 高兼容性-单个jar库,无第3个依赖项 高性能-O(n)线性时间复杂度可...
  • java-regex正则表达式

    2014-07-23 11:05:07
    本文当是java正则表达式实例教程,从入门语法开始,结合源代码实例,详细讲解了java正则表达式用法和相关细节
  • Java —— 正则表达式 Regex

    万次阅读 2017-08-22 12:07:07
    Java正则表达式的语法与示例 java 正则表达式 语法 示例 概要: Java正则表达式的语法与示例 | |目录 1匹配验证-验证Email是否正确 2在字符串中查询字符或者字符串 3常用正则表达式 4正则表达式语法 ...
    转载自:http://baike.xsoftlab.net/view/207.html#4


    Java正则表达式的语法与示例

    概要:
    Java正则表达式的语法与示例

    一、匹配验证-验证Email是否正确

    public static void main(String[] args) {
        // 要验证的字符串
        String str = "service@xsoftlab.net";
        // 邮箱验证规则
        String regEx = "[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}\\.){1,3}[a-zA-z\\-]{1,}";
        // 编译正则表达式
        Pattern pattern = Pattern.compile(regEx);
        // 忽略大小写的写法
        // Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(str);
        // 字符串是否与正则表达式相匹配
        boolean rs = matcher.matches();
        System.out.println(rs);
    }



    二、在字符串中查询字符或者字符串

    public static void main(String[] args) {
        // 要验证的字符串
        String str = "baike.xsoftlab.net";
        // 正则表达式规则
        String regEx = "baike.*";
        // 编译正则表达式
        Pattern pattern = Pattern.compile(regEx);
        // 忽略大小写的写法
        // Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(str);
        // 查找字符串中是否有匹配正则表达式的字符/字符串
        boolean rs = matcher.find();
        System.out.println(rs);
    }



    三、常用正则表达式
    一个或多个汉字	^[\u0391-\uFFE5]+$ 
    邮政编码	^[1-9]\d{5}$(问题:邮政编码可以0开头。修正后为:^[0-9]{6}$或\d{6}等)
    QQ号码	^[1-9]\d{4,10}$ 
    邮箱	^[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}\.){1,3}[a-zA-z\-]{1,}$(问题:转义字符本身需要转义,即\.应为\\,其它地方同理.)
    用户名(字母开头 + 数字/字母/下划线)	^[A-Za-z][A-Za-z1-9_-]+$
    手机号码	^1[3|4|5|8][0-9]\d{8}$(手机号码第二位只能为3458?那也应该修正为:^1[3458]\d{9})
    URL	^((http|https)://)?([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
    18位身份证号	^(\d{6})(18|19|20)?(\d{2})([01]\d)([0123]\d)(\d{3})(\d|X|x)?$

    注:原来的有些错误,括号里的为自己修正过的。

    特别地:

    匹配只包含协议名、主机名的url:

    ^((http://)|(https://))?((w|W){3}\\.)?[A-Za-z0-9]+\\.((com)|(cn)|(org))$
    注意事项:

    见第六点。


    四、正则表达式语法

    元字符描述

    \

    转义字符

    ^

    匹配输开始位置。如果设置了RegExp对象的Multiline属性,^也匹配“\n”或“\r”之后的位置。

    $

    匹配结束位置。如果设置了RegExp对象的Multiline属性,$也匹配“\n”或“\r”之前的位置。

    *

    匹配前面的子表达式任意次。等价于{0,}。

    +

    比*特殊,匹配前面的子表达式一次或多次。等价于{1,}。

    匹配前面的子表达式0或1次。如"am?"可以匹配"a","do(es)?"可匹配"does"。等价于{0,1}。

    {n}

    匹配前面的子表达式确定的n次。如"o{2}"可匹配"hood"中的"oo"。

    {n,}

    匹配至少重复n次。

    {n,m}

    匹配至少重复n次,最多重复m次。


    非重点。当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串“oooo”,“o+?”将匹配单个“o”,而“o+”将匹配所有“o”。

    .

    匹配除“\r\n”之外的任何单个字符。要匹配包括“\r\n”在内的任何字符,请使用像“[\s\S]”的模式

    (pattern)

    pattern 为子表达式。使用圆括号字符需转义。

    (?:pattern)

    匹配pattern但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用或字符“(|)”来

    组合一个模式的各个部分是很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达

    式。当然此处|可替换为其它匹配方式。

    (?=pattern)

    正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需

    要获取供以后使用。例如,“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”,但不能匹配

    “Windows3.1”中的“Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始

    下一次匹配的搜索,而不是从包含预查的字符之后开始。

    (?!pattern)

    正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不

    需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”,但不能匹配

    “Windows2000”中的“Windows”。

    (?<=pattern)

    反向肯定预查,与正向肯定预查类似,只是方向相反。例如,“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”

    中的“Windows”,但不能匹配“3.1Windows”中的“Windows”。

    (?<!pattern)

    反向否定预查,与正向否定预查类似,只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中

    的“Windows”,但不能匹配“2000Windows”中的“Windows”。

    x|y

    或。

    [xyz]

    匹配字符集合。

    [^xyz]

    不匹配字符集合。

    [0-9]

    匹配数字。

    [a-z]

    匹配小写字母。

    [A-Z]

    匹配大写字母。(以此开始的前三个可自由组合,如[a-zA-Z])

    [^a-z]

    匹配非该范围内的字母。对大写同理。

    \b

    匹配单词边界。例如,“er\b”可以匹配“never”中的“er”,但不能匹配“verb”中的“er”。boundary

    \B

    作用与\b相反。

    \d

    匹配一个数字字符。等价于[0-9]。digital
    \D

    匹配一个非数字字符。等价于[^0-9]。


    不常用:

    \cx

    匹配由x指明的控制字符。例如,\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则,将c视为一个原义的“c”字符。
    \f

    匹配一个换页符。等价于\x0c和\cL。
    \n

    匹配一个换行符。等价于\x0a和\cJ。
    \r

    匹配一个回车符。等价于\x0d和\cM。
    \s

    匹配任何不可见字符,包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
    \S

    匹配任何可见字符。等价于[^ \f\n\r\t\v]。
    \t

    匹配一个制表符。等价于\x09和\cI。
    \v

    匹配一个垂直制表符。等价于\x0b和\cK。
    \w

    匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”,这里的"单词"字符使用Unicode字符集。
    \W

    匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
    \xn

    匹配n,其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如,“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。
    \num

    匹配num,其中num是一个正整数。对所获取的匹配的引用。例如,“(.)\1”匹配两个连续的相同字符。
    \n

    标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式,则n为向后引用。否则,如果n为八进制数字(0-7),则n为一个八进制转义值。
    \nm

    标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式,则nm为向后引用。如果\nm之前至少有n个获取,则n为一个后跟文字m的向后引用。如果前面的条件都不满足,若n和m均为八进制数字(0-7),则\nm将匹配八进制转义值nm。
    \nml

    如果n为八进制数字(0-7),且m和l均为八进制数字(0-7),则匹配八进制转义值nml。
    \un

    匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。例如,\u00A9匹配版权符号(&copy;)。
    \< \>

    匹配词(word)的开始(\<)和结束(\>)。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the",但是不能匹配字符串"otherwise"中的"the"。注意:这个元字符不是所有的软件都支持的。
    \( \)

    将 \( 和 \) 之间的表达式定义为“组”(group),并且将匹配这个表达式的字符保存到一个临时区域(一个正则表达式中最多可以保存9个),它们可以用 \1 到\9 的符号来引用。
    |

    将两个匹配条件进行逻辑“或”(Or)运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her",但是不能匹配"it belongs to them."。注意:这个元字符不是所有的软件都支持的。
    +

    匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。注意:这个元字符不是所有的软件都支持的。
    ?

    匹配0或1个正好在它之前的那个字符。注意:这个元字符不是所有的软件都支持的。
    {i} {i,j}

    匹配指定数目的字符,这些字符是在它之前的表达式定义的。例如正则表达式A[0-9]{3} 能够匹配字符"A"后面跟着正好3个数字字符的串,例如A123、A348等,但是不匹配A1234。而正则表达式[0-9]{4,6} 匹配连续的任意4个、5个或者6个数字



    五、较常用简单总结

    匹配位置:

    ^(开始位置)、$(结束位置)、\b(单词边界)、\B(非单词边界)

    匹配值:

    x|y、[a-zA-Z0-9]、[xyz]、[^xyz]、(pattern)、(?:pattern)、(?=pattern)(正向肯定预查)、(?!pattern)(正向否定预查)、(?<=pattern)、(?<!pattern)

    正向预查:

    预测字符串后面的值等于(=)或不等于(!)pattern匹配的值

    反向预查:

    预测字符串前面的值等于(<=)或不等于(<!)pattern匹配的值

    匹配值重复次数:

    {n}(重复n次)、{n,m}(至少n次,最多m次)、{n,}(最少n次)、?(0或1次)、+(至少1次)、*(任意次)、元字符加?(非贪婪模式,匹配出现1次)


    六、部分注意事项

    1、[xyz]只匹配单个字符,所以[(ab)]也只能匹配a、b中的一个,而不能将ab作为整体匹配。

    2、匹配值重复次数{}里面只能为数字,不能再为匹配表达式。如:

    匹配url中域名www.或WWW.不能为:"((w|W){(3|0)}\\.)+",可改为:"((w|W){3}\\.)+",还应注意的是(w|W){3}除了可匹配www与WWW外,还能匹配wWw等,即它将几种|操作的字符视为一种字符,其出现次数为各字符出现次数相加。

    3、正则表达式中转义字符本身需要转义,如显示"("应加转义,即为"\(",但正则表达式中转义字符本身也需转义,所以应为"\\("。

    4、最好别单独用?(出现一次或0次)。原因:

    System.out.println(new String("www").replaceAll("a?", "替换"));

    结果为:替换w替换w替换w替换

    可见,两个字符之间它出现次数为0,也进行替换。

    5、当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的(尽可能少的匹配)。

    通过示例理解:

    System.out.println(new String("aaabbb").replaceAll(regex,"替换"));

    regex取值:结果。分析。

    "a*?":

    结果:替换a替换a替换a替换b替换b替换b替换。

    分析:单独的*匹配连续出现至少0次,所以*?匹配了最少次数(0),即匹配了aaabbb之间与前后的“空隙”,共7处。

    "a??":

    结果:结果同上。

    分析:?匹配连续出现0或1次,所以??匹配了最少次数(0)。

    "a+?":

    结果:替换替换替换bbb。

    分析:+至少匹配1次,所以+?匹配单个a。

    "{n}?":

    结果:替换abbb。

    分析:固定次数的有无?无差异。

    "{n,}?":

    结果:同上。

    分析:取决于n。

    "{n,m}?":

    结果:同上。

    分析:取决于n。


    练习:


    判断设置的密码(要求至少6位,必须包含数字与字母):

    //一个正则表达式无法判断同时包含字母与数字,所以用两个正则表达式
    
    String pass = "asdf12sa";//密码
    
    String regexNum = "[0-9]{1,}";//或"[0-9]+"
    
    String regexLetter ="[a-zA-Z]{1,}";//同上
    
    Pattern pattern1 = Pattern.complie(regexNum);
    
    Pattern pattern1 = Pattern.complie(regexLetter );
    
    Matcher m1 = pattern.matcher(pass);
    
    Matcher m2 = pattern.matcher(pass);
    
    if(m1.find()&&m2.find()){
    
    //密码格式合格
    
    }


    七、Pattern 与 Matcher 类








    展开全文
  • Java中关于Regex的问题

    2017-06-14 09:42:56
     at java.util.regex.Pattern.compile(Pattern.java:1702)  at java.util.regex.Pattern.(Pattern.java:1351)  at java.util.regex.Pattern.compile(Pattern.java:1028)  at java.util.regex.Pattern.matches...
  • java中的regex

    千次阅读 2017-03-26 13:59:39
    System.out.println(s1.matches(regex1));//true split方法,将字符串按照给定的正则表达式进行切割成字符串数组 String regex2="[a-z]{2}"; String s2="13a3ab349acb3"; System.out.println("s2.split(regex2...

    1.什么是正则表达式?

        正则表达式是具有特殊规则的字符串,也就是该字符串的内容不同,所表示的规范也不同。常常用于对一些复杂字符串的匹配、查找和替换等操作。
    

    2.正则表达式的含义及用法?

        部分正则表达式的含义如下:
        [abc]          //abc中任意一个字符
        [^abc]         //除了abc之外的任意字符
        [a-z]          //a-z中任意一个字符
        [a-zA-Z0-9]    //任意一个
        [a-z&&[^bc]]   //a-z中除了bc之外的任意一个字符
        x?             //表示0个或1个x
        x*             //表示0个或任意多个x
        x{n}           //表示n个x
        x+             //表示1个到任意多个x
        x{n,}          //表示n个到任意多个x
        x{n,m}         //表示n个到m个x
        ()            //表示分组
        ···
    
        正则表达式的用法如下:
        matches方法,将字符串与正则表达式进行匹配,成功则返回true
        String regex1="[0-9]{9}@qq.com"; //qq邮箱的匹配
        String s1="888888888@qq.com";
        System.out.println(s1.matches(regex1));//true
    
        split方法,将字符串按照给定的正则表达式进行切割成字符串数组
        String regex2="[a-z]{2}";
        String s2="13a3ab349acb3";
        System.out.println("s2.split(regex2)");//13a3 349 b3
    
        replaceAll方法,将符合正则表达式的部分替换为给定的字符串
        String regex3="\\d"; //任意一个数字字符,转义
        String s3="ab3c4d";
        System.out.println(s3.replaceAll(regex3,"k"));
        ...
    

    3.正则表达式常用于哪些场景?

        正则表达式使用比较常见,用户注册时账号密码的合法性验证、从用户页面输入的字符串中提取有效的字符串信息等...
    
    展开全文
  • import java.util.regex.Matcher 和 java.util.regex.Pattern,里面有很多方法可以用 package regextest; import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches ...

    前言

    什么是正则表达式?不同的网站的解释略有差别。在此我引用 wikipedia 的版本:In theoretical computer science and formal language theory, a regular expression (sometimes called a rational expression) is a sequence of characters that define a search pattern, mainly for use in pattern matching with strings, or string matching, i.e. “find and replace”-like operations. 直译过来就是:一个字符的序列,它定义了一个搜索模式

    很多编程语言内置了regex ( regular expression 的缩写 ) 的功能(都是一些大神写的算法,我们凡人学会使用就行了),不同的语言在语法定义上略有不同。我初次学习正则表达式,是基于 java 的正则表达式。

    来几个有用的网址。
    正则表达式快速入门
    常用的正则表达式集锦
    Java 正则表达式中文学习网站
    Java 正则表达式 English 学习网站
    在线测试 Grok 正则表达式网站
    Grok 正则表达式学习
    BM 算法详解,传说中的 Ctrl + F ?


    talk is cheap, show me the code

    String 的 regex

    String 有 4 个方法用到了 regex : matches( ),split( ), replaceFirst( ), replaceAll( )

    package regextest;
    
    public class RegexTestStrings
    {
        public final static String EXAMPLE_TEST = 
        "This is my small example string which I'm going to use for pattern matching   .";
    
        public static void main(String[] args)
        {
            // 判断是否是:第一个字符是‘word字符’的字符串
            System.out.println(EXAMPLE_TEST.matches("\\w.*")); 
    
            // 用 white spaces 拆开字符串,返回拆开后的String数组
            String[] splitString = (EXAMPLE_TEST.split("\\s+")); 
            System.out.println(splitString.length);
            for (String string : splitString)
            {
                System.out.println(string);
            }
    
            // 把符合正则式"\\s+"的字符串,全部替换成"才"
            System.out.println(EXAMPLE_TEST.replaceFirst("\\s+", "才")); 
    
            // 把符合正则式"\\s+"的字符串,全部替换成"才"
            System.out.println(EXAMPLE_TEST.replaceAll("\\s+", "才")); 
        }
    }
    
    

    输出结果:

    true
    15
    This
    is
    my
    small
    example
    string
    which
    I'm
    going
    to
    use
    for
    pattern
    matching
    .
    This才is my small example string which I'm going to use for pattern matching   .
    This才is才my才small才example才string才which才I'm才going才tousefor才pattern才matching才.
    

    java. util. regex

    import java.util.regex.Matcher 和 java.util.regex.Pattern,里面有很多方法可以用

    package regextest;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegexMatches
    {
    
        public static void main(String[] args)
        {
            String line = "The price for iPhone is 5288, which is a little expensive.";
            // 提取字符串中的唯一的数字,圆括号是用来分组的, ^ 是“取反”的意思
            String regex = "(.*[^\\d])(\\d+)(.*)";
    
            // 创建 Pattern 对象
            Pattern pattern = Pattern.compile(regex);
    
            // 创建 matcher 对象
            Matcher mather = pattern.matcher(line);
    
            if (mather.find())
            {
                System.out.println("Found value: " + mather.group(2));
            }
            else
            {
                System.out.println("NO MATCH");
            }
        }
    
    }
    

    输出结果:

    Found value: 5288
    

    grok 更加强大的 regex

    在 Matcher,Pattern 的基础上, import 了很多包;进行了升级,可以调用的方法更多,更加强大。

    import com.google.code.regexp.Matcher;
    import com.google.code.regexp.Pattern;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.Reader;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.TreeMap;
    import org.apache.commons.lang3.StringUtils;

    某网站对Grok的定义:
    Java Grok is simple tool that allows you to easily parse logs and other files (single line). With Java Grok, you can turn unstructured log and event data into structured data (JSON).

    Java Grok program is a great tool for parsing log data and program output. You can match any number of complex patterns on any number of inputs (processes and files) and have custom reactions.

    一个简单的例子:从日志文件中读取数据,提取想要的信息:一是时间,二是来源IP

    输入:

    Mon Nov  9 06:47:33 2015; UDP; eth1; 461 bytes; from 88.150.240.169:tag-pm to 123.40.222.170:sip
    Mon Nov  9 06:47:34 2015; UDP; eth1; 463 bytes; from 88.150.240.169:49208 to 123.40.222.170:sip
    Mon Nov  9 06:47:34 2015; UDP; eth1; 463 bytes; from 88.150.240.169:54159 to 123.40.222.170:sip
    Mon Nov  9 06:47:34 2015; UDP; eth1; 463 bytes; from 88.150.240.169:53640 to 123.40.222.170:sip
    Mon Nov  9 06:47:34 2015; UDP; eth1; 463 bytes; from 88.150.240.169:52483 t
    package com.yz.utils.grok.api;
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class GrokTest
    {
    
            public static void main(String[] args)
            {
                FileInputStream   fiStream = null;
                InputStreamReader iStreamReader = null;
                BufferedReader    bReader = null; 
                //用于包装InputStreamReader,提高处理性能。因为BufferedReader有缓冲的,而InputStreamReader没有。
    
            try
            {
                String line = "";
                // 从文件系统中的某个文件中获取字节
                fiStream = new FileInputStream("C:\\dev1\\javagrok\\javagrok\\iptraf_eth1_15.06.11"); 
    
                // InputStreamReader 是字节流通向字符流的桥梁
                iStreamReader = new InputStreamReader(fiStream); 
    
                // 从字符输入流中读取文件中的内容,封装了一个new InputStreamReader的对象
                bReader = new BufferedReader(iStreamReader);     
    
                Grok grok = new Grok();
                // Grok 提供了很多现成的pattern,可以直接拿来用。用已有的pattern,来构成新的pattern。
                 grok.addPatternFromFile("c:\\dev1\\cloudshield\\patterns\\patterns"); 
    
                grok.addPattern("fromIP", "%{IPV4}");
                // compile 一个 pattern,期间我被空格坑了一下
                grok.compile(".*%{MONTH}\\s+%{MONTHDAY}\\s+%{TIME}\\s+%{YEAR}.*%{fromIP}.* to 123.40.222.170:sip"); 
                Match match = null;
    
                while((line = bReader.readLine()) != null)       // 注意这里的括号,被坑了一次
                {
                    match = grok.match(line);
                    match.captures();
                    if(!match.isNull())
                    {
                        System.out.print(match.toMap().get("YEAR").toString() + " ");
                        System.out.print(match.toMap().get("MONTH").toString() + " ");
                        System.out.print(match.toMap().get("MONTHDAY").toString() + " ");
                        System.out.print(match.toMap().get("TIME").toString() + " ");
                        System.out.print(match.toMap().get("fromIP").toString() + "\n");
                    }
                    else
                    {
                        System.out.println("NO MATCH");
                    }
                }
    
            }
            catch (FileNotFoundException fnfe)
            {
                System.out.println("file not found exception");
                fnfe.printStackTrace();
            }
            catch (IOException ioe)
            {
                System.out.println("input/output exception");
                ioe.printStackTrace();
            }
            catch (Exception e)
            {
                System.out.println("unknown exception");
                e.printStackTrace();
            }
            finally
            {
                try
                {
                    if(bReader!=null)   
                    {
                        bReader.close();
                        bReader=null;
                    }
                    if(iStreamReader!=null)
                    {
                        iStreamReader.close();
                        iStreamReader=null;
                    }
                    if(fiStream!=null)
                    {
                        fiStream.close();
                        fiStream=null;
                    }
                }
                catch(IOException ioe)
                {
                    System.out.println("input/output exception");
                    ioe.printStackTrace();
                }
            }
        }
    
    }
    

    输出:

    2015 Nov 9 06:47:33 88.150.240.169
    2015 Nov 9 06:47:34 88.150.240.169
    2015 Nov 9 06:47:34 88.150.240.169
    2015 Nov 9 06:47:34 88.150.240.169
    NO MATCH
    展开全文
  • JAVA replaceAll regex和replacement转义

    千次阅读 2018-05-03 11:36:03
    JAVA replaceAll regex和replacement转义 JAVA replaceAll regex和replacement转义 replacement转义 regex转义 replacement转义 有下面这段代码: public static void main(String[] args){ System....

    JAVA replaceAll regex和replacement转义

    replacement转义

    有下面这段代码:

    public static void main(String[] args){
        System.out.println("abcdef".replaceAll("abc","$"));//1
        System.out.println("abcdef".replaceAll("abc", "\\"));//2
    }

    咋一看没毛病,但是运行会报错:

    1:Exception in thread "main" java.lang.IllegalArgumentException: Illegal group reference: group index is missing
    2:Exception in thread "main" java.lang.IllegalArgumentException: character to be escaped is missing

    因为\$replacement中的特殊字符,前者用来转义,后者用来匹配组并使用$n来引用第n个组。它们的正确使用方法如下:

    System.out.println("abcdef".replaceAll("abc", "\\\\"));// \def
    System.out.println("abcdef".replaceAll("abc", "\\$"));// $def
    System.out.println("www.baidu.com".replaceAll("(.*)\\.(baidu)\\.(.*)", "https://$1.google.$3"));// https://www.google.com

    可以看出这两个特殊字符的作用了,所以如果replacement里面包含有这两个特殊字符,却没有按照需要的规则来匹配,就会报错。除了直接使用\转义以外,还有一种方法在不知道replacement中是否包含特殊字符是特别有用:

    public static void main(String[] args){
        System.out.println(replaceAll("abcdef","abc", "\\"));
        System.out.println(replaceAll("abcdef","abc", "$"));
    }
    
    public static String replaceAll(String s,String regex,String replacement){
        return s.replaceAll(regex,Matcher.quoteReplacement(replacement));
    }

    使用Matcher.quoteReplacement(replacement)就能将replacement中的所有特殊字符转义,是一种非常保险的方法,Matcher.quoteReplacement()就是一个转义的操作:

    /**
     * Returns a literal replacement <code>String</code> for the specified
     * <code>String</code>.
     *
     * This method produces a <code>String</code> that will work
     * as a literal replacement <code>s</code> in the
     * <code>appendReplacement</code> method of the {@link Matcher} class.
     * The <code>String</code> produced will match the sequence of characters
     * in <code>s</code> treated as a literal sequence. Slashes ('\') and
     * dollar signs ('$') will be given no special meaning.
     *
     * @param  s The string to be literalized
     * @return  A literal string replacement
     * @since 1.5
     */
    public static String quoteReplacement(String s) {
        if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
            return s;
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<s.length(); i++) {
            char c = s.charAt(i);
            if (c == '\\' || c == '$') {
                sb.append('\\');
            }
            sb.append(c);
        }
        return sb.toString();
    }

    regex转义

    replacement类似的,如果regex中有字符需要转义,也可主动加\来转义,但是在不确定regex中是否有特殊字符时,可能就会出错:

    public static void main(String[] args){
        System.out.println(replaceAll("My name is ${name}","${name}", "Hanmeimei"));
    }
    
    public static String replaceAll(String s,String regex,String replacement){
        return s.replaceAll(regex,Matcher.quoteReplacement(replacement));
    }
    Exception in thread "main" java.util.regex.PatternSyntaxException: Illegal repetition near index 0
    ${name}
    ^

    在确定regex中不包含正则表达式的时候,可以使用Pattern.quote()来转义:

    public static void main(String[] args){
        System.out.println(replaceAll("My name is ${name}","${name}", "Hanmeimei"));//My name is Hanmeimei
    }
    
    public static String replaceAll(String s,String regex,String replacement){
        return s.replaceAll(Pattern.quote(regex),Matcher.quoteReplacement(replacement));
    }
    展开全文
  • Chapter 3: Java Regex Classes Chapter 4: Regex for Username Chapter 5: Regex for Password Chapter 6: Regex for Email Chapter 7: Regex Color Coding Chapter 8: Regex for Image Files Chapter 9: Regex for...
  • 自己整理的关于java和jscookie的实际应用,以及regex的应用,绝对好用。
  • 本文给大家分享java使用正则表达式匹配中文的实例代码,以及java中要匹配中文的正则表达式两写法,感兴趣的朋友通过本文一起看看吧
  • 范例1:Pattern类import ...import java.util.regex.Pattern; public class Demo { public static void main(String[] args) throws Exception { String str = "hjkhasjkghjk1123sdfasdf"; String ...
  • matches方法 ...java.util.regex.Pattern类中最常用的方法是matches(String regex, CharSequence input)、split(CharSequence input)、split(CharSequence input, int limit)。 matches方法 p...
  • jregexdebugger是Java正则表达式(regex)模式的调试器
  • StackOverflowError in java.util.regex.Pattern 引擎与回溯 这里引用下一位老哥的原文,简单介绍下正则表达式的引擎和回溯机制。 正则引擎主要可以分为基本不同的两大类:一是DFA(确定型有穷自动机),...
  • Java Regex To Use

    2019-03-14 01:13:57
    NULL 博文链接:https://log-cd.iteye.com/blog/199661
  • 先贴出异常 服务器的CPU使用率一直保持在10%左右,...是java进程跑死的,只能找java进程下哪些线程高cpu使用率 问题线程已经找到 USER %CPU PRI SCNT WCHAN USER SYSTEM TID TIME [root@27a2a017-029b-48d8-...
  • 正则表达式 基本 Java 正则表达式解释器
  • 最近线上项目出现了java.util.regex.PatternSyntaxException,项目也没什么改动,除了特殊 字符表的字符集由于原来是utf8编码的字符集,不支持4个字节的字符,修改成了utf8mb4字节,其余 的也没什么改动.异常原因如下 ...
  • 代码生成比较 Java regex / Groovy / ANTLR 代码生成对比
  • java.util.regex包下Pattern、Matcher类学习

    千次阅读 2018-04-07 15:02:12
    java.util.regex包下Pattern、Matcher类学习 此文所有的程序代码地址:RegularExperssion java.util.regex包主要包括以下三个类: Pattern 类 Matcher 类 PatternSyntaxException 类 PatternSyntaxException 是...
  • java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherTest { public static void main (String[] args) { repalceAllTest(); } public static void ...
  • 以###1###开头, ###2###结尾的 String word = "adlsfjlsajflksadjlfdsajfljdfka"... String regex = "(s?)###1###.*?###2###"; Pattern p = Pattern.compile(regex); String[] contents = p....
  • 这是一个简单的正则表达式应用jar包,通过调用其内部方法可实现java的一系列验证,提取和清洗的方法,内附帮助文档,使用非常简单,希望可以为广大编程爱好者编程提供方便,欢迎下载!
  • java regex例子

    2009-01-01 18:32:52
    学习regex的好例子,感觉挺好的。 学习regex的好例子,感觉挺好的。
  • Java Regex中Matcher类的group(int m)方法

    千次阅读 2016-03-27 22:47:24
    Java Regex中Matcher类的group(int m)方法
  • java中有一个非常好用的方法,把字符串分割成数组,那就是split方法。1.比较常用的split(regex)方法参数为分割的字符串或者正则表达式根据字符串中的分割符,进行拆分成字符串数组,直接上代码package ...
  • import java.util.regex.Pattern的问题

    千次阅读 2018-01-24 19:02:24
    第一个xx说:The import java.util.regex.Pattern cannot be resolved 第二个:Pattern cannot be resolved to a type 试了网上好多方法,最后发现是用的JDK是1.8的,Eclipse版本太旧了,在Eclipse官网下载最新...
  • Pattern.matches();是静态方法。此方法需要传入两个参数第一个参数为:我们的正则表达式第二个参数为:我们想要验证的数据返回值为 boolean类型,符合正则表达式 返回true 否则返回false---------------------------...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,660
精华内容 40,664
关键字:

java种的regex

java 订阅