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，输入非法！");
		}
	}
}
因为在日后的所有项目的开发之中，只要是输入的数据都是利用字符串接收的，那么字符串又可以向各个数据类型转换，而要转换之前为了保证转换成功一定需要进行验证，验证最方便的就是正则表达式。