认识正则表达式
通过之前一些列的分析可以发现,String是一个非常万能的类型,因为String不仅仅可以支持各种字符串的处理操作,也支持有向各个数据类型的转换功能,所以在项目的开发之中,只要是用户输入的信息基本上都用String表示。于是在向其他数据类型转换的时候,为了保证转换的正确性,往往需要对其进行一些复杂的验证处理,那么这种情况下如果只是单纯的依靠String的方法是非常麻烦的。
现在假设有一个字符串要求你判断是否由数字所组成,如果由数字所组成则将其变为数字进行乘法计算。
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "123" ;
if (isNumber(str)) {
int num = Integer.parseInt(str) ;
System.out.println(num * 2);
}
}
public static boolean isNumber(String str) {
char data [] = str.toCharArray();
for (int x = 0; x < data.length ; x ++) {
if (data[x] > '9' || data[x] < '0') {
return false ;
}
}
return true ;
}
}
实际上这种验证的功能是非常简单的,但是这如此简单的功能却需要开发者编写大量的程序逻辑代码,那么如果是更加复杂的验证呢?那么在这样的情况下,对于验证来讲最好的做法就是利用正则表达式来完成。
范例:使用正则表达式实现同样的效果
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "123" ;
if (str.matches("\\d+")) {
int num = Integer.parseInt(str) ;
System.out.println(num * 2);
}
}
}
正则表达式最早是从Perl语言里面发展而来的,而后在JDK1.4以前如果需要使用到正则表达式的相关定义则需要单独引入其他的*.jar文件,但是从JDK1.4之后,正则已经默认被JDK所支持,并且提供有java.util.regex开发包,同时针对于String类也进行了一些修改,使其可以由方法直接支持正则处理。
使用正则最大的特点在于方便进行验证处理,以及方便进行复杂字符串的修改处理。
常用正则标记(背)
如果要想进行正则的处理操作,那么就首先需要对常用的正则标记有所掌握,从JDK1.4开始提供有java.util.regex开发包,这个包里面提供有一个Pattern程序类,在这个程序类里面定义有所支持的正则标记。
1、【数量:单个】字符匹配
任意字符:表示由任意字符组成;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "a" ; // 要判断的数据
String regex = "a" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
\: 匹配“\” ;
\n: 匹配换行 ;
\t: 匹配制表符 ;
2、【数量:单个】字符集(可以从里面任选一个字符)
[ abc ] :表示可能是字母a、b、c中的任意一个;
[ ^abc ]:表示不是由字母a、b、c中的任意一个;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "x" ; // 要判断的数据
String regex = "[^abc]" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "x" ; // 要判断的数据
String regex = "[a-zA-Z]" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "1" ; // 要判断的数据
String regex = "[0-9]" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
3、【数量:单个】简化字符集
“ . ”:表示任意的一个字符;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "#" ; // 要判断的数据
String regex = "." ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
\d : 等价于“0-9”范围;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "1" ; // 要判断的数据
String regex = "\\d" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
\D: 等价于[^0-9],不是一个数字;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "a" ; // 要判断的数据
String regex = "\\D" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
\s:匹配任意的一位空格、可能是空格、换行、制表符;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "a\t" ; // 要判断的数据
String regex = "\\D\\s" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
\S:匹配任意的非空格数据;
\w:匹配字母、数字、下划线,等价于“[ a-zA-Z 0-9]” ;
\W:匹配非字母、数字、下划线,等价于“[^a-zA-Z 0-9]”
4、边界匹配:
^:匹配边界开始;
$:匹配边界结束;
5、数量表示,默认情况下只有添加上了数量单位才可以匹配多位字符;
表达式?:该正则可以出现0次或1次;
表达式*:该正则可以出现0次、1次或多次;
表达式+:该正则可以出现1次或多次
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "" ; // 要判断的数据
String regex = "\\w*" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
表达式{n}:表达式的长度正好为n次;
表达式{n,}:表达式的长度为n次以上;
表达式{n,m}:表达式的长度在n~m次;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "abc" ; // 要判断的数据
String regex = "\\w*{3}" ; // 正则表达式
System.out.println(str.matches(regex)) ; // true
}
}
6、逻辑表达式:可以连接多个正则:
表达式X表达式Y:X表达式之后紧跟上Y表达式;
表达式X|表达式Y:有一个表达式满足即可;
(表达式):为表达式设置一个整体描述,可以为整体描述设置数量单位。
String类对正则的支持
在进行正则表达式大部分处理的情况下都会基于String类完成,并且在String类里面提供有如下关于正则表达式的方法。
范例:实现字符串的替换(删除掉非字母与数字)
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "JJOR#$^FFRFB%23455f" ; // 要判断的数据
String regex = "[^0-9a-zA-Z]+" ; // 正则表达式
System.out.println(str.replaceAll(regex, "")) ;
}
}
范例:实现字符串拆分
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "a1b22c333d4444f55555g6666666" ; // 要判断的数据
String regex = "\\d+" ; // 正则表达式
String result [] = str.split(regex) ;
for (int x = 0; x < result.length ; x ++) {
System.out.print(result[x] + "、");
}
}
}
在正则处理的时候对于拆分与替换操作相对容易一些,但是比较麻烦的是数据验证部分。
范例:判断一个数据是否为小数,如果是小数则将其变为double类型
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "100.1" ; // 要判断的数据
String regex = "\\d+(\\.\\d+)?" ; // 正则表达式
System.out.println(str.matches(regex)); // true
}
}
范例:现在判断一个字符串是否由日期所组成,如果是由日期所组成则将其转为Date类型
package cn.mldn.demo ;
import java.text.SimpleDateFormat ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "1998-10-15" ; // 要判断的数据
String regex = "\\d{4}-\\d{2}-\\d{2}" ; // 正则表达式
if (str.matches(regex)) {
System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse(str)) ;
}
}
}
需要注意的是,正则表达式无法对立面的内容进行判断,只能够对格式进行判断处理。
范例:判断给定的电话号码是否正确?
电话号码:51283346; \d{7,8}
电话号码:01051283346
电话号码:(010)-51283345。
package cn.mldn.demo ;
import java.text.SimpleDateFormat ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "51283346" ; // 要判断的数据
String regex = "\\d{7,8}" ; // 正则表达式
System.out.println(str.matches(regex)); // true
}
}
package cn.mldn.demo ;
import java.text.SimpleDateFormat ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "01051283346" ; // 要判断的数据
String regex = "(\\d{3,4})?\\d{7,8}" ; // 正则表达式
System.out.println(str.matches(regex)); // true
}
}
package cn.mldn.demo ;
import java.text.SimpleDateFormat ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "(010)-51283346" ; // 要判断的数据
String regex = "((\\d{3,4})|(\\(\\d{3,4}\\)-))?\\d{7,8}" ; // 正则表达式
System.out.println(str.matches(regex)); // true
}
}
既然已经可以使用正则进行验证了,那么下面就可以利用其来实现一个email地址格式的验证。
范例:验证email格式
email的用户可以由字母、数字、所组成;(不应该使用“”开头);
email的域名可以由字母、数字、_、-所组成;
域名的后缀必须是:.cn、.com、,net、.com.cn、.gov;
package cn.mldn.demo ;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "mldnjava888@mldn.cn" ; // 要判断的数据
String regex = "[a-zA-Z0-9]\\w+@\\w+\\.(cn|com|com.cn|net|gov)" ; // 正则表达式
System.out.println(str.matches(regex)); // true
}
}
现在这几种正则的匹配操作是最常用的几种方式。
java.util.regex包支持
虽然在大部分的情况下都可以利用String类实现正则的操作,但是也有一些情况下需要使用到java.util.regex开发包中提供的正则处理类,在这个包里面一共定义有两个类:Pattern(正则表达式编译)、Matcher(匹配)。
1、Pattern类提供有正则表达式的编译处理支持:public static Pattern compile(String regex)
同时也提供有字符串的拆分操作:public String[] split(CharSequence input);
package cn.mldn.demo ;
import java.util.regex.Pattern;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "JKL()UI^&()JKLSD()QW@#$WEFEF" ; // 要判断的数据
String regex = "[^a-zA-Z]+" ; // 正则表达式
Pattern pat = Pattern.compile(regex) ; // 编译正则表达式
String result [] = pat.split(str) ; // 拆分
for (int x = 0; x < result.length ; x ++) {
System.out.println(result[x]);
}
}
}
2、Matcher类,实现了正则匹配的处理类,这个类的对象实例化依靠Pattern类完成:
Pattern类提供的方法:public Matcher matcher(CharSequence input);
当获取了Matcher类的对象之后就可以利用该类中的方法进行如下操作:
正则匹配:public boolean matches();
字符串替换:public String replaceAll(String replacement)
package cn.mldn.demo ;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "101" ; // 要判断的数据
String regex = "\\d+" ; // 正则表达式
Pattern pat = Pattern.compile(regex) ; // 编译正则表达式
Matcher mat = pat.matcher(str) ;
System.out.println(mat.matches());
}
}
范例:字符串替换
package cn.mldn.demo ;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DeadLock {
public static void main(String[] args) throws Exception {
String str = "1KKK3KK3NGKF344KKDF34 &*(f F" ; // 要判断的数据
String regex = "\\D+" ; // 正则表达式
Pattern pat = Pattern.compile(regex) ; // 编译正则表达式
Matcher mat = pat.matcher(str) ;
System.out.println(mat.replaceAll(""));
}
}
如果纯粹的是以拆分、替换、匹配三种操作为例根本用不到java.util.regex开发包,只依靠String类就都可以实现了。但是Matcher类里面提供有一种分组的功能,而这种分组的功能是String不具备的。
package cn.mldn.demo ;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DeadLock {
public static void main(String[] args) throws Exception {
// 要求取出“#{内容}标记中的所有内容”
String str = "INSERT INTO dept(deptno,dname,loc) VALUES (#{deptno}, #{dname}, #{loc})" ; // 要判断的数据
String regex = "#\\{\\w+\\}" ; // 正则表达式
Pattern pat = Pattern.compile(regex) ; // 编译正则表达式
Matcher mat = pat.matcher(str) ;
while(mat.find()) { // 是否有匹配成功的内容
System.out.println(mat.group(0).replaceAll("#|\\{|\\}", ""));
}
}
}
java.util.regex开发包,如果不是进行一些更为复杂的正则处理是很难使用到的,而String类所提供的只适合用于正则的基本操作。