JAVA基础（常用API） —— 正则表达式

 经过之前对于API的学习：JAVA基础 —— API

接下来的文章让我们来了解一下不同类下的方法，但是这些方法不要去背。

而是要去记一下类名和类作用，也可以在以后去查阅API帮助文档。

Math、System、Runtime和Object	JAVA基础 （常用API）—— Math、System、Runtime和Object
BigInteger和BigDecimal	JAVa基础（常用API） —— BigInteger和BigDecimal
正则表达式	JAVA基础（常用API） —— 正则表达式
时间相关类	JAVA基础（常用API） —— 时间相关类
包装类	JAVA基础（常用API） —— 包装类

---

目录

 一、 校验字符串

1.  字符类

2.  预定义字符

3.  数量词

4.  练习

二、  爬虫

1. 本地爬虫

1.1 带条件爬取

1.2  贪婪爬取和非贪婪爬取

2. 网络爬虫

三、分组

 1. 捕获分组

2. 非捕获分组

---

import java.util.regex.Pattern  正则表达式包

import java.util.regex.Matcher 文本匹配器包

作用1 ：正则表达式可以校验字符串是否满足一定的规则，并用来校验数据格式的合法性。

作用2 ：正则表达式可以在一段文字中查找满足要求的内容。

---

正则表达式在字符串方法中的使用：

方法名	说明
public String[ ]  matches（String regex）	判断是否与正则表达式匹配
public String replaceAll (String regex,String newStr)	按照正则表达式的规则进行替换
public String[ ] spilt (String regex)	按照正则表达式的规则进行切割字符串

 一、 校验字符串

1.  字符类

字符类（只匹配一个字符）：

public class matchesTest {
	public static void main(String[] args) {
		// 一个大括号只能是一个字符

		// 只能是a b c
		System.out.println("a".matches("[abc]")); // true
		System.out.println("z".matches("[abc]")); // false
		System.out.println("ab".matches("[abc]")); // false
		System.out.println("ab".matches("[abc][abc]")); // true

		// 不能出现a b c
		System.out.println("a".matches("[^abc]")); // fasle
		System.out.println("zz".matches("[^abc]")); // fasle

		// a到z A到Z（包括头尾范围）
		System.out.println("b".matches("[a-zA-Z]")); // true
		System.out.println("0".matches("[a-zA-Z]")); // fasle

		// [a-d[m-p]] a到d 或者 m到p
		System.out.println("b".matches("[a-d[m-p]]")); // true
		System.out.println("e".matches("[a-d[m-p]]")); // fasle

		// [a-z&&[def]] a-z和def的交集
		// 细节：如果要求两个范围的交集 需要写&&
		// 如果写成了一个& 就不表示交集 只是单单一个符号而已
		System.out.println("a".matches("[a-z&&[def]]")); // true
		System.out.println("&".matches("[a-z&&[def]]")); // false

		// [a-z&&[^bc]] a-z 和 非bc 的交集
		System.out.println("a".matches("[a-z&&[^bc]]")); // true
		System.out.println("b".matches("[a-z&&[^bc]]")); // false

		// [a-z&&[^m-p]] a到z和除了m到p的交集
		System.out.println("a".matches("[a-z&&[^m-p]]")); // true
		System.out.println("m".matches("[a-z&&[^m-p]]")); // false
	}
}

2.  预定义字符

 预定义字符（只匹配一个字符）：

public class matchesTest {
	public static void main(String[] args) {
		// \表示转义字符 ：改变后面字符原本含义
		// 练习：以字符串形式打印一个双引号
		// System.out.println("\"");

		// .表示任意一个字符
		System.out.println("你".matches(".")); // true
		System.out.println("你a".matches("..")); // true

		// \\d 只能是任意一个数字
		// 简单来说 两个\表示一个\
		System.out.println("a".matches("\\d")); // fasle
		System.out.println("3".matches("\\d")); // true
		System.out.println("333".matches("\\d")); // fasle
		System.out.println("333".matches("\\d\\d\\d")); // true

		// \\w只能是一个单词字符 [a-zA-Z0-9]
		System.out.println("z".matches("\\w")); // true
		System.out.println("21".matches("\\w")); // false
		System.out.println("你".matches("\\w")); // fasle
		System.out.println("-".matches("\\w")); // true

		// 非单词字符
		System.out.println("你".matches("\\W")); // true
		// 以上正则表达式只能校验单个字符
	}
}

3.  数量词

public class matchesTest {
	public static void main(String[] args) {
		//必须是数字 字母 下划线 至少 6位
		System.out.println("2442fsfsf".matches("\\w{6,}")); //true
		System.out.println("244f".matches("\\w{6,}")); //false
		
		//必须是数字和字符 必须是 4位
		System.out.println("23dF".matches("[a-zA-Z0-9]{4}")); //true
		System.out.println("23_F".matches("[a-zA-Z0-9]{4}")); //false
		System.out.println("23dF".matches("\\w&&[^_]{4}")); //true
		System.out.println("23_F".matches("\\w&&[^_]{4}")); //fasle
	}
}

4.  练习

需求：
请编写正则表达式验证用户输入的手机号码是否满足要求。

请编写正则表达式验证用户输入的邮箱号是否满足要求。

请编写正则表达式验证用户输入的电话号码是否满足要求。

public class matchesTest {
	public static void main(String[] args) {
		 
		//手机号： 三部分
		//一、 1 表示手机号码只能由1开头
		//二、 [3-9] 表示手机号码第二位只能是3-9之间
		//三、\\d{9} 表示任意数字可以出现9次，也只能出现9次
		String regex1 = "1[3-9]\\d{9}";
		System.out.println("13112345678".matches(regex1)); //true
		System.out.println("131123456789".matches(regex1)); //fasle
		
		//座机号码： 三部分
		//一、区号： 0表示区号只能以0开头  
		//         \\d{2,3} 表示区号从二位开始可以是任意数字，可以出现2~3次
		//二、 -  ?表示次数  次数0次或者1次
		//三、 号码  第一位不能以0开头；从第二位开始可以为任意数字 ；号码总长度： 5-10位
		String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
		System.out.println("020-2324242".matches(regex2)); //true
		
		//邮箱号码 ：三部分
		//一、 @左边  \\w+任意字符数字下划线至少出现一次就行
		//二、 @只能出现一次
		//三、   .的左边可以是字母和数字  [\\w&&[^_]]  任意字符数字总共出现2-6次  {2,6}
		//     .   \\.
		//     .的右边   所有的大写字母和小写字母 只能出现2-3次  [a-zA-Z]{2,3}
		String regex3 = "\\w+@[\\w&&[^_]]{2,6}\\.[a-zA-Z]{2,3}";
		System.out.println("zhangsan@163.com".matches(regex3)); //true
		
		//24小时
		String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
		System.out.println("23:11:11".matches(regex4)); //true
		
		String regex5 = "([01]\\d|2[0-3])(:[0-5]\\d){2}";
		System.out.println("23:11:11".matches(regex5)); //true
	}
}

二、  爬虫

在一段文字中查找满足要求的内容。

1. 本地爬虫

通过一个小练习来了解什么是本地爬虫：

有如下文本，请按照要求爬取数据。
             Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。

要求：找出里面所有的JavaXX

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

public class regexTest {
	public static void main(String[] args) {

		String str = " Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是"
          + "Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，"
				+ "相信在未来不久Java17也会逐渐登上历史舞台。";

		// 获取正则表达式对象
		Pattern p = Pattern.compile("Java\\d{0,2}");
		// 获取文本匹配器对象
		Matcher m = p.matcher(str);
		while(m.find()) {
			//知道字符串末尾 find为false
			String s=m.group();
			System.err.println(s);
		}
	}

	public static void method1(String str) {
		// Pattern:表达正则表达式
		// Matcher:文本匹配器 作用：按照正则表达式规则读取字符串，从头读取，找到符合规则的子串

		// 获取正则表达式对象
		Pattern p = Pattern.compile("Java\\d{0,2}");

		// 获取文本匹配器对象
		// m: 文本匹配器的对象
		// str：大串
		// p：规则
		// 即 m要在str中找到符合p规则的小串
		Matcher m = p.matcher(str);

		// 拿着文本匹配器从头开始读取，寻找是否有满足规则子串
		// 如果有，返回true，并且在底层记录子串的起始索引和结束索引+1
		// Java : 0,4
		// 如果没有，返回false
		boolean flag = m.find();

		// 方法底层根据find方法记录的索引进行字符串的截取
		// subString(起始索引,结束索引) 包头不包尾
		// (0,4) 但是不包含4索引
		// 会把截取的小串返回
		String s1 = m.group();
		System.out.println(s1);
		
		//第二次在调用find的时候，会维续读取后面的内容
		//读取到第二个满足要求的子串，方法会继续返回true
		//并把第二个子串的起始索引和结束索引+1，进行记录
		flag = m.find();
		
		//第二次调用group方法的时候，会根据find方法记录的索引再次截取子串
		String s2 = m.group();
		System.out.println(s2);
	}
}

 爬取小规则：

1.1 带条件爬取

需求1：爬取版本号为8,11,17的]ava文本，但是只要]ava，不显示版本号。
需求2：爬取版本号为8,11,17的ava文木。正确爬取结果为: Java8 JAva11 JAVa17 JAVA17。

需求3：爬取除了版本号为8,11,17的Java文本。

public class regexTest {
	public static void main(String[] args) {
		String str = " Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是"
		          + "Java8和JAva11，因为这两个是长期支持版本，下一个长期支持版本是JAVa17，"
						+ "相信在未来不久JAVA17也会逐渐登上历史舞台。";
		
		//1.定义正则表达式
		//? 表示前面的数据java
		// = 表示在java后面要跟随的数据
		//但是在获取的时候，只获取后半部分 
		//需求1
		String regex = "((?i)Java)(?=8|11|17)";
		
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(str);
		while (m.find()) {
			System.out.print(m.group() + ",");
		}
		
		System.out.println();
		//需求2
		String regex1 = "((?i)Java)(8|11|17)";
		Pattern p1 = Pattern.compile(regex1);
		Matcher m1 = p1.matcher(str);
		while (m1.find()) {
			System.out.print(m1.group() + ",");
		}
		
		System.out.println();
		String regex2 = "((?i)Java)(?:8|11|17)";
		Pattern p2 = Pattern.compile(regex2);
		Matcher m2 = p2.matcher(str);
		while (m2.find()) {
			System.out.print(m2.group() + ",");
		}
		
		System.out.println();
		//需求3
		// !去除的意思
		String regex3 = "((?i)Java)(?!8|11|17)";
		Pattern p3 = Pattern.compile(regex2);
		Matcher m3 = p3.matcher(str);
		while (m3.find()) {
			System.out.print(m3.group() + ",");
		}
		
	}
}

1.2  贪婪爬取和非贪婪爬取

贪婪爬取	在爬取数据的时候尽可能多的获取数据库
非贪婪爬取	在爬取数据的时候尽可能少的获取数据库

需求1：按照ab+的方式爬取ab，b尽可能多获取

需求2：按照ab+的方式爬取ab，b尽可能少获取

public class regexTest {
	public static void main(String[] args) {
		
		//Java当中，默认的就是贪婪爬取
		//如果我们在数量词 + * 的后面加上问号 那么就是非贪婪爬取
		
		String str = " Java自从95年问世以来，abbbbbbbbbbbbb" + 
	           "经历了很多版本，目前企业中用的最多的是"
				+"Java8和JAva11，因为这两个是长期支持版本，下一个长期支持版本是JAVa17，" + 
	           "相信在未来不久JAVA17也会逐渐登上历史舞台。";
		String regex = "ab+";
		Pattern p = Pattern.compile(regex);
		Matcher m=p.matcher(str);
		while (m.find()) {
			System.out.println(m.group());
		}
		String regex1 = "ab+?";
		Pattern p1 = Pattern.compile(regex1);
		Matcher m1=p1.matcher(str);
		while (m1.find()) {
			System.out.println(m1.group());
		}

	}
}

2. 网络爬虫

通过下面代码来了解什么是网络爬虫：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class regexTest {
	public static void main(String[] args) {
		//将某个URL网址中所有的身份证号码提取出来
		
		//创建一个URL对象
		URL url = new URL();
		//连接上网址
		//细节：保证网络是畅通的
		URLConnection conn = url.openConnection();
		//创建一个对象去读取网路中的数据
		BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
		String line;
		//获取正则表达式对象
		String regex = "[1-9]\\d{17}";
		Pattern pattern = Pattern.compile(regex);
		//在读取的时候每次读一整行
		
		while((line = br.readLine())!=null) {
			System.out.println(line);
			//拿着文本匹配器的对象matcher按照pattern的规则去读取当前这一行信息
			Matcher m = pattern.matcher(line);
			while(m.find()) {
				System.out.println(m.group());
			}
		}
		
	}
}

三、分组

分组就是一个小括号。 

 每组是有组号的，也就是序号。

规则1：从1开始，连续不间断。

规则2：以左括号为基准，最左边的是第一组，其次为第二组，以此类推。

 1. 捕获分组

捕获分组（默认）就是把这一组的数据捕获出来，再用一次。

组号的特点：

从1开始，连续不间断；以左括号为基准，最左边的是第一组。

正则内部使用	\\组号
正则外部使用	$组号

---

需求1：判断一个字符串的开始字符和结束字符是否一致？只考虑一个字符
举例:：a123a b456b 17891 &abc&

需求2：判断一个字符串的开始部分和结束部分是否一致？可以有多个字符

举例：abc123abc  b456b  123789123  &!@abc&!@

需求3：判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致
举例：aaa123aaa  bbb456bbb  111789111  &&abc&&

public class regexTest {
	public static void main(String[] args) {
		// 需求1
		// \\组号 表示把把x组内容再拿出来用一次
		String regex1 = "(.).+\\1";
		System.out.println("a123a".matches(regex1)); // true
		System.out.println("&abc&".matches(regex1)); // true
		System.out.println("b4561".matches(regex1)); // false

		//需求2
		String regex2 = "(.+).+\\1";
		System.out.println("abc123abc".matches(regex2)); // true
		System.out.println("&!@abc&!@".matches(regex2)); // true
		System.out.println("123789b".matches(regex2)); // false
		
		//需求3
		//某某某需要一致 需要捕获分组
		// (.) 把首字母看成一组
		//  \\2 被首字母拿出来再次使用
		//  * 作用于\\1 表示后面重复的内容出现0次或者多次
		String regex3 = "((.)\\2*).+\\1";
		System.out.println("aaa123aaa".matches(regex3)); // true
		System.out.println("&&abc&&".matches(regex3)); // true
		System.out.println("111789123".matches(regex3)); // false
	}
}

2. 非捕获分组

分组之后不需要再用本组数据，仅仅把数据括起来，不占组号。

符号	含义	举例
（？：正则）	获取所有	Java(?:8|11|17)
（？ = 正则）	获取前面部分	Java(?=8|11|17)
（？！ 正则）	获取不是指定内容的前面部分	Java(?!8|11|17)

public class regexTest {
	public static void main(String[] args) {
		//身份证号码的 简易正则表达式
		//非捕获分组：仅仅是把数据概括起来
		//特点：不占用组号
		
		// (?:) (?=) (?!)
		//更多使用第一个
		String regex  = "[1-9]\\d{16}(?:\\d|x|x)\\1";
		String regex1  = "[1-9]\\d{16}(\\d|x|x)\\1";
		
		System.out.println("41080119930228457x".matches(regex));
	}
}