Java学习第25天:正则表达式

　------- android培训、java培训、期待与您交流！ ----------　

until25

1.特点

2.匹配

3.切割

4.替换

5.获取

6.练习

7.网页爬虫

 

特点

符合一定规则的表达式。

用于操作字符串（简化操作）

但过长的话阅读性差

需求	方法	注解
匹配	matches()
切割	spilt()
替换	replace replaceAll
获取		字符串中取出正则需要的字串！ 1.将正则表达式封装成对象 2.让正则对象和要操作字符关联 3.关联后，获取到的是正则匹配引擎 4.通过引擎对符合规则字串进行操作取出

 

public class SplitDemo {
 
public static void main(String[] args) {
//切割方法
String str ="lisi,wuwang,zhangsan";
String spl = ",";
String[] all = str.split(spl);
for(String ss : all)
{
System.out.println(ss);
}
//封装组的概念：组会自动编号。用（）封装。组号是从1开始的！
//比如：（.）\\1 --->AA 重叠的切  而想获取设定好的第一组！使用"$1"就是拿第一组 获取的是一个A
}
 
}

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class PattenrDemo {
 
public static void main(String[] args) {
//获取符合正则表达式规则的字串进行取出操作
/*
 *  Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
 */
//稍显负责但是功能多
String str = "277910278";
String reg = "\\d{9}";
//将规则封装成对象
Pattern p = Pattern.compile(reg);
//将规则和字符串进行匹配
Matcher m = p.matcher(str);
//System.out.println(m.matches());//返回boolean，判断是否有想要的字串！matchers是作用于整个字符串
//将规则作用于字符串中并进行查找看是否有结果
boolean flag = m.find();
System.out.println(flag);
System.out.println(m.group());//返回查找到的字串  该方法找到后，角标会自动下移
System.out.println(m.start()+"...."+m.end());//返回找到的字串的位置！包含头不包含尾巴
}
 
}

 

的非捕获组

字符
x	字符 x
\\	反斜线字符
\0n	带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn	带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn	带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh	带有十六进制值 0x 的字符 hh
\uhhhh	带有十六进制值 0x 的字符 hhhh
\t	制表符 ('\u0009')
\n	新行（换行）符 ('\u000A')
\r	回车符 ('\u000D')
\f	换页符 ('\u000C')
\a	报警 (bell) 符 ('\u0007')
\e	转义符 ('\u001B')
\cx	对应于 x 的控制符
字符类
[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a到 z，而非 m 到 p：[a-lq-z]（减去）
预定义字符类
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]
POSIX 字符类（仅 US-ASCII）
\p{Lower}	小写字母字符：[a-z]
\p{Upper}	大写字母字符：[A-Z]
\p{ASCII}	所有 ASCII：[\x00-\x7F]
\p{Alpha}	字母字符：[\p{Lower}\p{Upper}]
\p{Digit}	十进制数字：[0-9]
\p{Alnum}	字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}	标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}	可见字符：[\p{Alnum}\p{Punct}]
\p{Print}	可打印字符：[\p{Graph}\x20]
\p{Blank}	空格或制表符：[ \t]
\p{Cntrl}	控制字符：[\x00-\x1F\x7F]
\p{XDigit}	十六进制数字：[0-9a-fA-F]
\p{Space}	空白字符：[ \t\n\x0B\f\r]
java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase}	等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase}	等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace}	等效于 java.lang.Character.isWhitespace()
\p{javaMirrored}	等效于 java.lang.Character.isMirrored()
Unicode 块和类别的类
\p{InGreek}	Greek 块（简单块）中的字符
\p{Lu}	大写字母（简单类别）
\p{Sc}	货币符号
\P{InGreek}	所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]]	所有字母，大写字母除外（减去）
边界匹配器
^	行的开头
$	行的结尾
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾
\Z	输入的结尾，仅用于最后的结束符（如果有的话）
\z	输入的结尾
Greedy 数量词
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次
Reluctant 数量词
X??	X，一次或一次也没有
X*?	X，零次或多次
X+?	X，一次或多次
X{n}?	X，恰好 n 次
X{n,}?	X，至少 n 次
X{n,m}?	X，至少 n 次，但是不超过 m 次
Possessive 数量词
X?+	X，一次或一次也没有
X*+	X，零次或多次
X++	X，一次或多次
X{n}+	X，恰好 n 次
X{n,}+	X，至少 n 次
X{n,m}+	X，至少 n 次，但是不超过 m 次
Logical 运算符
XY	X后跟 Y
X|Y	X或 Y
(X)	X，作为捕获组
Back 引用
\n	任何匹配的 nth 捕获组
引用
\	Nothing，但是引用以下字符
\Q	Nothing，但是引用所有字符，直到 \E
\E	Nothing，但是结束从 \Q 开始的引用
特殊构造（非捕获）
(?:X)	X，作为非捕获组
(?idmsux-idmsux)	Nothing，但是将匹配标志i d m s u x on - off
(?idmsux-idmsux:X)	X，作为带有给定标志 i d m s u x on - off
(?=X)	X，通过零宽度的正 lookahead
(?!X)	X，通过零宽度的负 lookahead
(?<=X)	X，通过零宽度的正 lookbehind
(?<!X)	X，通过零宽度的负 lookbehind
(?>X)	X，作为独立的非捕获组

 

练习

 

1.将“我我。。。我我。。。我要。。要要。。。要要。。。学学学。。。。学学。。。编编编。。。编程。。程。程程。。。程。。。程”变成“我要学编程”
import java.util.regex.*;
public class practice {
 
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = "我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程.程程...程...程";
String str1 = str.replaceAll("\\.+","");
String str2 = str1.replaceAll("(.)\\1+","$1");
System.out.println(str2);
}
 
}

2.

将Ip地址进行地址段顺序的排序

192.68.1.254.102.49.23.013 10.10.10.10. 2.2.2.2.8.109.90.30

public class Practice2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "192.68.1.254   102.49.23.013  10.10.10.10  2.2.2.2   8.109.90.30";
		//给数字后面加两个零
		str = str.replaceAll("(\\d+)","00$1");
		//取三位数字
		str = str.replaceAll("0*(\\d{3})","$1");
		
		String[] arr = str.split(" +");
		TreeSet<String> ts = new TreeSet<String>();
		for(String s : arr)
		{
			ts.add(s);
		}
		for(String ss : ts)
		{
			System.out.println(ss);
		}

	}//一般的邮箱匹配规则：[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-z]+

}

网页爬虫

package until_25;
import java.net.*;
import java.io.*;
import java.util.regex.*;
public class zhizhu {
 
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
practice();
}
//读取网络
public static void practice_1() throws IOException
{
URL url = new URL("随便一个网站");
URLConnection cnn = url.openConnection();
BufferedReader br = 
new BufferedReader(new InputStreamReader(cnn.getInputStream()));
String reg = "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-z]+";
Pattern p = Pattern.compile(reg);
//Mactcher m = p.matcher(reg);
String line = null;
while((line=br.readLine())!=null)
{
Matcher m = p.matcher(line);
while(m.find())
{
System.out.println(line);
}
}
}
//读取文件
public static void practice() throws IOException
{
BufferedReader br = 
new BufferedReader(new FileReader("mail.txt"));
String reg = "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-z]+";
Pattern p = Pattern.compile(reg);
//Mactcher m = p.matcher(reg);
String line = null;
while((line=br.readLine())!=null)
{
Matcher m = p.matcher(line);
while(m.find())
{
System.out.println(line);
}
}
}
 
}
 

------- android培训、java培训、期待与您交流！ ----------