java 模式匹配_Java正则表达式的模式匹配示例

package date0804.demo1;

import java.util.regex.Pattern;

public class RegularExpres {

public static void main(String[] args) {

//中括号只代表一位字符,*代表任意位,问号代表一位

//匹配首字母为a,末尾字母为b的任意字符串

boolean b1 = Pattern.matches("a*d", "aaaaad");

//匹配首字母为a,末尾字母为b的中间为任意一个字符(包括空字符)的任意字符串

boolean b2 = Pattern.matches("a?d", "ad");

//匹配首字母为a,末尾字母为b,中间为a或b或c的任意字符串

boolean b3 = Pattern.matches("a[abc]d", "abd");

//匹配首字母为a,末尾字母为b,中间为排除a或b或c的任意字符串

boolean b4 = Pattern.matches("a[^abc]d", "abd");

//匹配a-z或A-Z任意字符

boolean b5 = Pattern.matches("[a-zA-Z]", "a");

//a-d,m-p

boolean b6 = Pattern.matches("[a-dm-p]", "l");

//d,e,f

boolean b7 = Pattern.matches("[a-z&&[def]]", "d");

//a-d,m-p

boolean b8 = Pattern.matches("[a-dm-p]", "l");

//digit

boolean b9 = Pattern.matches("[0-9]", "?");

}

}

package date0814.regrex;

import java.util.StringTokenizer;

/**

* 正则表达式系列学习

* @author zzw922cn

*

*/

public class Test1 {

public static void main(String[] args) {

String str = "I am a good boy!";

//分割字符串，方法一，使用StringTokenizer

StringTokenizer stringTokenizer = new StringTokenizer(str," ");

while(stringTokenizer.hasMoreElements()) {

String nextToken = stringTokenizer.nextToken();

System.out.println(nextToken);

}

//方法二，使用split分割

/*

* 在Java中，\\表示要插入一个正则表达式的反斜线，所以其后的字符具有特殊意义

*/

String[] strings = str.split("\\s");

for(String element:strings)

System.out.println(element);

//加深正则表达式,从下面的str中提取字符串I am a good boy!

str="I-12am-4532a-2good213boy!";

//下面的-?\\d+表示可能有一个负号，并且有至少一位数字

strings = str.split("-?\\d+");

for(String element:strings)

System.out.println(element);

}

}

package date0814.regrex;

/**

* 字符串的模式匹配

* @author zzw922cn

*

*/

public class Test2 {

public static void main(String[] args) {

//下面来看一下正则表达式的匹配

System.out.println("-123".matches("-?\\d+"));

System.out.println("123".matches("-?\\d+"));

System.out.println("+123".matches("-?\\d+"));

System.out.println("+123".matches("(-|\\+)?\\d+"));

//下面来一个难一点的，分割段落中的所有单词

String line="Well,,you have found the biggest school!You must look for such school in the future..."+

"with such a beatiful garden——SunGarden.I am serious!!!";

//下面这个正则表达式分割,!,.——,\n,空格中的任意一项的一个或多个，+表示>=1个

String regex="(,+|\\!+|\\.+|\\——+|\n+|\\s+)";

String[] strings = line.split(regex);

for(String element:strings)

System.out.println(element);

System.out.println("共"+strings.length+"个单词");

//或者用现有的\\W来分割非单词字符，\\w表示分割一个单词字符

regex="\\W+";

strings = line.split(regex);

for(String element:strings)

System.out.println(element);

System.out.println("共"+strings.length+"个单词");

//\\w表示分割一个单词字符，+号表示分割一个或多个单词字符，也就是说对下面的line分割过后只剩下非单词字符了

//[,? ,! !.]三个元素

regex="\\w+";

line="I,?am,!zzw!.";

strings = line.split(regex);

for(String element:strings)

System.out.println(element);

}

}

package date0814.regrex;

public class Test3 {

public static void main(String[] args) {

//下面来把一个句子中的所有标点符号替换成_

String line="Well,,you have found the biggest school!You must look for such school in the future..."+

"with such a beatiful garden——SunGarden.I am serious!!!";

//下面这个正则表达式分割,!,.——,\n,空格中的任意一项的一个或多个，+表示>=1个

String regex="(,+|\\!+|\\.+|\\——+|\n+|\\s+)";

String replaceAll = line.replaceAll(regex, "_");

System.out.println(replaceAll);

}

}

package date0814.regrex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

* 正则表达式字符及字符类的学习

* @author zzw922cn

*

*/

public class Test4 {

///**

// * \xhh 十六进制值为0xhh的字符

// * \\uhhhh 十六进制表示为0xhhhh的Unicode字符

// * \t 制表符Tab

// * \n 换行符

// * \r 回车

// * \f 换页

// * \e 转义

// *

// * . 任意字符

// * [abc] abc的任何字符

// * [^abc] 除abc以外的任何字符

// * [a-zA-Z] 从a到z或从A到Z的任意字符

// * [abc[hij]] 任意abchij的字符，即合并作用

// * [a-z&&[hij]] 表示a-z与hij的交集中的任意一个字符，即hij中的任意字符

// * \s 空白符(包括空格,Tab,换行,换页,回车)

// * \S 非空白符([^\s])

// * \d 数字([0-9])

// * \D 非数字([^0-9])

// * \w 词字符 ([a-zA-Z0-9])

// * \W 非词字符 [^\W]

// *

// * XY Y跟在X后面

// * X|Y X或Y

// * (X) 捕获组，可以在表达式中引用\i引用第i个捕获组

// * ^ 一行的起始

// * $ 一行的结束

// * \b 词的边界

// * \B 非词的边界

// * \G 前一个匹配的结束

// */

public static void main(String[] args) {

//提取1,strt,4

String line="
a=1;b=strt;c=4";

String regex1="";

line = line.replaceAll(regex1, "");

System.out.println(line);

String regex="[abc]=";

Pattern pattern = Pattern.compile(regex);

Matcher matcher = pattern.matcher(line);

while(matcher.find()) {

System.out.println(matcher.group()+"从"+matcher.start()+"到"+matcher.end());

}

}

}

package date0814.regrex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Test5 {

public static void main(String[] args) {

String str="abcdabcdabcd";

//要打括号

String regex="(abcd)+";

System.out.println(str.matches(regex));

//使用Pattern来编译正则表达式

Pattern pattern = Pattern.compile("abcd+");

Matcher matcher = pattern.matcher(str);

while(matcher.find()) {

System.out.println(matcher.start()+"——"+matcher.end());

}

}

}

package date0814.regrex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Test7 {

public static void main(String[] args) {

String str="Java now has regular expressions";

//匹配Java开头的句子，后面可以跟任意内容

String[] regx={

"\\breg.*",

"^Java",

"n.w\\s+h(a|i)s",

"s?",

"h*",

"s+",

"s{4}",

"s{1}.",

"s{0,3}"

};

for(int i=0;i

Pattern compile = Pattern.compile(regx[i]);

Matcher matcher = compile.matcher(str);

while(matcher.find()) {

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

}

}

}

}

package date0814.regrex;

import java.util.regex.Pattern;

public class Test8 {

public static void main(String[] args) {

//如何匹配a^nb^n呢

// ?x 表示空格符被忽略

//

Pattern p = Pattern.compile("(?x)(?:a(?= a*(\\1?+b)))+\\1");

// true

System.out.println(p.matcher("aaabbb").matches());

// false

System.out.println(p.matcher("aaaabbbb").matches());

// false

System.out.println(p.matcher("aaabbbb").matches());

// false

System.out.println(p.matcher("caaabbb").matches());

}

}

package date0814.regrex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Test9 {

public static void main(String[] args) {

final String POEM="This was boring,and the slightly\n"

+ "good boys are here running\n"

+ "haha i don't want to say anything\n";

/*

* ?m表示多行模式下，^ $分别表示一行的开始和结束，而在默认环境下，仅匹配完整字符串的开头或结尾

* \\S 匹配任意字母或数字

* + 表示多个

* \\s 匹配任意空白符

* + 表示多个

* 因此下面这个正则表达式表示一行的结尾的三个单词

*/

Pattern pattern = Pattern.compile("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$");

Matcher matcher = pattern.matcher(POEM);

while(matcher.find()) {

for(int j=0;j

System.out.print("["+matcher.group(j)+"]");

}

System.out.println();

}

}

}

package date0814.regrex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Test10 {

public static void main(String[] args) {

String s="/*!I am a good boy!*/";

Pattern pattern = Pattern.compile("(?s)/\\*!(.*)!\\*/");

Matcher matcher = pattern.matcher(s);

while(matcher.find()) {

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

}

}

}

附录：2015年12月6日更新，正则表达式补充内容：

正则表达式含有一些限定符：

例如：*表示匹配前面的表达式0次或者多次，如zo*可以匹配z也可以匹配zoo，相当于zo{0,}

+匹配前面的表达式1次或者多次，例如zo+可以匹配zo或者zoo，相当于zo{1,}

?匹配前面的表达式0次或者1次，例如zo?可以匹配z或者zo，相当于zo{0,1}

{n}n是一个非负整数，可以匹配n次，如o{2}可以匹配food，但是不能匹配zoe

{n,}n是一个非负整数，可以匹配至少出现n次，例如o{2,}可以匹配food，也可以匹配oook

{n,m}n、m均为非负整数，并且n<=m，可以匹配至少出现n次，至多出现m次，例如o{2,3}可以匹配food,也可以匹配oook，但不能匹配ooook