java正则表达式 and_java中的正则表达式And Pattern And Macher

在哪里？？

java.util.regex包下有两个用于正则表达式的类, 一个是Matcher类, 另一个Pattern

简单例子

public class RegexLeaning {

public staticvoidmain(String[] args) {

Pattern p= Pattern.compile("[a-z]{3}");

Matcher m= p.matcher("bac");

System.out.println(m.matches());

}//结果：true

}

Pattern可以理解为一个模式, 字符串需要与某种模式进行匹配，上面设置的就是匹配a-z中的三个字母

Matcher可以理解为模式匹配某个字符串后产生的结果

Pattern类中的compile方法, 也就是说对我们传入的正则表达式编译后得到一个模式对象. 而这个经过编译后模式对象,

会使得正则表达式使用效率会大大提高, 并且作为一个常量, 它可以安全地供多个线程并发使用

第一类正则表达式：

/**

* . Any character (may or may not match line terminators), 任意字符

* 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{n,} X, at least n times x出现至少n次

* X{n,m} X, at least n but not more than m times 出现n~m次

第二类正则表达式：

/**

* \d A digit: [0-9] 数字

* \D A non-digit: [^0-9] 非数字

* \s A whitespace character: [ \t\n\x0B\f\r] 空格

* \S A non-whitespace character: [^\s] 非空格

* \w A word character: [a-zA-Z_0-9] 数字字母和下划线

* \W A non-word character: [^\w] 非数字字母和下划线*/

[]用于描述一个字符的范围

Pattern类：

/*** 将给定的正则表达式编译并赋予给Pattern类

*

* public static Pattern compile(String regex, int flags)

* public static Pattern compile(String regex)*/Pattern p= Pattern.compile("a+",Pattern.CASE_INSENSITIVE);

System.out.println(p.flags());//2

/*** String pattern() 返回该pattern对象所编译的正则表达式*/Pattern p1= Pattern.compile("\\d+");

System.out.println(p1.pattern());//\d+

String[] split()

/*** String[] split() 按regex分隔字符串，返回字符串数组

*

* public String[] split(CharSequence input, int limit)

* intput:需要财富的字符串序列

* limit是控制应用模式的次数，影响数组的长度

* n>0 :模式至少应用n-1次，数组长度不大于n。

* n != 正数：模式应用无限制，并且数组可任意长度

* n =0 ：模式应用无限制，并且数组可任意长度，丢弃尾部空字符串

*

*

* public String[] split(CharSequence input)*/

Pattern p2 = Pattern.compile("\\d+");

String[] str= p2.split("全12电话89和收集");

String[] str2= p2.split("全12电话89和收集",2);

System.out.println(Arrays.toString(str));//[全, 电话, 和收集]

System.out.println(Arrays.toString(str2));//[全, 电话89和收集]

备注：因为String 实现了ChraSequence接口，所以直接可以用字符串

Pattern.matches

/*** 快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.

*

* public static boolean matches(String regex, CharSequence input) {

* Pattern p = Pattern.compile(regex);

* Matcher m = p.matcher(input);

* return m.matches();

* }*/

Boolean re1 = Pattern.matches("\\d+","232");//true

Boolean re2 = Pattern.matches("\\d+","23aa2");//false

Pattern类中的matcher方法

/***返回一个Macher对象

*

*因为Matcher的构造方法也是私有的 ，不能随意创建，

* 只能通过下面方法创建了

* public Matcher matcher(CharSequence input)*/

Pattern p3 = Pattern.compile("\\d+");

Matcher matcher= p3.matcher("2321");

System.out.println("p3"+matcher.pattern());//返回该Matcher对象是由哪个Pattern对象的创建的

Machter类

获得实例

Pattern pattern1 = Pattern.compile("\\d+");/*** Matcher的构造方法也是私有的，只能通过pattern类中的matcher方法创建*/Matcher matcher1= pattern1.matcher("quan1zhi2qiang3hao4");

pattern()

/*** Matcher中的方法pattern()获取建立matcher实例时的pattern

* 即构造器传入的Pattern对象。*/

System.out.println(matcher1.pattern());//\d+

matches()

/*** Matcher里面的matches方法，

* 对整个字符串进行匹配,只有整个字符串都匹配了才返回true。*/

String mailstr = "1234@163.com";

Pattern pattern= Pattern.compile("[\\w\\.]+@[\\w\\-\\.]+[\\w\\-]+");

Matcher matcher=pattern.matcher(mailstr);

System.out.println(matcher.matches());//true

lookAt()

/*** Matcher.lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true。

*lookingAt是部分匹配，总是从第一个字符进行匹配,匹配成功了不再继续匹配，匹配失败了,也不继续匹配。*/

String str1 = "123quan";

String str2= "quan123";

Pattern pattern3= Pattern.compile("\\d+");

Matcher matcher3=pattern3.matcher(str1);

Matcher matcher4=pattern3.matcher(str2);

System.out.println(matcher3.lookingAt());//true

System.out.println(matcher4.lookingAt());//false

if(matcher4.find()){

System.out.println(matcher4.group());//123

}

find()

/*** find()是部分匹配，从当前位置开始匹配，找到一个匹配的子串，将移动下次匹配的位置。

*

* 该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配

* 的第一个字符开始。如果匹配成功，则可以通过 start、end 和 group 方法获取更多信息。*/

String str5 = "111quan222qq333";

Pattern pattern5= Pattern.compile("\\d+");

Matcher matcher5=pattern5.matcher(str5);while(matcher5.find()){

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

}/*111

222

333*/

matches lookAt find联系

/*** matches lookAt find 的联系和区别；

*都放回boolean类型：

* 1,Matcher.matches() 对整个字符串进行匹配,只有整个字符串都匹配了才返回true

* 2,Matcher.lookingAt() 从输入的头开始找，只有字符串的前缀满足模式才返回true

* 3,Matcher.find() 对字符串进行匹配,匹配到的字符串可以在任何位置.*/

String str6 = "111quan222qq333";

Pattern pattern6= Pattern.compile("\\d+");

Matcher matcher6=pattern6.matcher(str6);

matcher6.matches();//匹配在q这里失败了，下次匹配位置从位置4开始//下次匹配

matcher6.find();

System.out.println(matcher6.start());//查看这次匹配成功的开始位置//7

matcher6.reset();//回到初始位置

matcher6.lookingAt();

System.out.println(matcher6.start());//查看这次匹配成功的开始位置//0

替换的三个方法：

/***replaceAll 替换符合所有Regex的部分

* replaceFirst 替换第一个符合regex的部分

* replace 用字符串替换字符串，没有匹配规则*/

String str7 = "111quan222qq333";

Pattern pattern7= Pattern.compile("\\d+");

Matcher matcher7=pattern6.matcher(str7);

System.out.println(matcher7.replaceAll("@"));//@quan@qq@

System.out.println(matcher7.replaceFirst("*"));//*quan222qq333//字符串里面也有替换函数

System.out.println(str7.replace("111","BBB"));//BBBquan222qq333

System.out.println(str7.replaceAll("\\d+","ALL"));//ALLquanALLqqALL

System.out.println(str7.replaceFirst("\\d+","FIRST"));//FIRSTquan222qq333

正则表达式详解：

常用书写符号：

常用限定字符：

预定义字符集：

常用regex：

public classDemoRegex {public static voidmain(String[] args) {

String qqstr= "12898878332";

String qqreg= "[1-9]\\d{4,13}";//QQ没有0开头的

Pattern pattern1 =Pattern.compile(qqreg);

Matcher matcher=pattern1.matcher(qqstr);boolean re =matcher.matches();

System.out.println(re);//true//按照叠词切割：其中\\1表示前面括号里面的组

String[] strings = qqstr.split("(.)\\1+");

System.out.println(Arrays.toString(strings));//[1289, 78, 2]

}

}

组：

A(B(C))D 有三个组：组 0 是 ABCD，组 1 是 BC，组 2 是 C，

可以根据有多少个左括号来来确定有多少个分组，括号里的表达式都称子表达式。

"(.)\\1+"

\\1就是反向引用