JavaSE--正則表達式專題

正則表達式的引入

1、下面是不採用正則表達式的情況下檢查qq合法性的代碼實現

public class RegexDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] qqs= new String[]{"1234567","12345","1234","01234567","123456789123456",
				"1234567891234567","123456fff"};
		for(String qq:qqs)
		{
			checkQQ(qq);
		}
	}
	
	/*
	 * 	需求：定義一個功能對qq號進行校驗
	 * 	要求：長度5-15，只能是數字，0不能開頭
	 */
	public static void checkQQ(String qq)
	{
		int len=qq.length();
		if(len>=5 && len<=15)
		{
			if(!qq.startsWith("0"))
			{
				try
				{
					long l=Long.parseLong(qq);
					System.out.println(qq+" 正確");
				}
				catch(NumberFormatException e)
				{
					System.out.println(qq+" 含有非法字符");
				}
				
			}
			else
			{
				System.out.println(qq+" 不能以0開頭");
			}
		}
		else
		{
			System.out.println(qq+" 長度錯誤");
		}
	}
}

執行結果爲：

1234567 正確
12345 正確
1234 長度錯誤
01234567 不能以0開頭
123456789123456 正確
1234567891234567 長度錯誤
123456fff 含有非法字符

2、下面是採用正則表達式來進行qq合法性檢查的代碼實現，顯然，代碼實現起來簡單的多。

public class RegexDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] qqs= new String[]{"1234567","12345","1234","01234567","123456789123456",
				"1234567891234567","123456fff"};
		for(String qq:qqs)
		{
			checkQQ(qq);
		}
	}
	
	/*
	 * 	需求：定義一個功能對qq號進行校驗
	 * 	要求：長度5-15，只能是數字，0不能開頭
	 */
	public static void checkQQ(String qq)
	{
		String regex="[1-9][0-9]{4,14}";//	正則表達式
		boolean b=qq.matches(regex);
		System.out.println(qq+" : "+b);
	}
}

執行結果爲：

1234567 : true
12345 : true
1234 : false
01234567 : false
123456789123456 : true
1234567891234567 : false
123456fff : false

正則表達式的規則

/*
 * 	正則表達式規則：
 * 	字符 
 * 		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] 
 * 	邊界匹配器 
 * 		^ 				行的開頭 
 * 		$ 				行的結尾 
 * 		\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，作爲捕獲組 
 */

正則表達式規則的使用實例

public class RegexDemo4 {

	public static void main(String[] args) {
		String str="aoob";
		String regex="ao?b";//false
		boolean b=str.matches(regex);
		System.out.println(str+" : "+b);
		
		regex="ao+b";
		b=str.matches(regex);//true
		System.out.println(str+" : "+b);
		
		regex="ao*b";
		b=str.matches(regex);//true
		System.out.println(str+" : "+b);
		
		regex="ao{2}b";
		b=str.matches(regex);//true
		System.out.println(str+" : "+b);
		
		regex="ao{4,10}b";
		b=str.matches(regex);//false
		System.out.println(str+" : "+b);
		
		regex="ao{1,4}b";
		b=str.matches(regex);//true
		System.out.println(str+" : "+b);
		
		regex="ao{3,}b";
		b=str.matches(regex);//false
		System.out.println(str+" : "+b);
	}
}

執行結果爲：

aoob : false
aoob : true
aoob : true
aoob : true
aoob : false
aoob : true
aoob : false

正則表達式功能簡介

/*
 * 	正則表達式：
 * 		正則表達式用於操作字符串處理
 * 		通過一些特定的符號來體現的
 * 	正則表達式雖然代碼簡化了，但是閱讀性下降了
 * 
 * 	正則表達式對字符串的常見操作
 * 		1、匹配
 * 			其實使用的就是String類中的matches方法
 * 				boolean matches(String regex) 告知此字符串是否匹配給定的正則表達式。 
 * 		2、切割
 * 			其實使用的就是String類中的split方法
 * 				String[] split(String regex) 根據給定正則表達式的匹配拆分此字符串。 
 * 				String[] split(String regex, int limit) 根據匹配給定的正則表達式來拆分此字符串。 
 * 			使用組分割：((A)(B(C)))
 * 					計算組號的方法是從左到右數左括號，第一個左括號表示的內容即爲第一組，第二個表示的內容即爲第二組......
 * 					比如這裏：
 * 						第一組		((A)(B(C))) 
 * 						第二組		(A)
 * 						第三組		(B(C))
 * 						第四組		(C)
 * 		3、替換
 * 			其實使用的就是String類中的replaceAll方法
 * 				String replaceAll(String regex, String replacement) 使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。 
 * 		4、獲取
 * 			1、將正則規則進行對象封裝
 * 				Pattern p=Pattern.compile("a*b");
 * 			2、通過正則對象的matcher方法字符串相關聯，獲取要對字符串操作的匹配器對象Match而
 * 				Matcher m=p.matcher("aaaaaaab");
 * 			3、通過matcher匹配器對象的方法對字符串進行操作
 * 				boolean b=m.matches(); 
 */

正則表達式功能–匹配

檢查手機號合法性實例

public class RegexDemo5 {
	public static void phone_number_matches(String tel)
	{
		// 匹配手機號碼是否正確
		// 合法開頭爲：13xx,15xx,18xx
		// 長度爲11位數字
		String regex="1[538][0-9]{9}";
		boolean b=tel.matches(regex);
		System.out.println(tel+" : "+b);
	}
	public static void phone_number_matches2(String tel)
	{
		// 匹配手機號碼是否正確
		// 合法開頭爲：13xx,15xx,18xx
		// 長度爲11位數字
		String regex="1[538]\\d{9}";
		boolean b=tel.matches(regex);
		System.out.println(tel+" : "+b);
	}
	
	public static void main(String[] args) {
		String[] tels=new String[]{"15051876412","14151876412","15251876412",
				"13651876412","03751876412","138ff1876412",
				"18051876412","28151876412"};
		for(String tel:tels)
		{
			phone_number_matches(tel);
		}
		
		System.out.println("正則表達式匹配0-9使用 \\d:");
		for(String tel:tels)
		{
			phone_number_matches2(tel);
		}
	}
}

運行結果爲：

15051876412 : true
14151876412 : false
15251876412 : true
13651876412 : true
03751876412 : false
138ff1876412 : false
18051876412 : true
28151876412 : false
正則表達式匹配0-9使用 \d:
15051876412 : true
14151876412 : false
15251876412 : true
13651876412 : true
03751876412 : false
138ff1876412 : false
18051876412 : true
28151876412 : false

正則表達式功能–分割

public class RegexDemo6 {
	
	public static void main(String[] args) {
		String str1="zhangsan xiaoqiang zhaoliu";
		//不使用正則表達式的情況
		String[] names=str1.split(" ");
		for(String name:names)
		{
			System.out.println(name);
		}
		
		System.out.println("使用不定長度的空格分割......");
		//	當str類似如下情況時，不使用正則表達式，則顯得麻煩了，使用正則則顯得非常簡單
		str1="zhangsan     xiaoqiang      zhaoliu";
		names=str1.split("\\s+");// 正則表達式，使用一個或多個空格分割
		for(String name:names)
		{
			System.out.println(name);
		}
		
		System.out.println("使用特殊字符點.來分割......");
		str1="zhangsan.xiaoqiang.zhaoliu";
		names=str1.split("\\.");// 點是特殊字符，要使用點分割，需要進行轉義，使用\\
		for(String name:names)
		{
			System.out.println(name);
		}
		
		System.out.println("使用不同的疊詞分割......");
		//如下場景，想使用疊詞 #####和mmmmmm來切割
		str1="zhangsan#####xiaoqiangmmmmmmzhaoliu";
		//這裏需要使用分組
		names=str1.split("(.)\\1+");
		//                 |	|-----------第二字符表示使用第一個組的內容相同,而且使用正則+表示一個或多個
		//                 |----------------第一個字符是任意的，使用點，並且封裝爲組
		for(String name:names)
		{
			System.out.println(name);
		}
	}
}

運行結果爲：

zhangsan
xiaoqiang
zhaoliu
使用不定長度的空格分割......
zhangsan
xiaoqiang
zhaoliu
使用特殊字符點.來分割......
zhangsan
xiaoqiang
zhaoliu
使用不同的疊詞分割......
zhangsan
xiaoqiang
zhaoliu

正則表達式功能–替換

public class RegexDemo7 {
	
	public static void main(String[] args) {
		//將疊詞替換爲#
		String str="zhangsan#####xiaoqiangmmmmmmzhaoliu";
		str=str.replaceAll("(.)\\1+", "#");
		System.out.println(str);
		
		//將疊詞替換爲單個字母
		str="zhangsan#####xiaoqiangmmmmmmzhaoliu";
		str=str.replaceAll("(.)\\1+", "$1");// $1 表示正則表達式中第一個分組內容
		System.out.println(str);
		
		String tel="15800001111";//158****1111
		tel=tel.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1****$3");
		System.out.println(tel);
	}
}

執行結果爲：

zhangsan#xiaoqiang#zhaoliu
zhangsan#xiaoqiangmzhaoliu
158****1111

正則表達式功能–獲取

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

public class RegexDemo8 {
	
	public static void main(String[] args) {
		// 獲取下面字符串中三個字母組成的單詞
		String str="da jia hao,ming tian bu fang jia";
		String regex="\\b[a-zA-Z]{3}\\b";
		
		//1、將正則封裝成對象
		Pattern p=Pattern.compile(regex);  
		
		//2、通過正則對象獲取匹配器對象
		Matcher m=p.matcher(str);
		
		//3、使用matcher對象的方法對字符串進行操作
		//既然要獲取三個字母組成的單詞
		//查找，使用find
		// boolean find() 嘗試查找與該模式匹配的輸入序列的下一個子序列。 
		while(m.find())
		{
			System.out.println(m.group());
			System.out.println(m.start()+" : "+m.end());
		}
	}
}

執行結果爲：

jia
3 : 6
hao
7 : 10
jia
29 : 32

正則表達式練習1–治療口吃

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

public class RegexDemo9 {
	
	public static void main(String[] args) {
		/*
		 * 	1、治療口吃：我....我我.....我我...我我我...我我...我..我要......要....要要...要要學學學....學學學....學學....學學編編編....編編編...編編...編...編程程....程程....程...程...程程....程程
		 */
		String str="我....我我.....我我...我我我...我我...我..我要......要....要要...要要學學學....學學學....學學....學學編編編....編編編...編編...編...編程程....程程....程...程...程程....程程";
		//	1、將字符串中點.去掉，用替換
		str=str.replaceAll("\\.", "");
		System.out.println(str);
		
		// 替換疊詞
		str=str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
	}
}

執行結果爲：

我我我我我我我我我我我我要要要要要要學學學學學學學學學學編編編編編編編編編編程程程程程程程程程程
我要學編程

正則表達式練習2–對ip地址進行排序

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

public class RegexDemo10 {
	
	public static void main(String[] args) {
		/*
		 * 	對ip地址進行排序
		 * 	192.168.10.34  127.0.0.1  3.3.3.3  105.70.11.55
		 */
		String ip_str="192.168.10.34  127.0.0.1  3.3.3.3  105.70.11.55";
		
		// 1、爲了讓ip可以按照字符串順序比較，只要讓ip的每一段位數相同
		//	所以，補零，按照每一位所需做多少進行補充，每一段都加兩個0
		ip_str=ip_str.replaceAll("(\\d+)", "00$1");
		System.out.println(ip_str);
		
		//2、然後每一段保留三位
		ip_str=ip_str.replaceAll("0*(\\d{3})", "$1");
		System.out.println(ip_str);
		
		//3、將ip地址分割
		String[] ips=ip_str.split("\\s+");
		TreeSet<String> ts=new TreeSet<String>();
		for(String ip:ips)
		{
			ts.add(ip);
		}
		
		for(String ip:ts)
		{
			System.out.println(ip.replaceAll("0*(\\d+)", "$1"));
		}
	}
}

執行結果爲：

00192.00168.0010.0034  00127.000.000.001  003.003.003.003  00105.0070.0011.0055
192.168.010.034  127.000.000.001  003.003.003.003  105.070.011.055
3.3.3.3
105.70.11.55
127.0.0.1
192.168.10.34

正則表達式練習3–對郵件地址進行校驗

public class RegexDemo11 {
	
	public static void main(String[] args) {
		/*
		 * 	對郵件地址校驗
		 */
		String mail="[email protected]";
		String regex="[a-zA-Z0-9_]+@[a-zA-Z0-9]+\\.[a-zA-Z]{2,3}";
		
		boolean b=mail.matches(regex);
		System.out.println(mail+" : "+b);
	}
}

執行結果爲：

abc1@sina.com : true

JavaSE--正則表達式專題

正則表達式的引入

正則表達式的規則

正則表達式規則的使用實例

正則表達式功能簡介

正則表達式功能–匹配

正則表達式功能–分割

正則表達式功能–替換

正則表達式功能–獲取

正則表達式練習1–治療口吃

正則表達式練習2–對ip地址進行排序

正則表達式練習3–對郵件地址進行校驗

工作中用到的腳本合集

24-5-18 X

每天十分鐘學習python基礎（1）-課程簡介以及python簡介

Java Swing （五）如何使用佈局管理器組件（3）FlowLayout佈局管理器

不懂帶團隊你就自己累（2）領導力是一種力量

不懂帶團隊你就自己累（1）管理角色認知與角色定位

Java Swing （三）Java Swing 組件基礎（2）Windows類

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結