java中的正则表达式

在java JDK 1.4版本中，java.util.regex包正式支持了正则表达式

在regex包中，包含了两个类，Pattern（模式类）和Matcher（匹配器类）

Pattern类中常用的构造-匹配

在预定义字符中，需要有“\”，反斜线字符，

反斜线、转义和引用

反斜线字符 ('\') 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式 \\ 与单个反斜线匹配，而 \{ 与左括号匹配。

在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。

根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 "\b" 与单个退格字符匹配，而 "\\b" 与单词边界匹配。字符串字面值 "\(hello\)" 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 "\\(hello\\)"。

Pattern中常用方法：

（1）Pattern.compile(String regex)

静态方法，将给定的正则表达式编译到模式中

（2）matcher(CharSequencr input) 

方法返回一个Matcher对象，创建匹配给定输入与此模式的匹配器

示例一：在字符串中找到形如min(a,b)的子串

//通过给出的字符串得到一个匹配器
String s ="add(min(1,2),20)";
		
String rule="[a-zA-z]+\\(\\d+(,\\d+)?\\)";
		
Matcher match=Pattern.compile(rule).matcher(s);

//在字符串中寻找满足正则表达式的子串
while(match.find()){
				
<span style="white-space:pre">	</span>String str=match.group();
									
}

实例二：确定字符串是否全为数字

String s = "12342";
				
String rule="[0-9]+";
				
Matcher match=Pattern.compile(rule).matcher(s);

if(match.matches()){			
	System.out.println(match.group());								
}

分析一下第一个示例中的正则表达式

String rule="[a-zA-z]+\\(\\d+(,\\d+)?\\)";

第一个字符是大写或者小写字母，所以为“[a-zA-z]”，因为可以有多个不限制个数，所以后跟“+”

"\\("代表"("，可以有多个数字，"\\d"代表数字，"+"代表多个

注意这里的数字只有0-9，所以多个数字也就是一个多位数

参数的个数是可以为一个，也可以为两个，"()?"代表括号中的内容出现一次或者0次

两个参数之间有逗号相隔，直接写","，后面同上为"\\d+"

最后括号"\\)"即为")"

应用示例一：

判断给定字符串是什么，电话，email，中文名字，QQ？

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Validate {
	public static boolean isMobile(String info) {
		return getRules("1[358][0-9]{9}", info);
	}

	public static boolean isQQ(String info) {
		return getRules("[1-9][0-9]{5,9}", info);
	}

	public static boolean isChineseName(String info) {
		return getRules("[\u4e00-\u9fa5]{2,5}", info);
	}

	public static boolean isEmail(String info) {
		// +代表可以不限制次数，如第一个字符可以是大小写字母或数字，可以有无数个
		return getRules("[a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.[a-zA-Z0-9]+)+", info);
	}

	private static boolean getRules(String rule, String info) {
		boolean flag = false;
		Matcher match = Pattern.compile(rule).matcher(info);

		if (match.matches()) {
			flag = true;
		}
		return flag;
	}
}

应用实例二：

从键盘输入形如：add(5，max（10,sub（5,2））)的字符串，计算结果

public class Computer {

	public static int express(String info) {
		int first = info.indexOf("(");
		int result = 0;
		String cal = info.substring(0, first);

		if (!cal.equals("doubleMe")) {
			
			int second = info.indexOf(",");
			int last = info.indexOf(")");
			String num1 = info.substring(first + 1, second);
			String num2 = info.substring(second + 1, last);
			int firstNum = Integer.parseInt(num1);
			int secondNum = Integer.parseInt(num2);

			if (cal.equals("sub")) {
				result = Computer.sub(firstNum, secondNum);
			} else if (cal.equals("add")) {
				result = Computer.add(firstNum, secondNum);
			} else if (cal.equals("max")) {
				result = Computer.max(firstNum, secondNum);
			} else if (cal.equals("min")) {
				result = Computer.min(firstNum, secondNum);
			} else if (cal.equals("mult")) {
				result = Computer.mult(firstNum, secondNum);
			} else if (cal.equals("div")) {
				result = Computer.div(firstNum, secondNum);
			}else{
				System.out.println("Wrong!");
			}
		} else {
			
			int last = info.indexOf(")");
			String num = info.substring(first + 1, last);
			int number = Integer.parseInt(num);
			result = doubleMe(number);
		}
		return result;
	}

	public static int add(int num1, int num2) {
		return num1 + num2;
	}

	public static int sub(int num1, int num2) {
		return max(num1, num2) - min(num1, num2);
	}

	public static int mult(int num1, int num2) {
		return num1 * num2;
	}

	public static int div(int num1, int num2) {
		return num1 / num2;
	}

	public static int max(int num1, int num2) {
		return num1 > num2 ? num1 : num2;
	}

	public static int min(int num1, int num2) {
		return num1 < num2 ? num1 : num2;
	}

	public static int doubleMe(int num1) {
		return num1 * num1;
	}
}

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ComputerDriver {
	public static void main(String[] args) {
		
		Scanner console = new Scanner(System.in);
		System.out.println("请输入运算表达式，如add(12,20):");
		String s = console.nextLine();
		//String s="sub(min(23,12),sub(max(54,3),doubleMe(max(8,4))))";
		//?可以出现0 或1次
		String rule="[a-zA-z]+\\(\\d+(,\\d+)?\\)";
		System.out.println(s);
		while(true){
			Matcher match=Pattern.compile(rule).matcher(s);
			
			while(match.find()){
				
				String str=match.group();
				System.out.println(str);
				int result=Computer.express(str);
				System.out.println("result="+result);
				str=str.replaceAll("\\(", "\\\\(");
				str=str.replaceAll("\\)", "\\\\)");
				
				s=s.replaceAll(str, String.valueOf(result));
				System.out.println(s);
			}
		}
	}
}

str=str.replaceAll("\\(", "\\\\(");
str=str.replaceAll("\\)", "\\\\)");

在正则表达式中， 要与字符串  (...)  匹配，必须使用字符串字面值  "\\(...\\)" 。

System.out.println("\\(");      输出结果为"\("
System.out.println("\\\\(");    输出结果为"\\("

有人可以不理解为什么要用"\\("而不用"\("，好吧其实是我不理解，但后者会报错

所以我猜测应该是字符串在解析时，只可识别"\("，并将其识别为"("，而不可直接识别"("