java基础笔记（十四）正则表达式
今天学习到正则表达式，真有意思。
在jdk文档中 Patten类有具体的规则描述：
常用的是这几个：
A:字符
x 字符 x。举例：‘a’表示字符a
\ 反斜线字符。
\n 新行（换行）符 (’\u000A’)
\r 回车符 (’\u000D’)
B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括
C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? .
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成
D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi
E:Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
正则表达式的判断功能：
现在展示俩个例子，一个验证手机号码，一个验证邮箱：
package com.st.basis.day14.RegularExpression;
import java.util.Scanner;
/*
* 正则表达式的应用
* 规则看jdk文档 Patten类
* */
public class RegaxDemo {
public static void main(String[] args) {
// 判断手机号码是否符合要求
labe:while(true){
Scanner sc = new Scanner(System.in);
System.out.println("输入手机号");
String input = sc.nextLine();
boolean out = demo01(input);
System.out.println(out); //输出验证的结果，true/fasle
while(out == true){
sc.close();
// return; //正确就跳出循环。
break labe; //俩种跳出循环方式
}
}
//判断邮箱
while(true){
Scanner sc = new Scanner(System.in);
System.out.println("输入邮箱号");
String input = sc.nextLine();
boolean out = demo02(input);
System.out.println(out);
while(out == true){
sc.close();
return;
}
}
}
//正则表达式判断功能
//String类中的public boolean matches(String regax)
private static boolean demo01(String input) {
String regax = "1[3-7]\\d{9}";
boolean res = input.matches(regax);
return res;
}
//判断邮箱
private static boolean demo02(String input) {
/*
* [email protected]
* [email protected]
* [email protected]
* 分析： @前面的字符可能是数字也可能是字母，且数量不确定 ： [a-zA-Z_0-9]+
* 然后 @ [a-zA-Z_0-9]+@
* @后面的也不确定是数字还是字母但肯定没大写.且数量不确定，但大致在2到6之间 [a-z_0-9]{2,6} [a-zA-Z_0-9]+@[a-z_0-9]{2,6}
* 然后 加一个点 \\. [a-zA-Z_0-9]+@[a-z_0-9]{2,6}\\.
* 然后后面只有英文 [a-z] [a-zA-Z_0-9]+@[a-z_0-9]{2,6}\\.[a-z]
* 但 .后面可能有好几个后缀 就需要改进 (\\.[a-z]{2,3})+ [a-zA-Z_0-9]+@[a-z_0-9]{2,6}(\\.[a-z]{2,3})+
*
* */
String regax = "[a-zA-Z_0-9]+@[a-z_0-9]{2,6}(\\.[a-z]{2,3})+";
boolean res = input.matches(regax);
return res;
}
}
正则表达式的分割功能：
package com.st.basis.day14.RegularExpression;
import java.util.Arrays;
import java.util.Scanner;
/*
*
* 正则表达式的应用
* 规则看jdk文档 Patten类
* 分割功能
*
* 应用实例：
* 上网站搜索，自己想限定年龄为 18-24岁女性
* 那在搜索条件中写入这个条件，提交以后系统拿到的就是一个字符串 "18-24"
* 系统进行比对就需要拿到18和24，而不是这个字符串
* 就可以用正则的分割功能
* public String[] split(String regex)
* 注意该方法返回的是一个String[]
* */
public class RegaxDemo2 {
public static void main(String[] args) {
demo01(); //搜索限定年龄
demo02(); //分割字符串
demo03(); //分割字符串并且排序
}
private static void demo01() { //搜索限定年龄
//输入筛选条件
Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄范围：");
String range = sc.nextLine();
//定义规则
String regax = "-"; //输入的字符串格式是 18-24 规则就是 -
//调用
String[] arr = range.split(regax); //得到的是arr，里面放着 18，24
//获取数组中的值并转为int
int snum = Integer.parseInt(arr[0]); //得到了18
int endnum = Integer.parseInt(arr[1]); //得到了24
//筛选判断
System.out.println("请输入年龄");
int age = sc.nextInt();
if(age >= 18 && age <= 24){
System.out.println("合格");
}else{
System.out.println("不合格");
}
sc.close();
}
//
private static void demo02() {
String str = "aa,bb,cc"; //将aa,bb,cc这个字符串按 aa bb cc 输出
String[] arr = str.split(","); //调用方法 规则就是,
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]+" ");
}
System.out.println();
System.out.println("-----------------");
String str2 = "dd.ee.ff";
String[] arr2 = str2.split("\\."); //调用方法 规则是. 但在正则中.代表任意字符，所以需要转义
for(int i=0; i<arr2.length; i++){
System.out.print(arr2[i]+" ");
}
System.out.println();
System.out.println("-----------------");
String str3 = "gg hh qq"; //这个字符串中间有空格，但不确定有几个
String[] arr3 = str3.split(" +"); //调用方法 空格+ 代表一次或一次以上
for(int i=0; i<arr3.length; i++){
System.out.print(arr3[i]+" ");
}
System.out.println();
System.out.println("-----------------");
//硬盘中用\\代替\
String str4 = "F:\\学习资料\\01、第一阶段 Java基础(27天)\\day26\\avi";
String[] arr4 = str4.split("\\\\"); //调用方法 正则中\\代表\
for(int i=0; i<arr4.length; i++){
System.out.print(arr4[i]+" ");
}
System.out.println();
System.out.println("-----------------");
}
private static void demo03() {
String str = "27 89 75 22 15";
String[] arr = str.split(" ");
//字符串数组转int数组
int[] arr2 = new int[arr.length];
for(int i=0; i<arr.length; i++){
arr2[i] = Integer.parseInt(arr[i]);
}
//现在排序
Arrays.sort(arr2); //二分排序
//数组转字符串并输出
String res = Arrays.toString(arr2);
System.out.println(res); //输出的是：[15, 22, 27, 75, 89] 但我不喜欢这个格式就自己拼接
//自己拼接
StringBuilder sb = new StringBuilder();
for(int i=0; i<arr.length; i++){
if(i<arr.length-1){
sb.append(arr2[i]).append(" ");
}else{
sb.append(arr2[i]);
}
}
System.out.println(sb.toString());
}
}
结果：
[15, 22, 27, 75, 89]
15 22 27 75 89
正则表达式的替换功能：
package com.st.basis.day14.RegularExpression;
/*
* 正则表达式
* 替换功能
* public String replaceAll(String regex,String replacement)
* 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
* */
public class RegaxDemo3 {
public static void main(String[] args) {
demo01();
}
private static void demo01() {
String str = "hohot666beijing123java";
//去除所有数字，用*替换
String regax = "\\d+"; //正则 规则
String s = "*"; //替换的字符串
//调用方法
String res = str.replaceAll(regax, s);
System.out.println(res);
}
}
结果
hohot*beijing*java
正则表达式的获取功能：
package com.st.basis.day14.RegularExpression;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
* 正则表达式
* 获取功能
* API说明：
* Pattern和Matcher类的使用
* public final class Patternextends Object implements Serializable
* 正则表达式的编译表示形式。
*
* 指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
*
* 因此，典型的调用顺序是
*
* Pattern p = Pattern.compile("a*b");
* Matcher m = p.matcher("aaaaab");
* boolean b = m.matches();
* */
public class RegaxDemo4 {
public static void main(String[] args) {
demo01(); //引出
demo02();
}
private static void demo01() {
//将这个规则编译成模式对象
Pattern p = Pattern.compile("a*b"); //"a*b"是一个规则 *：0次或多次
//通过模式对象得到匹配器对象
Matcher m = p.matcher("aaaaab"); //"aaaaab"是需要匹配的字符串
boolean b = m.matches(); //调用匹配去对象的功能
System.out.println(b); //输出结果 true
//上述是一个针对与API例子做的demo，但实际要满足上述需求这样做就可以：
String str = "aaaaab";
String regex = "a*b";
boolean res = str.matches(regex);
System.out.println(res);
}
//获取功能：获取下列字符串中由三个字符组成的单词
//String str = "ni hao a, wo shi java ai hao zhe.ni ne ?"
private static void demo02() {
String str = "ni hao a, wo shi java ai hao zhe.ni ne ?";
String regex = "\\b[a-zA-Z]{3}\\b"; // \b单词边界 [a-zA-Z]{3}三个字符组成的字串
//将这个规则编译成模式对象
Pattern p = Pattern.compile(regex);
//通过模式对象得到匹配器对象
Matcher m = p.matcher(str);
//调用匹配去对象的功能
//通过find方法 查找有没有满足条件的字串
boolean res = m.find();
System.out.println(res); //输出 true 说明有符合规则的字串
//下面输出这些字串
while(m.find()){
System.out.println(m.group()); //先利用find方法，再利用group方法
}
}
}
结果
true
shi
hao
zhe