【JAVA基础】正则表达式

JAVA基础 专栏收录该内容
6 篇文章 0 订阅

正则表达式就是我们程序员为了在海量数据中搜索到符合我们规定的格式的数据所采用的一种规范,官方一点就是说正则表达式是一种文本模式,包括普通字符(例如,a 到 z 之间的字母)和特殊字符(称为“元字符”)。模式描述在搜索文本时要匹配的一个或多个字符串。


下面我们介绍一下正则表达式的规则,而且会给出一个详尽的实例来让你完全理解正则表达式的应用。

1.正则表达式的构造摘要 

正则表达式的构造摘要 
构造 匹配 
  
字符 
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,作为独立的非捕获组 


2.正则表达式应用大实例

正则表达式:RegularExpressions(字符串处理利器)

都在java.util.regex.*;包中

样例:

package cn.edu.RegularExpressions;


import java.util.regex.Matcher;
import java.util.regex.Pattern;


class Test {
	public static void main(String[] args) {
		//简单理解正则表达式
		System.out.println("abc".matches("..."));
		//其中“\d”代表一个数字(0-9)
		System.out.println("a324234a".replaceAll("\\d", "-"));
		Pattern p=Pattern.compile("[a-z]{3}");
		Matcher m=p.matcher("fgh");
		System.out.println(m.matches());
		System.out.println("fgha".matches("[a-z]{3}"));
		/*结果
		 * true
           a------a
		   true
		   false
		 * */
		
		//初步认识. * +
		p("1:"+"a".matches("."));//
		p("2:"+"aa".matches("aa"));//true,正则表达式可以写正常的字符
		p("3:"+"aaaa".matches("a*"));//“*”代表的是0个或者多个
		p("4:"+"aaaa".matches("a+"));//“+”代表的是1个或者多个
		p("5:"+"".matches("a*"));
		p("6:"+"aaaa".matches("a?"));//“?”代表的是0个或1个
		p("7:"+"".matches("a?"));
		p("8:"+"a".matches("a?"));
		p("9:"+"2342342432423234".matches("\\d{3,100}"));//“{”与“}”代表出现的次数(几次,至少几次,最多几次最少几次)
		//最简单的检测IP地址的方式:
		p("10:"+"192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
		p("11:"+"192".matches("[0-2][0-9][0-9]"));//“[]”代表一个范围
		/*结果:
		1:true
		2:true
		3:true
		4:true
		5:true
		6:false
		7:true
		8:true
		9:true
		10:false
		11:true*/
		
		p("a".matches("[abc]"));
		p("a".matches("[^abc]"));
		p("A".matches("[a-zA-Z]"));
		p("A".matches("[a-z] | [A-Z]"));
		p("A".matches("[a-z[A-Z]]"));
		p("R".matches("[A-Z&&[RFG]]"));
		/*true
		false
		true
		false
		true
		true*/


		/*
		 * "."代表任何字符
		 * "/d"[0-9]的数字
		 * "/D"非[0-9]的数字[^\d]
		 *"/s"空白字符(包括空格,Tab键\t,换行\n,backspace后退键/x0B,制表符/f,回车/r)
		 * "/S"非“空白字符”[^\s]
		 * "/w"单词字符[a-zA-Z_0-9]
		 * "/W""非“单词字符”[^\w]
		 */
		p(" \n\r\t".matches("\\s{4}"));
		p(" ".matches("\\S"));
		p("a_8".matches("\\w{3}"));
		p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));
		p("\\".matches("\\\\"));//在matches中,一个"\"要用"\\"来表示
	/*	true
		false
		true
		true
		true*/
		
		//POSIX Style
		p("a".matches("\\p{Lower}"));
		/*true*/
		
		//边界匹配
		//"^"位于中括号里面的时候是取反的意思,位于外面代表的是输入的开头
		p("hello sir".matches("^h.*"));//以"h"开头
		p("hello sir".matches(".*ir$"));//以"ir"结尾
		p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));//\b一个单词的边界(空格,空白字符,换行,特殊字符)
		p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
		/*true
			true 
			false*/
		
		//把空白行找出来
		p(" \n".matches("^[\\s&&[^\\n]]*\\n"));//以空白字符开头,并且不是换行符,出现0次或多次
		/*true*/
		
		//匹配email地址的正则表达式(有得email地址是含有横线和点号的)
		p("basdbjasbkja@dasbdn.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));
		
		//matches find lookingAt
		Pattern p1=Pattern.compile("\\d{3,5}");//编译正则表达式
		String s="123-34345-234-00";
		Matcher m1=p1.matcher(s);
		p(m1.matches());
		//false
		//find()一段一段的匹配
		//分析到“-”时,不符合p1的标准,认为结束
		m1.reset();//matches与find一起使用时需要reset
		p(m1.find());
		p(m1.start()+"-"+m1.end());//输出“-”的起始位置和结束位置(结束位置就是本身位置)
		p(m1.find());
		p(m1.start()+"-"+m1.end());
		p(m1.find());
		p(m1.start()+"-"+m1.end());
		p(m1.find());
//		true
//		true
//		true
//		false
		
		p(m1.lookingAt());
		//true
		
		//区别matches找整个串 
		//find找字串
		//lookingAt每次都从头上开始找
		
		//字符串的替换
		Pattern p2=Pattern.compile("java",Pattern.CASE_INSENSITIVE);//CASE_INSENSITIVE忽略大小写
		Matcher m2=p2.matcher("java Java JAVa JaVa IloveJAVA you hateJava lalalala");
		while(m2.find()){
			p(m2.group());//按组找
		}
		p(m2.replaceAll("JAVA"));
		//全部改为JAVA JAVA JAVA JAVA IloveJAVA you hateJAVA
		
		m2.reset();
		StringBuffer buf=new StringBuffer();
		int i=0;
		while(m2.find()){
			i++;
			if(i%2==0){//奇数大写偶数小写
				m2.appendReplacement(buf, "java");
			}else{
				m2.appendReplacement(buf, "JAVA");
			}
		}
		m2.appendTail(buf);//将尾巴加进去
		p(buf);
		//JAVA java JAVA java IloveJAVA you hatejava lalalala
		
		//分组:使用小括号组成的,分了机组就有几对小括号
		//每个组有自己的组号
		Pattern p3=Pattern.compile("(\\d{3,5})([a-z]{2})");
		String s1="123aa-12323bb-456cc-00";
		Matcher m3=p3.matcher(s1);
		while(m3.find()){
			p(m3.group());//按组找
			p(m3.group(1));
			p(m3.group(2));
		}
		/*123aa
		123
		aa
		12323bb
		12323
		bb
		456cc
		456
		cc*/
		


	}
	
	public static void p(Object o){
		System.out.println(o);
	}


}


3.实例:利用正则表达式写简单的邮件爬虫

把qiu_email.htm这个网页文件中的所有信息中属于邮箱地址的信息搜索出来

package cn.edu.RegularExpressions;


import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class EmailSpider {
		public static void main(String[] args) {
			try {
     BufferedReader br=new BufferedReader(new FileReader("F:\\Talk\\qiu_email.htm"));
				String line="";
				while((line=br.readLine())!=null){
					parse(line);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}




		private static void parse(String line) {
                        //email的正则表达式
			Pattern p=Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
			Matcher m=p.matcher(line);
			while(m.find()){
				System.out.println(m.group());
			}
			
		}
} 

转载请注明出处:http://blog.csdn.net/acmman/article/details/45078731

  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:黑客帝国 设计师:我叫白小胖 返回首页

打赏作者

光仔December

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值