java 正则表达式 网络资料

java.util.regex 包,包括了两个类，

    Pattern(模式类)    和    Matcher(匹配器类)。

    Pattern 类是用来表达和陈述所要搜索模式的对象，

    Matcher 类是真正影响搜索的对象。

    PatternSyntaxException，当遇到不合法的搜索模式时，会抛出。

    一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。

   正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

Pattern type_pattern_ = Pattern.compile("^type:[0-9]");

设计一个简单的表达式来匹配电话号码数字。比如:(212) 555-1212， 212-555-1212和212 555 1212 。

　　首先让我们构成一个正则表达式: (nnn)nnn-nnnn。

　　创建一个pattern对象来匹配上面的子字符串。

                    匹配上面格式的正则表达可以这样构成:(/d{3})/s/d{3}-/d{4}

　　对java的解释器来说，在反斜线字符(/)前的字符有特殊的含义。

        与regex有关的包，并不都能理解和识别反斜线字符(/)，应该用双反斜线字符(/)。

        此外圆括号在正则表达中两层含义，如果想让它解释为字面上意思(即圆括号)，也需要用双反斜线字符(/)。

　　            匹配上面格式的正则表达可以这样构成: //(//d{3}//)//s//d{3}-//d{4}

　　下面的一段代码实现的功能是，从一个文本文件逐行读入，并逐行搜索电话号码数字，一旦找到所匹配的，然后输出在控制台。

　　BufferedReader in;

　　Pattern pattern = Pattern.compile("//(//d{3}//)//s//d{3}-//d{4}");

　　in = new BufferedReader(new FileReader("phone"));

　　String s;

　　while ((s = in.readLine()) != null){

　　    Matcher matcher = pattern.matcher(s);

             //仅用在每行只能含有一个匹配的电话号码数字字符串时。

　　    if (matcher.find()){     

　　        System.out.println(matcher.group());

　　    }

　　}

　　in.close();

　　find()方法，就像你所想象的，用来搜索与正则表达式相匹配的任何目标字符串，

        group()方法，用来返回包含了所匹配文本的字符串。

如果在电话号码的开头，即区位号和本地号码之间可能会有空格。

        在正则表达式中加入/s?来实现，其中?元字符表示在模式可能有0或1个空格符。

本地号码位的前三位和后四位数字间有可能是空格符，而不是连字号，更有胜者，或根本就没有分隔符

        可以用(-|)?来解决。这个结构的正则表达式就是转换器，它能匹配上面所说的几种情况。

        在()能含有管道符 | 时，它能匹配是否含有空格符或连字符，而尾部的?元字符表示是否根本没有分隔符的情况。

区位号也可能没有包含在圆括号内，

    对此可以简单地在圆括号后附上?元字符，但这不是一个很好的解决方法。

    因为它也包含了不配对的圆括号，比如"(555" 或 "555)"。

我们可以通过另一种转换器来强迫让电话号码是否带有有圆括号:(/(/d{3}/)|/d{3})。

        Pattern pattern = Pattern.compile("//(//d{3}//)//s//d{3}-//d{4}"); 改进后，就成了一个非常有用的匹配器:

　　 Pattern pattern = Pattern.compile("(//(//d{3}//)|//d{3})//s?//d{3}(-|)?//d{4}");

在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
Pattern Pattern.compile(String regex, int flag)

  flag的取值范围如下：
     Pattern.CANON_EQ     、 Pattern.CASE_INSENSITIVE(?i)  对大小写敏感   、 Pattern.COMMENTS(?x)    、
     Pattern.MULTILINE(?m)     、 Pattern.UNICODE_CASE(?u)     、 Pattern.UNIX_LINES(?d)     

// 反斜杠
/t 间隔 ('/u0009')
/n 换行 ('/u000A')
/r 回车 ('/u000D')
/f 换页符
/e Escape
/G 前一个匹配的结束


/d 数字 等价于[0-9]
/D 非数字 等价于[^0-9]
/s 空白符号 [/t/n/x0B/f/r]
/S 非空白符号 [^/t/n/x0B/f/r]
/w 单独字符 [a-zA-Z_0-9]
/W 非单独字符 [^a-zA-Z_0-9]

^：限制开头
    ^java     条件限制为以Java为开头字符
$：限制结尾
    java$     条件限制为以java为结尾字符
.  ：限制除/n以外任意一个单独字符
    java. .    条件限制为java后除换行外任意两个字符

/b 一个单词的边界
/B 一个非单词的边界

[]：加入特定限制条件「[]」
     [a-z]     条件限制在小写a to z范围中一个字符
     [A-Z]     条件限制在大写A to Z范围中一个字符
     [a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
     [0-9]     条件限制在小写0 to 9范围中一个字符
     [0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
     [0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)

[a-d[m-p]]               a 到 d 或 m 到 p：[a-dm-p]（并集）

[a-z&&[def]]             d、e 或 f（交集）

[a-z&&[^bc]]             a 到 z，除了 b 和 c：[ad-z]（减去）

[a-z&&[^m-p]]            a 到 z，而非 m 到 p：[a-lq-z]（减去）

[^]：[]中加入^后加再次限制条件「[^]」
     [^a-z]     条件限制在非小写a to z范围中一个字符
     [^A-Z]     条件限制在非大写A to Z范围中一个字符
     [^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
     [^0-9]     条件限制在非小写0 to 9范围中一个字符
     [^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
     [^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)

*：在限制条件为特定字符出现0次以上时，可以使用「*」
     J*     0个以上J
     .*     0个以上任意字符
     J.*D     J与D之间0个以上任意字符

+：在限制条件为特定字符出现1次以上时，可以使用「+」
     J+     1个以上J
     .+     1个以上任意字符
     J.+D     J与D之间1个以上任意字符

?：在限制条件为特定字符出现有0或1次以上时，可以使用「?」
    JA?     J或者JA出现

{a}：限制为连续出现指定次数字符「{a}」
     J{2}     JJ
     J{3}     JJJ

{a,}：文字a个以上，并且「{a,}」
     J{3,}     JJJ,JJJJ,JJJJJ,???(3次以上J并存)

{a,b}：文字个以上，b个以下「{a,b}」
     J{3,5}     JJJ或JJJJ或JJJJJ

|：两者取一「|」
    J|A     J或A
    Java|Hello     Java或Hello
 
()：「()」规定一个组合类型
    我查询index中间的数据，可写作(.+?)

几个简单的Java正则用例：
//查找以Java开头,任意结尾的字符串
  Pattern pattern = Pattern.compile("^Java.*");
  Matcher matcher = pattern.matcher("Java不是人");
  boolean b= matcher.matches();  //当条件满足时，将返回true，否则返回false
  System.out.println(b);

//以多条件分割字符串时   +：在限制条件为特定字符出现1次以上时
Pattern pattern = Pattern.compile("[, |]+");
String[] strs = pattern.split("Java Hello World  Java,Hello,,World|Sun");
for (int i=0;i
    System.out.println(strs[i]);
} 

//文字替换（首次出现字符）
Pattern pattern = Pattern.compile("正则表达式");
Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
//替换第一个符合正则的数据
System.out.println(matcher.replaceFirst("Java"));

//文字替换（全部）
Pattern pattern = Pattern.compile("正则表达式");
Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
//替换符合正则的数据
System.out.println(matcher.replaceAll("Java"));

//文字替换（置换字符）
Pattern pattern = Pattern.compile("正则表达式");
Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World ");
StringBuffer sbr = new StringBuffer();
while (matcher.find()) {
    matcher.appendReplacement(sbr, "Java");
}
matcher.appendTail(sbr);
System.out.println(sbr.toString());

//验证是否为邮箱地址
String str="[email protected]";
Pattern pattern = Pattern.compile("[//w//.//-]+@([//w//-]+//.)+[//w//-]+",Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(str);
System.out.println(matcher.matches());



+：在限制条件为特定字符出现1次以上时，可以使用「+」
?：在限制条件为特定字符出现有0或1次以上时，可以使用「?」

//去除html标记
Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL);
Matcher matcher = pattern.matcher("主页");
String string = matcher.replaceAll("");
System.out.println(string);

//查找html中对应条件字符串
Pattern pattern = Pattern.compile("href=/"(.+?)/"");
Matcher matcher = pattern.matcher("主页");
if(matcher.find())
  System.out.println(matcher.group(1));
}

//截取http://地址
//截取url
Pattern pattern = Pattern.compile("(http://|https://){1}[//w//.//-/:]+");
Matcher matcher = pattern.matcher("dsdsdsfdf");
StringBuffer buffer = new StringBuffer();
while(matcher.find()){              
    buffer.append(matcher.group());        
    buffer.append("/r/n");              
System.out.println(buffer.toString());
}
        
//替换指定{}中文字
String str = "Java目前的发展史是由{0}年-{1}年";
String[][] object={new String[]{"//{0//}","1995"},new String[]{"//{1//}","2007"}};
System.out.println(replace(str,object));
public static String replace(final String sourceString,Object[] object) {
            String temp=sourceString;    
            for(int i=0;i
                      String[] result=(String[])object[i];
               Pattern    pattern = Pattern.compile(result[0]);
               Matcher matcher = pattern.matcher(temp);
               temp=matcher.replaceAll(result[1]);
            }
            return temp;
}