Java正则表达式

x 字符x
\\ 转义\
\0n The character with octal value 0n (0 <= n <= 7) 
\0nn The character with octal value 0nn (0 <= n <= 7) 
\0mnn The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7) 
\xhh 十六进制表示 value 0xhh 
\uhhhh The character with hexadecimal value 0xhhhh 
\x {h...h}十六进制值0xh…h的字符(Character.MIN_CODE_POINT  <= 0xh...h <=  Character.MAX_CODE_POINT) 
\t tab键字符 ('\u0009') 
\n 换行字符 ('\u000A') 
\r 回车字符 ('\u000D') 
\f 换页符('\u000C') 
\a 警铃字符 ('\u0007') 
\e 转义字符 ('\u001B') 
\cx 与x对应的控制字符,如\cM (Ctrl+M)

#Linebreak匹配器
\R 任何Unicode换行序列,都相当于\u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

#字符类运算符的优先级如下，从最高到最低：
1.Literal escape     	\x
2.Grouping 	[...]
3.Range 	a-z
4.Union 	[a-e][i-u]
5.Intersection 	[a-z&&[aeiou]]

#字符类一览表
* [abc] | [0-9]  #a、b 或 c（简单类）或者0到9的字符都包括
* [^abc]  #任何字符，除了 a、b 或 c（否定） 
* [a-zA-Z] #a到 z 或 A到 Z，两头的字母包括在内（范围） 
* [a-d[m-p]]    #并集 [a-dm-p] (union) 
* [a-z&&[def]] #交集
* [a-z&&[^bc]] #补集 [a-z&&[^m-p]];

* . 任何字符。
* \d 数字：[0-9]
* \D 非数字: [^0-9]
* \w 单词字符：[a-zA-Z_0-9]
* \W 非单词字符：[^\w]
* \h 水平空白字符: [\t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000] 
* \H 非水平空白字符:: [^\h] 
* \v 垂直空格字符:: [\n\x0B\f\r\x85\u2028\u2029]  
* \V 非垂直空格字符:: [^\v] 
* \s 空格字符: [ \t\n\x0B\f\r] 
* \S 非空格字符: [^\s]

#贪婪量词
* X? 一次或一次也没有
* X* 零次或多次
* X+ 一次或多次
* X{n} X恰好 n 次 
* X{n,} X至少 n 次 
* X{n,m} X至少 n 次


#非贪婪量词
X?? X, once or not at all 
X*? X, zero or more times 
X+? X, one or more times 
X{n}? X,匹配n次或者0次
X{n,}? X,至少n次
X{n,m}? X,至少n次，但不超过m次


#占有欲强的量词
X?+ X, once or not at all 
X*+ X, zero or more times 
X++ X, one or more times 
X{n}+ X, exactly n times 
X{n,}+ X, at least n times 
X{n,m}+ X, at least n but not more than m times

^ 行开头
$ 行结尾
\b 单词边界
\B 非单词边界
\A 输入的开始 (NEW)
\G 上次匹配结束 (NEW)
\Z 输入结束符但对于最终终止符，如果有的话  (NEW)
\z 输入结束 (NEW)

#Quotation 
\ Nothing, but quotes the following character 
\Q 只是以\E结尾的引用结束
\E 只是以\Q开头的引用结束

XY  X后面跟着Y
X|Y X或者Y
(X) X捕获组

#特殊的结构 Special constructs (named-capturing and non-capturing) 
(X)       #常规元组捕获
(?<name>X) #X,名称元组捕获named-capturing group 
(?:X) X, as a non-capturing group  #非补货组
(?idmsuxU-idmsuxU)  Nothing, but turns match flags i d m s u x U on - off 
(?idmsux-idmsux:X)   X, as a non-capturing group with the given flags i d m s u x on - off 

(?=X) X, via zero-width positive lookahead  #肯定型顺序环视 (从左到右) 当前位置的右边
(?!X) X, via zero-width negative lookahead  #否定型顺序环视

(?<=X) X, via zero-width positive lookbehind  #肯定型逆序环视 (从右到左) 当前位置的左边
(?<!X) X, via zero-width negative lookbehind  #否定型逆序环视

(?>X) X, as an independent, non-capturing group 


#Back references(向后引用)
\n 无论第n个捕获组匹配什么,如([a-z]) 可以采用\1调用元组捕获的值;
\k<name> 无论名称捕获组“name”匹配什么;

#POSIX character classes (US-ASCII only) 
\p{Lower} A lower-case alphabetic character: [a-z] 
\p{Upper} An upper-case alphabetic character:[A-Z] 
\p{ASCII} All ASCII:[\x00-\x7F] 
\p{Alpha} An alphabetic character:[\p{Lower}\p{Upper}] 
\p{Digit} A decimal digit: [0-9] 
\p{Alnum} An alphanumeric character:[\p{Alpha}\p{Digit}] 
\p{Punct} Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 
\p{Graph} A visible character: [\p{Alnum}\p{Punct}] 
\p{Print} A printable character: [\p{Graph}\x20] 
\p{Blank} A space or a tab: [ \t] 
\p{Cntrl} A control character: [\x00-\x1F\x7F] 
\p{XDigit} A hexadecimal digit: [0-9a-fA-F] 
\p{Space} A whitespace character: [ \t\n\x0B\f\r] 
  
#java.lang.Character classes (simple java character type) 
\p{javaLowerCase} Equivalent to java.lang.Character.isLowerCase() 
\p{javaUpperCase} Equivalent to java.lang.Character.isUpperCase() 
\p{javaWhitespace} Equivalent to java.lang.Character.isWhitespace() 
\p{javaMirrored} Equivalent to java.lang.Character.isMirrored() 
  
#Classes for Unicode scripts, blocks, categories and binary properties 
\p{IsLatin} A Latin script character (script) 
\p{InGreek} A character in the Greek block (block) 
\p{Lu} An uppercase letter (category) 
\p{IsAlphabetic} An alphabetic character (binary property) 
\p{Sc} A currency symbol 
\P{InGreek} Any character except one in the Greek block (negation) 
[\p{L}&&[^\p{Lu}]] Any letter except an uppercase letter (subtraction)

java.util.regex.Pattern 
#类定义
public final class Pattern
extends Object
implements Serializable


#类方法
public static Pattern compile(String regex) #将给定的正则表达式编译成模式。
#参数：regex -要编译的表达 
CANON_EQ 使正则等价。  
CASE_INSENSITIVE 启用不区分大小写匹配。  
COMMENTS 允许空格和注释模式。  
DOTALL 使dotall模式。  
LITERAL 启用模式的文本解析。  
MULTILINE 使多行模式。  
UNICODE_CASE 使用Unicode的折盒。  
UNICODE_CHARACTER_CLASS 使用Unicode版本的预定义字符类别和POSIX字符类。  
UNIX_LINES 使UNIX线模式。  

public static boolean matches(String regex,CharSequence input) #编译给定的正则表达式，并试图匹配给定的输入反对它。 
# Pattern.compile(regex).matcher(input).matches()  如果一个模式是要多次使用，编译它一次，并重用它将是更有效的比调用该方法，每一次。

public Matcher matcher(CharSequence input)  #创建一个匹配，将匹配给定的输入对该模式。

#语法结构
public final class Matcher
extends Object
implements MatchResult

#类常用方法
public boolean matches() #试图将整个区域与模式匹配。如果匹配成功则更多的信息可以通过start，end获得，并group方法。

public boolean find()  #试图找到匹配模式的输入序列中的下一个序列。匹配之后没有复位，在不匹配的第一个字符之前的比赛。如果匹配成功则更多的信息可以通过start，end获得，并group方法。

public String group()  #返回由以前的匹配输入序列。对于一个输入序列的匹配M，表达m.group()和s.substring(m start(), m.end())是等价的。

public String group(int group)  #返回被给定组以前的匹配操作在输入序列。 Capturing groups索引从左到右，在一开始。零组表示整个格局所以表达m.group(0)相当于m.group()。

public String group(String name)  #返回被给定的 named-capturing group之前匹配操作中的输入序列。在捕获组中设置了名称,向后引用的时候便可以直接调用该名称进行捕获调用 
groupCount

public int groupCount() #返回捕获组在这匹配的模式数。 组零表示的是整个模式的约定。它不包括在这个计数中。

public boolean matches(String regex)   #告诉是否这个字符串匹配给定 regular expression (这str.matches(正则表达式)产生完全相同的结果的表达形式的方法调用)

public String replaceFirst(String regex,String replacement) #代替这个字符串的替换，给 regular expression匹配第一个字符串。 (与Pattern.compile(regex).matcher(str).replaceFirst(repl)形式相同)

public String replaceAll(String regex,String replacement) #每个子串替换该字符串的给予更换，给 regular expression比赛。 (与Pattern.compile(regex).matcher(str).replaceAll(repl) 形式相同)

public String[] split(String regex)  #将此字符串在给定的 regular expression比赛。 
public String[] split(String regex, int limit) #将此字符串在给定的 regular expression比赛，limit分割次数;

/**
 *  * a:非正则表达式实现 
    * b:正则表达式实现
	*    需求: 校验qq号码
    * 1:要求必须是5-15位数字
    * 2:0不能开头
    * 3:必须都是数字
 */
package com.weiyigeek.regex;
public class Demo1_Regex {
  public static void main(String[] args) {
    //示例1.采用非正则表达式实现 param1 String
    String str = new String("12345678");
    System.out.println("非正则验证匹配 :  "+notRegex(str));
    
    //示例2：正则方式String.matches()
    System.out.println("正则匹配结果 : " + str.matches("^[1-9]\\d{4,14}"));
    System.out.println("正则匹配结果 : " + "01234579".matches("^[1-9]\\d{4,14}"));
  }

  private static boolean notRegex(String str) {
    boolean flag = false;
    if(str.length() > 4 && str.length() < 16){
      if(!str.startsWith("0")) {
        char[] arr = str.toCharArray();
        for (int i = 0; i < arr.length; i++) {
          if(arr[i] > '0' && arr[i] < '9') {
            flag = true;
          }else {
            break;
          }
        }
      }
    }
    return flag;
  }
}

非正则验证匹配 : true
正则匹配结果 : true
正则匹配结果 : false

//示例1.字符串分割采用正则表达式
strSpilt("I.LOVE.JAVA");
private static void strSpilt(String str) {
    String[] arr0 = str.split("\\.");  //关键点 1
    String[] arr1 = str.split("[.]");  //关键点 2
    for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }
    System.out.println("###########################");
}

//执行结果:
I
LOVE
JAVA

strSpiltInteger("91 48 75 76 82 10"); //字符串分割并且进行比较排序	
private static void strSpiltInteger(String st) {
    /**
        *  分析：
        * 1.将字符串转换成字符串数组
        * 2.将字符串转换成为数字并且存储在一个等长度的int数组中
        * 3.排序
        * 4.将排序后的结构钢遍历并拼接成为一个字符串;
        * */
    String[] sArr = st.split(" ");
    int[] iArr = new int[sArr.length]; //建立一个整形数组长度为字符串数组长度
    for (int i = 0; i < iArr.length; i++) {
        iArr[i] = Integer.valueOf(sArr[i]);  //将字符串转换成为数字
    }
    
    Arrays.sort(iArr);
    
    StringBuilder res = new StringBuilder();
    res.append("[ ");
    for (int i = 0; i < iArr.length; i++) {
        if( i == iArr.length - 1)
        {
            res.append(iArr[i] + " ]");
        }else{
            res.append(iArr[i] + " ");
        }
    }
    System.out.println(res);
}
//###########################
[ 10 48 75 76 82 91 ]

//示例2.正则表达式的替换功能(将数字替换掉)
System.out.println("字符串正则替换 : " + "We1iyi12Geek556".replaceAll("\\d",""));
//###########################
字符串正则替换 : WeiyiGeek

1.((A)(B(C))) 
2.(A)
3.(B(C)) 
4.(C)

package com.weiyigeek.regex;
public class Demo3_Regex {
  public static void main(String[] args) {
    //示例1.分组的使用(正则叠词) 开开心心,快快乐乐
    System.out.println("示例1-1 : " + "开开心心".matches("(.)\\1(.)\\2"));
    System.out.println("示例1-2 : " + "开心开心".matches("(..)\\1"));
    
    //示例2.切割需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
    String str = new String("sdqqfgkkkhjppppkl");
    String[] Arr = str.split("(.)\\1+");
    for (int i = 0; i < Arr.length; i++) {
      System.out.println(Arr[i]);
    }
    
    //示例3.替换需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程将字符串还原成:“我要学编程”。
    String s1 = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
    String res = s1.replaceAll("\\.", "").replaceAll("(.)\\1\\1", "");  //方式1
    String res1 = s1.replaceAll("\\.", "").replaceAll("(.)\\1+", "$1");  //方式2 (这里采用$1代替捕获的值得学习)
    System.out.println(res + "\n" + res1);
  }
}

示例1-1 : true
示例1-2 : true

sd
fg
hj
kl

我要学编程
我要学编程

package com.weiyigeek.regex;

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

public class Demo4_Regex {

  public static void main(String[] args) {
    //示例1.Pattern类的简单实用
    Pattern p = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE); //获取正则表达式不区分大小写 (方式1)
    Matcher m = p.matcher("AABBB"); //获取适配器
    boolean b1 = m.matches();  //判断是否能进行匹配
    boolean b2 = Pattern.compile("[a-z]+").matcher("AABBB").matches(); //方法2 链式匹配
    System.out.println("方式1 的结果 : " + b1);
    System.out.println("方式2 的结果 : " + b2);
    
    //示例2.Pattern和Matcher的结合使用进行 手机号正则匹配
    String s = "我的手机号是:18983441325, 曾经用过18487258412, 还用过18883420241";
    Matcher m1 = Pattern.compile("1[456789]\\d{9}").matcher(s);
    //注意要先找再获取注意这里的find获取了一个便会从下一个位置进行查找
    System.out.println("提取到的电话号码:");
    while(m1.find())
      System.out.println(m1.group());
  }
}

方式1 的结果 : true
方式2 的结果 : false

提取到的电话号码:
18983441325
18487258412
18883420241