对正则表达式的理解

正则表达式

 

正则表达式虽然不需要我们深入研究，但是必须看懂其中的意思，以及明白一些它的语法

以下是一些简单的正则表达式的语法，需要我们去牢记它

字符

 

x x字符

\\ 反斜线字符

\t 制表符

\n 换行符

\r 回车符

字符类:

[abc] a、b 或 c（简单类）

[^abc] 任何字符，除了 a、b 或 c（否定）

[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类:

. 任何字符 如果本身就是. \. qq.com 写正则表达式(\\.)

\d 数字：[0-9] 写正则表达式 :\\d

\w 单词字符：[a-zA-Z_0-9]:字母大小写,数字字符 \\w

 

边界匹配器:

^  行的开头

$  行的结尾

\b 单词边界 尾 (helloword?haha:world)

 

Greedy 数量词(重点)

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X字符恰好出现n次

X{n,} X字符至少出现n次

X{n,m} X字符至少出现n次,但不超过m次

正则表达式的引入：

在我们还没有学习正则表达式之前，当需要我们去检测一个QQ号的格式是否正确，就需要我们用普通if-else语句去一步一步书写

例如：

package practiceDome;
 
import java.util.Scanner;
 
//检测QQ
public class Text5 {
 
public static void main(String[] args) {
//创建键盘录入QQ号码
Scanner sc=new Scanner(System.in);
System.out.println("请您输入您的QQ号码");
String QQ=sc.nextLine();
boolean flag=checkQQ(QQ);//调用下面的静态方法
System.out.println("flag:"+flag);
}
//创建一个静态的方法去判断QQ所需要的要求
public static boolean checkQQ(String QQ) {
boolean flag=true;
if(QQ.length()>=5&&QQ.length()<=10) { //判断QQ的位数是不是在5位数到10位数之间
if(!QQ.startsWith("0")) { //判断QQ的开头是不是以0开头的
char[] ch=QQ.toCharArray(); //将Sstring类型的数组转换成字符数组类型
for(int x=0;x<ch.length;x++) {
char c=ch[x];
if(!Character.isDigit(c)) { //判断转换成的字符数组是不是数字
flag= false;
break;
}
}
}else {
flag= false;
}
}else {
flag= false;
}
return flag;
}
}

通过正则表达式之后，我们可以对上述代码进行优化,例如：

package practiceDome;
 
import java.util.Scanner;
 
//QQ改进版用正则表达式去编译
public class Text6 {
 
public static void main(String[] args) {
//创建一个键盘录入对象
Scanner sc=new Scanner(System.in);
System.out.println("请您输入您的QQ号：");
String QQ=sc.nextLine();
boolean flag=checkqq(QQ);
System.out.println("flag:"+flag);
}
public static boolean checkqq(String qq) {
// String s="[1-9][0-9] {4,14}"; 
// boolean flag=qq.matches(s);
// return flag;
// 下面的返回值是上面的简写方式
return qq.matches("[0-9][1-9]{4,15}");
}
}

以上两种方法都可以检测出来我们的QQ号，但是对比之后，发现运用正则表达式的代码则很简单方便。

下面让我们用正则表达式进行一些小练习：

检测手机号码：

package practiceDome;
 
import java.util.Scanner;
 
//用正则表达式去检测手机号码
public class PhoneRegexDome {
 
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请您输入您的手机号码：");
String number =sc.nextLine();
boolean flag=checknum(number);
System.out.println("flag:"+flag);
}
public static boolean checknum(String number) {
String regex="1[1-9]\\d{9}";
return number.matches(regex);
}
}

检测邮箱号码：

package practiceDome;
 
import java.util.Scanner;
 
//用正则表达式去检测手机号码
public class PhoneRegexDome {
 
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请您输入您的手机号码：");
String number =sc.nextLine();
boolean flag=checknum(number);
System.out.println("flag:"+flag);
}
public static boolean checknum(String number) {
String regex="1[1-9]\\d{9}";
return number.matches(regex);
}
}

下面让我们来学习一个正则表达式的方法：

public String[] split(String regex) :字符串的分割功能

package com.Math;
public class splitDome2 {
 
public static void main(String[] args) {
String s="18-23";
String[] str=s.split("-");
int d1=Integer.parseInt(str[0]);
int d2=Integer.parseInt(str[1]);
int height=20;
if(height>=d1&&height<=d2) {
System.out.println("你是这个范围的哦");
}else {
System.out.println("很遗憾你不是...");
}
}
}
运行结果：你是这个范围的哦

分割方法除了分割这个“-”符号外，还有其他符号需要我们在书写上注意

例如：

package com.Math;
 
public class SplitDome3 {
 
public static void main(String[] args) {
//当分割的符号是“，”时
String s="aa,bb,cc";
String[] str=s.split(",");
for(int x=0;x<str.length;x++) {
System.out.print(str[x]+" ");
}
System.out.println("-----------------");
//当分割的符号是"."时，需要我们注意敲代码时应该写"\\."
String s2="aa.bb.cc";
String[] str2=s2.split("\\.");
for(int x=0;x<str2.length;x++) {
System.out.print(str2[x]+" ");
}
System.out.println("--------------------");
//当我们的中间空格数量不一时，在书写时应该用" +"
String s3="aa     bb             cc";
String[] str3=s3.split(" +");
for(int x=0;x<str3.length;x++) {
System.out.print(str3[x]+" ");
}
System.out.println("---------------------");
//当遇到电脑上文件保存的路径,书写"\\"应该写成"\\\\"
String s4="F:\\java\\bin\\jdk";
String[] str4=s4.split("\\\\");
for(int x=0;x<str4.length;x++) {
System.out.print(str4[x]+" ");
}
}


}
运行结果：
aa bb cc -----------------
aa bb cc --------------------
aa bb cc ---------------------
F: java bin jdk

例题：

当我们想让一个字符串数组排序排时

 

package practiceDome;
 
import java.util.Arrays;
 
//有一个字符串将它按从小到大排序好
public class splitArraysDome {
 
public static void main(String[] args) {
String s="23 56 67 54 34";
String[] str=s.split(" ");
//创建一个长度固定的int数组
int[] arr=new int[str.length];

for(int x=0;x<arr.length;x++) {
//将字符串数组遍历后转换成int类型数组
arr[x]=Integer.parseInt(str[x]);
}
Arrays.sort(arr);
//将int数组转变成字符串数组
StringBuilder sb=new StringBuilder();
for(int x=0;x<arr.length;x++) {
sb.append(arr[x]).append(" ");

}
//将int类型转变成字符串数组并去除两端空格
String t= sb.toString().trim();
System.out.println(t);
}
运行结果：23 34 54 56 67
替换功能：
public String replaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
例如：
package practiceDome;
 
public class regexDome {
 
public static void main(String[] args) {
String str="adgasgh1345648AGDASGHYBA";
//定义需要替换掉的数字
String regex="\\d+";
//定义替代的*号
String s="*";
String result=str.replaceAll(regex, s);
System.out.println("result："+result);
}
}
运行结果：
result：adgasgh*AGDASGHYBA

当判断字符串是否符合正则表达式，牵引出模式和匹配器的调用：

将正则表达式编译成一个模式对象

public static Pattern compile(String regex)将给定的正则表达式编译到模式中

通过模式对象,构造一个匹配器对象(Matcher对象)

Matcher matcher(String input)  :模式对象转换成匹配器对象

匹配器对象有一个方法:machers() ; 直接对当前字符串数据进行校验,返回boolean类型值

 public boolean matches()

例如 ：

package practiceDome;
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class patternDome {
 
public static void main(String[] args) {
//定义一个字符串
String regex="a+b";//a+代表a出现一次或多次
//将需要判断的正则表达式放进创建好的模式中
Pattern p=Pattern.compile(regex);
//通过模式对象创建一个匹配器对象（matcher方法）
Matcher m=p.matcher("b");//这里a一次也没有出现，所以结果应该是false
//调用匹配器方法（macthes）去检测
boolean flag=m.matches();
System.out.println("flag:"+flag);
}
}
运行结果：
flag:false

但是上述方法显得有点繁琐，在实际中有时候并不怎么常用，所以我们一般用下面这种方法，具体用哪种方法还得具体看

例如：

package practiceDome;
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class patternDome {
 
public static void main(String[] args) {
//定义一个字符串
String regex="a+b";//a+代表a出现一次或多次
//将需要判断的正则表达式放进创建好的模式中
Pattern p=Pattern.compile(regex);
//通过模式对象创建一个匹配器对象（matcher方法）
Matcher m=p.matcher("b");//这里a一次也没有出现，所以结果应该是false
//调用匹配器方法（macthes）去检测
boolean flag=m.matches();
System.out.println("flag:"+flag);
System.out.println("===================");
String s="b";
//直接调用matches方法去检测
boolean flag1=s.matches(regex);
System.out.println("flag:"+flag1);
}
}
运行结果：
flag:false
===================
flag:false

根据上例，从两者进行比较，我们不难发现第二种方法更加简单方便，所以具体怎么用得看自己