3、正则表达式

最新推荐文章于 2024-07-16 22:31:12 发布

S_壮

最新推荐文章于 2024-07-16 22:31:12 发布

阅读量110

点赞数

分类专栏：六、重要知识点文章标签：正则表达式 pattern matcher 网页爬虫

六、重要知识点专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、正则表达式

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

二、具体操作：匹配

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]`

边界匹配器
`^`	行的开头
`$`	行的结尾
`\b`	单词边界
`\B`	非单词边界
`\A`	输入的开头
`\G`	上一个匹配的结尾
`\Z`	输入的结尾，仅用于最后的结束符（如果有的话）
`\z`	输入的结尾

Greedy 数量词
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);
	}
}

五、获取

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

软件包 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 = "1354@qq.com";

		//较为精确的匹配
		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();
	}
}

S_壮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3、正则表达式

一、正则表达式正则表达式：符合一定规则的表达式作用：用于专门操作字符串特点：用于一些特定的符号来表示一些代码操作。这样就简化书写好处：可以简化对字符串的复杂操作弊端：符号定义越多，正则越长，阅读性越差二、具体操作：匹配 String 的 matches 方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false 字符...
复制链接

扫一扫