Java类库之正则表达式（重点）
范例：代码实现
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = " 13412a 4124214141232" ;
if (isNumber(str)) {
System.out.println("是由数字所组成！");
} else {
System.out.println("不是由数字所组成！");
}
}
public static boolean isNumber(String data) {
char arr [] = data.toCharArray() ; // 字符串变为字符数组
for (int x = 0; x < arr.length; x++) {
if (arr[x] < '0' || arr[x] > '9') {
return false ;
}
}
return true ;
}
}
但是现在一个简单的问题就出现了，这个验证应该算是不难的，但是面对这样一个不麻烦的验证，代码写了9行代码，如果是一些更为复杂的验证呢？那么对于整体操作就更加的麻烦了，现在有另外一种做法：
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "1341224124214141232" ;
if (str.matches("\\d+")) {
System.out.println("是由数字所组成！");
} else {
System.out.println("不是由数字所组成！");
}
}
}
public class RegexDemo01{
public static void main(String args[]){
String str = "1234567890" ; // 此字符串由数字组成
boolean flag = true ; // 定义一个标记变量
// 要先将字符串拆分成字符数组，之后依次判断
char c[] = str.toCharArray() ; // 将字符串变为字符数组
for(int i=0;i<c.length;i++){ // 循环依次判断
if(c[i]<'0'||c[i]>'9'){ // 如果满足条件，则表示不是数字
flag = false ; // 做个标记
break ; // 程序不再向下继续执行
}
}
if(flag){
System.out.println("是由数字组成！") ;
}else{
System.out.println("不是由数字组成！") ;
}
}
};
很明显，现在对于程序而言，第二种方式更加的简单，而第二种方式就是使用了正则表达式的概念，而其中的“\d+”代码就属于正则表达式的程序代码。
正则表达式最早是在Linux下发展起来的，但是由于其使用方便，在JDK 1.4的时候将其正式引入到了Java的开发行列之中，而在JDK 1.4之前如果要想使用正则表达式，那么需要单独配置一个Apache的开发包，而JDK 1.4之后除了引入了正则的支持之外，同时也对String类进行了一些修改，可以让其直接操作正则。
在JDK 1.4之后专门引入了一个java.util.regex开发包，这个包之中有两个主要类负责完成正则的开发：Pattern（定义并且编译正则的匹配模板）、Matcher（匹配应用），之所以现在不去关心这两个类，主要是因为JDK 1.4之后对String类的修改达到了一个很好的正则操作效果，主要使用String类完成。
常用正则匹配符号（背，死了都要背）
所有的正则匹配的符号都在java.util.regex.Pattern类之中进行定义，下面分别对这些常用的符号做一些介绍。
1、 字符：匹配单个字符
· a：表示匹配字母a；
· \：匹配转义字符“\”；
· \t：匹配转义字符“\t”；
· \n：匹配转义字符“\n”；
2、 一组字符：任意匹配里面的一个单个字符；
· [abc]：表示可能是字母a，可能是字母b或者是字母c；
· [^abc]：表示不是字母a、字母b、字母c的任意一个；
· [a-zA-Z]：表示全部字母中的任意一个；
· [0-9]：表示全部数字的任意一个；
3、 边界匹配：在以后编写JavaScript的时候使用正则中要使用到；
· ^：表示一组正则的开始；
· $：表示一组正则的结束；
4、 简写表达式：每一位出现的简写标记也只表示一位；
· .：表示任意的一位字符；
· \d：表示任意的一位数字，等价于“[0-9]”；
· \D：表示任意的一位非数字，等价于“[^0-9]”；
· \w：表示任意的一位字母、数字、，等价于“[a-zA-Z0-9]”；
· \W：表示任意的一位非字母、数字、，等价于“[^a-zA-Z0-9]”；
· \s：表示任意的一位空格，例如：\n、\t等；
· \S：表示任意的一位非空格；
5、 数量表示：之前的所有正则都只是表示一位，如果要想表示多位，则就需要数量表示。
· 正则表达式?：此正则出现0次或1次；
· 正则表达式*：此正则出现0次、1次或多次；
· 正则表达式+：此正则出现1次或多次；
· 正则表达式{n}：此正则出现正好n次；
· 正则表达式{n,}：此正则出现n次以上；
· 正则表达式{n,m}：此正则出现n ~ m次。
6、 逻辑表示：与、或、非
· 正则表达式A正则表达式B：表达式A之后紧跟着表达式B；
· 正则表达式A|正则表达式B：表示表达式A或者是表达式B，二者任选一个出现；
· (正则表达式)：将多个子表达式合成一个表示，作为一组出现。
String类对正则的支持
在JDK 1.4之后，String类对正则有了直接的方法支持，只需要通过如下的几个方法就可以操作正则。
Pattern类之中存在的方法：
· 字符串全拆分：public String[] split(CharSequence input)；
· 字符串部分拆分：public String[] split(CharSequence input, int limit)；
Matterh类之中存在的方法：
· 字符串匹配：public boolean matches()；
· 字符串全替换：public String replaceAll(String replacement)；
· 字符串替换首个：public String replaceFirst(String replacement)。
正是因为String类支持的方法比较全面，所以在开发之中，主要的都是String类操作正则，因为方便。下面编写若干个操作实例来进行正则的验证。
范例：字符串拆分
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "a1bb2ccc3dddd4eeeee5fffffff6ggggggg7" ;
String regex = "[a-zA-Z]+" ;// 字母出现1次或多次
System.out.println(str.replaceAll(regex, ""));
System.out.println(str.replaceFirst(regex, ""));
}
}
范例：字符串拆分
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "a1bb2ccc3dddd4eeeee5fffffff6ggggggg7" ;
String regex = "\\d" ;// 数字出现1次，[0-9]
String result [] = str.split(regex) ;
for (int x = 0; x < result.length; x++) {
System.out.print(result[x] + "、");
}
}
}
有了正则，对于字符串日后的种种操作就会变的相当的方便。而正则在使用的过程之中最为重要的部分就是验证部分，因为一些字符串必须满足于指定的格式才可以操作。
范例：做一个简单的验证，要求字符串格式“aaaaab”，在b之前可以有无数多个a，但是不能没有，至少1个。
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "aaaaaab" ;
String regex = "a+b" ;
System.out.println(str.matches(regex));
}
}
范例：验证一个字符串是否是整型数据，如果是则将其变为int型数据，而后执行乘法操作
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "123" ;
String regex = "\\d+" ;
if (str.matches(regex)) { // 符合于验证要求
int data = Integer.parseInt(str) ; // 字符串变为int型数据
System.out.println(data * data);
} else {
System.out.println("字符串不是数字所组成！");
}
}
范例：验证字符串是否是小数，如果是则将其变为double型数据，而后执行乘法操作
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "123.1" ;
String regex = "\\d+(\\.\\d+)?" ;
if (str.matches(regex)) { // 符合于验证要求
double data = Double.parseDouble(str) ; // 字符串变为double型数据
System.out.println(data * data);
} else {
System.out.println("字符串不是数字所组成！");
}
}
}
范例：输入一个字符串，按照年-月-日 时-分-秒的形式，如果正确，则将其变为Date型数据
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "1998-09-18 10:10:10.100" ;
String regex = "\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}" ;
if (str.matches(regex)) { // 符合于验证要求
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")
.parse(str);
System.out.println(date);
} else {
System.out.println("字符串不是日期！");
}
}
}
范例：一个用户名只能由字母、数字、_所组成，其长度只能是6~15位
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "343234FDSF_";
String regex = "\\w{6,15}";
if (str.matches(regex)) { // 符合于验证要求
System.out.println("用户名合法。");
} else {
System.out.println("用户名非法！");
}
}
}
范例：现在编写一个正则表达式要求验证电话号码是否正确，例如：现在写上咱们电话号码，有如下几种写法：
· 写法一：51283346 \\d{7,8}；
· 写法二：01051283346 (\\d{3,4})?\\d{7,8}；
· 写法三：010-51283346 (\\d{3,4})?-?\\d{7,8}；
· 写法四：(010)-51283346 ((\\d{3,4}|\\(\\d{3,4}\\))-?)?\\d{7,8}；
· 写法五：(010)51283346 ((\\d{3,4}|\\(\\d{3,4}\\))-?)?\\d{7,8}。
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "51283346";
// 第一步：\\d{7,8}，因为电话号码可能是7~8位所组成；
// 第二步：(\\d{3,4})?\\d{7,8}，因为区号由3~4位所组成；
// 第三步：(\\d{3,4})?-?\\d{7,8}，因为-可能出现也可能不出现
// 第四步：((\\d{3,4}|\\(\\d{3,4}\\))-?)?\\d{7,8}
String regex = "((\\d{3,4}|\\(\\d{3,4}\\))-?)?\\d{7,8}";
if (str.matches(regex)) { // 符合于验证要求
System.out.println("TRUE，电话号码输入合法。");
} else {
System.out.println("FALSE，电话号码输入非法！");
}
}
}
范例：现在要求验证一个email地址，email地址的用户名由字母、数字、_、.所组成，其中不能以数字和.开头，而且email地址的域名只能是.com、.cn、.net
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "mldnqa@163.net";
String regex = “[a-zA-Z_][a-zA-Z_0-9\.]*@[a-zA-Z_0-9\.]+\.(com|cn|net)”;
if (str.matches(regex)) {// 符合于验证要求
System.out.println(“TRUE，EMAIL输入合法。”);
} else {
System.out.println(“FLASE，EMAIL输入非法！”);
}
}
}
范例：现在判断一个字符串的组成，其组成原则“姓名:年龄:成绩|姓名:年龄:成绩|姓名:年龄:成绩|…”
例如，现在有一个字符串内容如下：“SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2|”，其中姓名的组成只能是字母，年龄只能是数字，成绩可能是小数。
第一问：写出来验证的正则表达式
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2";
String regex = "([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?\\|)+([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?)?";
if (str.matches(regex)) { // 符合于验证要求
System.out.println("TRUE，输入合法。");
} else {
System.out.println("FLASE，输入非法！");
}
}
}
第二问：将所有的数据排序，按照成绩由高到低排序，如果成绩相同，则按照年龄由低到高排序
既然是排序操作，现在可以想到的方法就是：Arrays.sort()，但是现在这些数据可以将其变为对象数组排序，利用比较器完成。
import java.util.Arrays;
class Student implements Comparable<Student> {
private String name ;
private int age ;
private double score ;
public Student(String name,int age,double score) {
this.name = name ;
this.age = age ;
this.score = score ;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ "]\n";
}
@Override
public int compareTo(Student o) {
if (this.score > o.score) {
return -1 ;
} else if (this.score < o.score) {
return 1 ;
} else {
if (this.age > o.age) {
return 1 ;
} else if (this.age < o.age){
return -1 ;
} else {
return 0 ;
}
}
}
}
public class TestDemo {
public static void main(String[] args) throws Exception {
String str = "SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2";
String regex = "([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?\\|)+([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?)?";
if (str.matches(regex)) { // 符合于验证要求
String result [] = str.split("\\|") ; // 拆分
Student stu [] = new Student[result.length]; // 此时的数组大小就是对象数组大小
for (int x = 0; x < result.length; x++) {
String temp [] = result[x].split(":") ;
stu[x] = new Student(temp[0], Integer.parseInt(temp[1]),
Double.parseDouble(temp[2]));
}
Arrays.sort(stu) ;
System.out.println(Arrays.toString(stu));
} else {
System.out.println("FLASE，输入非法！");
}
}
}
因为在日后的所有项目的开发之中，只要是输入的数据都是利用字符串接收的，那么字符串又可以向各个数据类型转换，而要转换之前为了保证转换成功一定需要进行验证，验证最方便的就是正则表达式。
投递上海莱迪思半导体等公司10个岗位 >