Java 正则

正则表达式示例：

String text = "tytufvbnhjk" + "kiegurf http://www.baidu.com";
String pattern = ".*http://.*"; // 包含此字符串
boolean  matches = Pattern.matches(pattern, text);  //判断字符串中的是否包含http://
System.out.println("matches = " + matches);

java.util.regex包主要由以下三个类组成

pattern类 - 模式对象是正则表达式的编译表示。Pattern类不提供公共构造函数。要创建模式，必须首先调用其公共静态compile（）方法之一，然后返回Pattern对象。这些方法接受正则表达式作为第一个参数。

Matcher类 - Matcher对象是解释模式并对输入字符串执行匹配操作的引擎。与Pattern类一样，Matcher没有定义公共构造函数。通过在Pattern对象上调用matcher（）方法获取Matcher 对象。

PatternSyntaxException - PatternSyntaxException对象是未经检查的异常，指示正则表达式模式中的语法错误。

Subexpression	Matches
^	匹配行的开头
$	匹配行的末尾
[…]	匹配括号中任意单个字符
[^…]	匹配除括号中的任意单个字符
\A	整个字符串的开头
\z	整个字符串的结尾
\Z	匹配字符串的结尾,如果存在换行符，则它在换行符之前匹配。
re*	匹配前面表达式的0项或多项
re+	匹配前面表达式的1项或多项
re?	匹配前面表达式的0次或1次
re{n}	匹配表达式的n次
re{n,}	匹配前面表达式的n次或更多次
re{n,m}	匹配前面表达式的至少n次或最多m次
A | b	匹配A或b
\w	匹配一个字母字符
\W	匹配任意一个非字母字符
\s	匹配任意一个空白字符（\t\n\r\n）
\S	匹配任意一个非空包字符
\d	匹配任意一个数字字符，相当于[0-9]
\D	匹配任意一个非数字字符，相当于[^0-9]
(re)	分组匹配
(?: re)	在不记住匹配文本的情况下对正则表达式进行分组
(?> re)	在不回溯的情况下匹配独立模式
\G	匹配字符串最后的字符
\b	在括号外部匹配单词边界。在括号内匹配退格
\B	匹配非字符边界
\n,\t,etc	匹配换行符，回车符，制表符等
\Q	开始引用
\E	结束引用以\ Q开头

####方法
#####matches和lookingAt方法都尝试将输入数据与patter匹配，不同在于，matches需要匹配整个字符串，而lookingAt不需要.
例：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

结果

#####replaceFirst和replaceAll方法
两者的共同点是替换正则匹配出来的文本，不同在于，replaceFirst是替换匹配出的第一项，replaceAll是替换匹配出来的所有项
例：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

结果：

#####Pattern.compile()
如果需要匹配一个正则表达式在文本中多次出现，需要通过Pattern.compile() 方法创建一个Pattern对象

Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
 //Pattern.CASE_INSENSITIVE 忽略大小写

例：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {
   public static void main( String args[] ) {
        String text    =
        "This is the text to be searched " +
        "for occurrences of the http:// pattern.";
        String patternString = ".*http://.*";
        Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(text);
        boolean matches = matcher.matches();
        System.out.println("matches = " + matches);
   }
}

结果

#####split
通过制定字符将字符串分割
例：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {
   public static void main( String args[] ) {
        String text = "A sep Text sep With sep Many sep Separators";
        String patternString = "sep";
        Pattern pattern = Pattern.compile(patternString);
        String[] split = pattern.split(text);
        System.out.println("split.length = " + split.length);
        for(String element : split){
            System.out.println("element = " + element);
        }
   }
}

结果

####find() + start() + end()
find() 方法用于在文本中查找出现的正则表达式，文本是创建Matcher时，通过 Pattern.matcher(text) 方法传入的。如果在文本中多次匹配，find() 方法返回第一个，之后每次调用 find() 都会返回下一个。
start() 和 end() 返回每次匹配的字串在整个文本中的开始和结束位置。实际上, end() 返回的是字符串末尾的后一位，这样，可以在把 start() 和 end() 的返回值直接用在String.substring() 里。

String text    =
        "This is the text which is to be searched " +
        "for occurrences of the word 'is'.";
String patternString = "is";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);
int count = 0;
while(matcher.find()) {
    count++;
    System.out.println("found: " + count + " : "  + matcher.start() + " - " + matcher.end());
}

结果

found: 1 : 2 - 4
found: 2 : 5 - 7
found: 3 : 23 - 25
found: 4 : 70 - 72

#####reset()
reset() 方法会重置Matcher 内部的 匹配状态。当find() 方法开始匹配时,Matcher 内部会记录截至当前查找的距离。调用 reset() 会重新从文本开头查找。
也可以调用 reset(CharSequence) 方法. 这个方法重置Matcher,同时把一个新的字符串作为参数传入，用于代替创建 Matcher 的原始字符串。
#####group()

假设想在一个文本中查找URL链接，并且想把找到的链接提取出来。当然可以通过 start()和 end()方法完成。但是用group()方法更容易些。

分组在正则表达式中用括号表示，例如:
(John)
此正则表达式匹配John, 括号不属于要匹配的文本。括号定义了一个分组。当正则表达式匹配到文本后，可以访问分组内的部分。
使用group(int groupNo) 方法访问一个分组。一个正则表达式可以有多个分组。每个分组由一对括号标记。想要访问正则表达式中某分组匹配的文本，可以把分组编号传入 group(int groupNo)方法。
group(0) 表示整个正则表达式，要获得一个有括号标记的分组，分组编号应该从1开始计算。

贪婪模式	饥饿模式	独占模式
X?	X??	X?+	匹配0或1次
X*	X*?	X*+	匹配0次或多次
X+	X+?	X++	匹配1次或多次
X{n}	X{n}?	X{n}+	匹配n次
X{n,}	X{n,}?	X{n,}+	匹配至少n次
X{n,m}	X{n,m}?	X{n,m}+	匹配至少n次,最多m次