java正则表达式

2、正则表达式的各种符号及其含义
常用的符号

. 表示任意一个字符

\s 空格字符(空格键, tab, 换行, 换页, 回车)

\S 非空格字符([^\s])

\d 一个数字，（相当于[0-9] ）

\D 一个非数字的字符，（相当于[^0-9] ）

\w 一个单词字符(word character) （相当于 [a-zA-Z_0-9] ）

\W 一个非单词的字符，[^\w]

^ 一行的开始

$ 一行的结尾

\b 一个单词的边界

\B 一个非单词的边界

\G 前一个匹配的结束

[] 匹配方括号内的一个字符

例如：[abc] 表示字符a，b，c中的任意一个(与a|b|c相同)

[a-zA-Z] 表示从a到z或A到Z当中的任意一个字符

表示次数的符号

* 重复零次或更多次

例如：a* 匹配零个或者多个a

+ 重复一次或更多次

例如：a+ 匹配一个或者多个a

? 重复零次或一次

例如：a? 匹配零个或一个a

{n} 重复n次

例如：a{4} 匹配4个a

{n,} 重复n次或更多次

例如：a{4,} 匹配至少4个a

{n,m} 重复n到m次

例如：a{4,10} 匹配4~10个a

java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现：

1、首先引入java包：java.util.regex

2、使用方法如下：

共分三步：

①构造一个模式.

Pattern p=Pattern.compile("[a-z]*");

②建造一个匹配器

Matcher m = p.matcher(str);

③进行判断，得到结果

boolean b = m.matches()；

Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到

时返回true,没匹配到则返回false

①m.matches()

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

②m.lookingAt()

lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返

回true

③m.find()

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

Matcher类的其他方法

int groupcount() 返回此匹配器模式中的捕获组数。

String replaceAll(String replacement) 用给定的replacement全部替代匹配的

部分

String repalceFirst(String replacement) 用给定的replacement 替代第一次匹

配的部分

appendReplacement(StringBuffer sb,String replacement) 根据模式用

replacement替换相应内容,并将匹配的结果添加到sb当前位置之后

StringBuffer appendTail(StringBuffer sb) 将输入序列中匹配之后的末尾字串

添加到sb当前位置之后.

group(n) 0代表永远都是匹配整个表达式的字符串的那部分 n<>0时代表

第n组匹配的部分

①字符匹配

Pattern p = Pattern.compile(expression); // 正则表达式

Matcher m = p.matcher(str); // 操作的字符串

boolean b = m.matches(); //返回是否匹配的结果

System.out.println(b);

Pattern p = Pattern.compile(expression); // 正则表达式

Matcher m = p.matcher(str); // 操作的字符串

boolean b = m. lookingAt (); //返回是否匹配的结果

System.out.println(b);

Pattern p = Pattern.compile(expression); // 正则表达式

Matcher m = p.matcher(str); // 操作的字符串

boolean b = m..find (); //返回是否匹配的结果

System.out.println(b);

②分割字符串

Pattern pattern = Pattern.compile(expression); //正则表达式

String[] strs = pattern.split(str); //操作字符串 得到返回的字符串数组

③替换字符串

Pattern p = Pattern.compile(expression); // 正则表达式

Matcher m = p.matcher(text); // 操作的字符串

String s = m.replaceAll(str); //替换后的字符串

④查找替换指定字符串

Pattern p = Pattern.compile(expression); // 正则表达式

Matcher m = p.matcher(text); // 操作的字符串

StringBuffer sb = new StringBuffer();

int i = 0;

while (m.find()) {

m.appendReplacement(sb, str);

i++; //字符串出现次数

}

m.appendTail(sb);//从截取点将后面的字符串接上

String s = sb.toString();

⑤查找输出字符串

Pattern p = Pattern.compile(expression); // 正则表达式

Matcher m = p.matcher(text); // 操作的字符串

while (m.find()) {

//m.start() 返回匹配到的子字符串在字符串中的索引位置.

//m.end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.

//m.group()返回匹配到的子字符串

}

以下是例子

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegTest{
static void test(){
Pattern p = null; //正则表达式
Matcher m = null; //操作的字符串
boolean b = false;
//正则表达式表示首字母是a，中间是任意字符，结尾以b结束
//不匹配的结果
p = Pattern.compile("a*b");
m = p.matcher("baaaaab");
b = m.matches();
System.out.println("匹配结果："+b); //输出：true
//匹配的结果
p = Pattern.compile("a*b");
m = p.matcher("aaaaab");
b = m.matches();
System.out.println("匹配结果："+b); //输出：false
}
public static void main(String argus[]){
test();
}}

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegTest {
static void test() {
/**
* start()返回匹配到的子字符串在字符串中的索引位置.
* end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.
* group()返回匹配到的子字符串
*/
Pattern p=Pattern.compile("\\d+");
Matcher m=p.matcher("aaa2223bb11222");
while(m.find()){
System.out.println(m.start());//第一个循环返回3，第二个循环返回
9
System.out.println(m.end());//返回7,第二个循环返回14
System.out.println(m.group());//返回2233，第二个返回11222
}
}
public static void main(String argus[]) {
test();
}
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegTest {
static void test() {
/*
* 本例groupCount将返回三组a11bbb、11、bbb
*/
Pattern p=Pattern.compile("\\w(\\d\\d)(\\w+)");
Matcher m=p.matcher("aa11bbb");
if(m.find()){
int count = m.groupCount(); //返回匹配组的数目，而不是匹配字符串
的数目
for(int i = 0; i <= count; i++)
System.out.println("group " + i + " :" + m.group(i));
}
}
/*
* 返回结果如下
* group 0 :a11bbb
* group 1 :11
* group 2 :bbb
*/
public static void main(String argus[]) {
test();
}
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegTest {
static void test() {
Pattern p = Pattern.compile("\\d+"); //将所含数字全部替换为XX
Matcher m = p.matcher("aa11bbb33cc55gg");
String str = m.replaceAll("XX");
System.out.println(str);
}
/*
* 返回结果如下
* aaXXbbbXXccXXgg
*/
public static void main(String argus[]) {
test();
}
}