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