3、正则表达式

一、正则表达式

 

1. 正则表达式：符合一定规则的表达式
2. 作用：用于专门操作字符串
3. 特点：用于一些特定的符号来表示一些代码操作。这样就简化书写
4. 好处：可以简化对字符串的复杂操作
5. 弊端：符号定义越多，正则越长，阅读性越差

二、具体操作：匹配

 

    String 的 matches 方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false

 

字符类 预定义字符类

[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]

 

边界匹配器 Greedy 数量词

^	行的开头
$	行的结尾
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾
\Z	输入的结尾，仅用于最后的结束符（如果有的话）
\z	输入的结尾
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次

 

/**
 *需求：验证手机号码
 */
public class RegexDemo
{
	public static void main(String[] args)
	{
		String tel = "13568556963";
		checkTel(tel);
	}
	private static void checkTel(String tel)
	{
		String regex = "1[358]\\d{9}";
		System.out.println(tel.matches(regex));
	}
}

 

三、切割

 

• String的split方法
• 组和捕获 
• 捕获组可以通过从左到右计算其开括号来编号。
• 例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 
•           1     ((A)(B(C))) 
•           2     \A 
•           3     (B(C)) 
•           4     (C) 
• 组零始终代表整个表达式。
• 之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。
• 捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。

public class RegexTest {
	public static void main(String[] args)
	{
		String res1 = "ni hao  ma wo   hen  hao";
		split1(res1);
		
		String res2 = "zhangsan.lisi.wangwu";
		split2(res2);
		
		String res3 = "c:\\java\\code\\a.txt";
		split3(res3);
		
		String res4 = "zhangsanqqlisimmmwangwu....zhaoliu";
		split4(res4);
	}
	//按多个空格切
	private static void split1(String res)
	{
		String reg = " +";
		String[] arr = res.split(reg);
		
		print(arr);
	}
	//按点来切
	private static void split2(String res)
	{
		String reg = "\\.";
		String[] arr = res.split(reg);
		
		print(arr);
	}
	//按双斜线 \\ 来切
	private static void split3(String res)
	{
		String reg = "\\\\";
		String[] arr = res.split(reg);
		
		print(arr);
	}
	//按照叠词来切，要用到组
	private static void split4(String res)
	{
		String reg = "(.)\\1+";
		String[] arr = res.split(reg);
		
		print(arr);
	}
	//打印字符串
	private static void print(String[] arr) {
		System.out.print("<");
		for(int x=0;x<arr.length-1;x++)
		{
			System.out.print(arr[x]+",");
		}
		System.out.println(arr[arr.length-1]+">");
	}
}

 

四、替换

 

    String的replaceAll(String regex,String replacement)方法

 

public class RegexTest {
	public static void main(String[] args)
	{
		String res1 = "zhangsan42lisi16357464wangwu1351";
		replaceAll1(res1);
		
		String res2 = "zhangsanqqqisi1bbbbbwangwu<<<<<<";
		replaceAll2(res2);
	}
	//将字符串中5个以上的数字替换成#
	private static void replaceAll1(String res) {
		String reg = "\\d{5,}";
		String dest = res.replaceAll(reg, "#");
		System.out.println(dest);
	}
	
	//将多个相同的字符替换成一个字符
	private static void replaceAll2(String res) {
		String reg = "(.)\\1+";
		String dest = res.replaceAll(reg, "$1");
		System.out.println(dest);
	}
}

 

五、获取

 

1. 将字符串中的符合规则的子串取出
2. 操作步骤：
3. 将正则表达式封装成对象
4. 让正则对象和要操作的字符串相关联
5. 关联后，获取正则匹配引擎
6. 通过引擎对符合规则的子串进行操作，比如取出

• 软件包 java.util.regex 
• 用于匹配字符序列与正则表达式指定模式的类。
• 只有一个接口一个异常和  两个类：Matcher类和Pattern类

/**
 *Pattern
 *正则表达式的编译表示形式。
 *指定为字符串的正则表达式必须首先被编译为此类的实例。
 *然后，可将得到的模式用于创建 Matcher 对象，
 *依照正则表达式，该对象可以与任意字符序列匹配。
 *执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式
 */
public final class Pattern implements Serializable
{
	//没有构造方法

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

	//将给定的正则表达式编译到具有给定标志的模式中
	public static Pattern compile(String regex,
                              int flags){}

	//返回此模式的匹配标志
	public int flags(){}

	//创建匹配给定输入与此模式的匹配器
	public Matcher matcher(CharSequence input){}

	//返回在其中编译过此模式的正则表达式和toString方法一样
	public String pattern(){}

	//编译给定正则表达式并尝试将给定输入与其匹配
	public static boolean matches(String regex,
                              CharSequence input){}

	//围绕此模式的匹配拆分给定输入序列
	public String[] split(CharSequence input){}
}

 

/**
 *Matcher
 *通过解释 Pattern 对 character sequence 执行匹配操作的引擎。 
 *通过调用模式的 matcher 方法从模式创建匹配器。
 *创建匹配器后，可以使用它执行三种不同的匹配操作： 
 *matches 方法尝试将整个输入序列与该模式匹配。 
 *lookingAt 尝试将输入序列从头开始与该模式匹配。 
 *find 方法扫描输入序列以查找与该模式匹配的下一个子序列。 
 *每个方法都返回一个表示成功或失败的布尔值。通过查询匹配器的状态可以获取关于成功匹配的更多信息
 */
public final class Matcher implements MatchResult
{
	//没有构造方法

	//返回最后匹配字符之后的偏移量
	public int end(){}

	/**
	 *尝试查找与该模式匹配的输入序列的下一个子序列。 
	 *此方法从匹配器区域的开头开始，
	 *如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始。 
	 *如果匹配成功，则可以通过 start、end 和 group 方法获取更多信息。
	 */
	public boolean find(){}

	//重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列
	public boolean find(int start){}

	//返回由以前匹配操作所匹配的输入子序列。 
	//对于具有输入序列 s 的匹配器 m，表达式 m.group() 和 s.substring(m.start(), m.end()) 是等效的
	public String group(){}

	//尝试将整个区域与模式匹配。
	public boolean matches(){}

	//返回以前匹配的初始索引
	public int start(){}

	//替换模式与给定替换字符串相匹配的输入序列的每个子序列。 
	public String replaceAll(String replacement){}

	//替换模式与给定替换字符串匹配的输入序列的第一个子序列
	public String replaceFirst(String replacement){}
}

 

六、示例

 

import java.util.regex.*;
class RegexDemo 
{
	public static void main(String[] args) 
	{
		getDemo();
	}
	private static void getDemo()
	{
		String str = "ming tian  jiu yao fang jia le haha ";
		String regex = "[a-z]{3}";

		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(str);

		while(m.find())
		{
			System.out.println(m.group()+" *****");
		}
	}
}
//打印结果为：min tia jiu yao fan jia hah不是我们想要的结果

 

import java.util.regex.*;
class RegexDemo 
{
	public static void main(String[] args) 
	{
		getDemo();
	}
	private static void getDemo()
	{
		String str = "ming tian  jiu yao fang jia le haha ";
		String regex = "\\b[a-z]{3}\\b";//加上单词边界

		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(str);

		while(m.find())
		{
			System.out.println(m.group()+" *****");
		}
	}
}
//打印结果为：jiu yao jia 

import java.util.regex.*;
/**
 *需求：将下列字符串转换成“我要学编程”
 *String str = "我我...我我....我要....要要...要要..学学学....学学...编编编..编编....编程..程.程程...程...程";
 */
class RegexDemo 
{
	public static void main(String[] args) 
	{
		String str = "我我...我我....我要....要要...要要..学学学....学学...编编编..编编....编程..程.程程...程...程";
		str = str.replace(".","");
		str = str.replaceAll("(.)\\1+","$1");
		System.out.println(str);
	}
}

 

import java.util.*;
/**
 *需求：将ip地址进行地址段顺序的排序
 *192.68.1.254 102.49.23.13 10.10.10.10 2.2.2.2 8.109.90.30
 *
 */
class RegexDemo 
{
	public static void main(String[] args) 
	{
		String ip = "192.68.1.254  102.49.23.13 10.10.10.10 2.2.2.4 2.2.2.3 8.109.90.30";

		ip = ip.replaceAll("(\\d+)","00$1");
		ip = ip.replaceAll("0*(\\d{3})","$1");

		String[] arr = ip.split(" +");
		Arrays.sort(arr);
		for(String s : arr)
			System.out.println(s.replaceAll("0*(\\d+)","$1"));
	}
}

 

import java.util.*;
/**
 *需求：对邮件地址进行校验
 */
class RegexDemo 
{
	public static void main(String[] args) 
	{
		String email = "[e-mail]";

		//较为精确的匹配
		String regex1 = "[a-zA-Z0-9_]+@[a-z0-9A-Z]+(\\.\\[a-zA-Z]+)+";

		//相对不太精确的匹配
		String regex2 = "\\w+@\\w+(\\.\\w+)+";

		System.out.println(email.matches(regex2));
	}
}

 

import java.util.*;
import java.io.*;
import java.net.*;
import java.util.regex.*;
/**
 *	网页爬虫，采集网页中的jpg格式的图片
 */
class RegexDemo 
{
	public static void main(String[] args) throws Exception
	{
		getJpg();
	}
	private static void getJpg ()throws Exception
	{
		String name = "http://tieba.baidu.com/p/1806328838";
		URL url = new URL(name);
		URLConnection con = url.openConnection();

		BufferedReader br = 
			new BufferedReader(new InputStreamReader(con.getInputStream(),"utf-8"));
		PrintWriter pw = new PrintWriter(new FileWriter("e:/a.html"),true);

		String line = null;
		String regex = "<img .*http.+\\.jpg.+>";
		Pattern p = Pattern.compile(regex);
		Matcher m;
		while((line=br.readLine())!=null)
		{
			m = p.matcher(line);
			while(m.find())
			{
				pw.println(m.group());
			}
		}
		System.out.println("采集成功");
		pw.close();
		br.close();
	}
}