【JAVA基础】正则表达式

最新推荐文章于 2022-11-10 15:05:56 发布
最新推荐文章于 2022-11-10 15:05:56 发布
阅读量91 收藏
点赞数
文章标签： java 爬虫
原文链接：https://yq.aliyun.com/articles/18734
版权

正则表达式就是我们程序员为了在海量数据中搜索到符合我们规定的格式的数据所采用的一种规范，官方一点就是说正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。


下面我们介绍一下正则表达式的规则，而且会给出一个详尽的实例来让你完全理解正则表达式的应用。

1.正则表达式的构造摘要 

正则表达式的构造摘要 
构造 匹配 
  
字符 
x 字符 x 
\\ 反斜线字符 
\0n 带有八进制值 0 的字符 n (0 <= n <= 7) 
\0nn 带有八进制值 0 的字符 nn (0 <= n <= 7) 
\0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7） 
\xhh 带有十六进制值 0x 的字符 hh 
\uhhhh 带有十六进制值 0x 的字符 hhhh 
\t 制表符 ('\u0009') 
\n 新行（换行）符 ('\u000A') 
\r 回车符 ('\u000D') 
\f 换页符 ('\u000C') 
\a 报警 (bell) 符 ('\u0007') 
\e 转义符 ('\u001B') 
\cx 对应于 x 的控制符 
  
字符类 
[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] 
  
POSIX 字符类（仅 US-ASCII） 
\p{Lower} 小写字母字符：[a-z] 
\p{Upper} 大写字母字符：[A-Z] 
\p{ASCII} 所有 ASCII：[\x00-\x7F] 
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}] 
\p{Digit} 十进制数字：[0-9] 
\p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}] 
\p{Punct} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 
\p{Graph} 可见字符：[\p{Alnum}\p{Punct}] 
\p{Print} 可打印字符：[\p{Graph}\x20] 
\p{Blank} 空格或制表符：[ \t] 
\p{Cntrl} 控制字符：[\x00-\x1F\x7F] 
\p{XDigit} 十六进制数字：[0-9a-fA-F] 
\p{Space} 空白字符：[ \t\n\x0B\f\r] 
  
java.lang.Character 类（简单的 java 字符类型） 
\p{javaLowerCase} 等效于 java.lang.Character.isLowerCase() 
\p{javaUpperCase} 等效于 java.lang.Character.isUpperCase() 
\p{javaWhitespace} 等效于 java.lang.Character.isWhitespace() 
\p{javaMirrored} 等效于 java.lang.Character.isMirrored() 
  
Unicode 块和类别的类 
\p{InGreek} Greek 块（简单块）中的字符 
\p{Lu} 大写字母（简单类别） 
\p{Sc} 货币符号 
\P{InGreek} 所有字符，Greek 块中的除外（否定） 
[\p{L}&&[^\p{Lu}]]  所有字母，大写字母除外（减去） 
  
边界匹配器 
^ 行的开头 
$ 行的结尾 
\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 次 
  
Reluctant 数量词 
X?? X，一次或一次也没有 
X*? X，零次或多次 
X+? X，一次或多次 
X{n}? X，恰好 n 次 
X{n,}? X，至少 n 次 
X{n,m}? X，至少 n 次，但是不超过 m 次 
  
Possessive 数量词 
X?+ X，一次或一次也没有 
X*+ X，零次或多次 
X++ X，一次或多次 
X{n}+ X，恰好 n 次 
X{n,}+ X，至少 n 次 
X{n,m}+ X，至少 n 次，但是不超过 m 次 
  
Logical 运算符 
XY X 后跟 Y 
X|Y X 或 Y 
(X) X，作为捕获组 
  
Back 引用 
\n 任何匹配的 nth 捕获组 
  
引用 
\ Nothing，但是引用以下字符 
\Q Nothing，但是引用所有字符，直到 \E 
\E Nothing，但是结束从 \Q 开始的引用 
  
特殊构造（非捕获） 
(?:X) X，作为非捕获组 
(?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on - off 
(?idmsux-idmsux:X)   X，作为带有给定标志 i d m s u x on - off 
的非捕获组  (?=X) X，通过零宽度的正 lookahead 
(?!X) X，通过零宽度的负 lookahead 
(?<=X) X，通过零宽度的正 lookbehind 
(?<!X) X，通过零宽度的负 lookbehind 
(?>X) X，作为独立的非捕获组 


2.正则表达式应用大实例

正则表达式:RegularExpressions（字符串处理利器）

都在java.util.regex.*;包中

样例：

package cn.edu.RegularExpressions;


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


class Test {
	public static void main(String[] args) {
		//简单理解正则表达式
		System.out.println("abc".matches("..."));
		//其中“\d”代表一个数字(0-9)
		System.out.println("a324234a".replaceAll("\\d", "-"));
		Pattern p=Pattern.compile("[a-z]{3}");
		Matcher m=p.matcher("fgh");
		System.out.println(m.matches());
		System.out.println("fgha".matches("[a-z]{3}"));
		/*结果
		 * true
           a------a
		   true
		   false
		 * */
		
		//初步认识. * +
		p("1:"+"a".matches("."));//
		p("2:"+"aa".matches("aa"));//true，正则表达式可以写正常的字符
		p("3:"+"aaaa".matches("a*"));//“*”代表的是0个或者多个
		p("4:"+"aaaa".matches("a+"));//“+”代表的是1个或者多个
		p("5:"+"".matches("a*"));
		p("6:"+"aaaa".matches("a?"));//“？”代表的是0个或1个
		p("7:"+"".matches("a?"));
		p("8:"+"a".matches("a?"));
		p("9:"+"2342342432423234".matches("\\d{3,100}"));//“{”与“}”代表出现的次数(几次，至少几次，最多几次最少几次)
		//最简单的检测IP地址的方式：
		p("10:"+"192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
		p("11:"+"192".matches("[0-2][0-9][0-9]"));//“[]”代表一个范围
		/*结果：
		1:true
		2:true
		3:true
		4:true
		5:true
		6:false
		7:true
		8:true
		9:true
		10:false
		11:true*/
		
		p("a".matches("[abc]"));
		p("a".matches("[^abc]"));
		p("A".matches("[a-zA-Z]"));
		p("A".matches("[a-z] | [A-Z]"));
		p("A".matches("[a-z[A-Z]]"));
		p("R".matches("[A-Z&&[RFG]]"));
		/*true
		false
		true
		false
		true
		true*/


		/*
		 * "."代表任何字符
		 * "/d"[0-9]的数字
		 * "/D"非[0-9]的数字[^\d]
		 *"/s"空白字符（包括空格，Tab键\t，换行\n，backspace后退键/x0B，制表符/f，回车/r）
		 * "/S"非“空白字符”[^\s]
		 * "/w"单词字符[a-zA-Z_0-9]
		 * "/W""非“单词字符”[^\w]
		 */
		p(" \n\r\t".matches("\\s{4}"));
		p(" ".matches("\\S"));
		p("a_8".matches("\\w{3}"));
		p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));
		p("\\".matches("\\\\"));//在matches中，一个"\"要用"\\"来表示
	/*	true
		false
		true
		true
		true*/
		
		//POSIX Style
		p("a".matches("\\p{Lower}"));
		/*true*/
		
		//边界匹配
		//"^"位于中括号里面的时候是取反的意思，位于外面代表的是输入的开头
		p("hello sir".matches("^h.*"));//以"h"开头
		p("hello sir".matches(".*ir$"));//以"ir"结尾
		p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));//\b一个单词的边界（空格，空白字符，换行，特殊字符）
		p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
		/*true
			true 
			false*/
		
		//把空白行找出来
		p(" \n".matches("^[\\s&&[^\\n]]*\\n"));//以空白字符开头，并且不是换行符，出现0次或多次
		/*true*/
		
		//匹配email地址的正则表达式(有得email地址是含有横线和点号的)
		p("basdbjasbkja@dasbdn.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));
		
		//matches find lookingAt
		Pattern p1=Pattern.compile("\\d{3,5}");//编译正则表达式
		String s="123-34345-234-00";
		Matcher m1=p1.matcher(s);
		p(m1.matches());
		//false
		//find()一段一段的匹配
		//分析到“-”时，不符合p1的标准，认为结束
		m1.reset();//matches与find一起使用时需要reset
		p(m1.find());
		p(m1.start()+"-"+m1.end());//输出“-”的起始位置和结束位置(结束位置就是本身位置)
		p(m1.find());
		p(m1.start()+"-"+m1.end());
		p(m1.find());
		p(m1.start()+"-"+m1.end());
		p(m1.find());
//		true
//		true
//		true
//		false
		
		p(m1.lookingAt());
		//true
		
		//区别matches找整个串 
		//find找字串
		//lookingAt每次都从头上开始找
		
		//字符串的替换
		Pattern p2=Pattern.compile("java",Pattern.CASE_INSENSITIVE);//CASE_INSENSITIVE忽略大小写
		Matcher m2=p2.matcher("java Java JAVa JaVa IloveJAVA you hateJava lalalala");
		while(m2.find()){
			p(m2.group());//按组找
		}
		p(m2.replaceAll("JAVA"));
		//全部改为JAVA JAVA JAVA JAVA IloveJAVA you hateJAVA
		
		m2.reset();
		StringBuffer buf=new StringBuffer();
		int i=0;
		while(m2.find()){
			i++;
			if(i%2==0){//奇数大写偶数小写
				m2.appendReplacement(buf, "java");
			}else{
				m2.appendReplacement(buf, "JAVA");
			}
		}
		m2.appendTail(buf);//将尾巴加进去
		p(buf);
		//JAVA java JAVA java IloveJAVA you hatejava lalalala
		
		//分组：使用小括号组成的，分了机组就有几对小括号
		//每个组有自己的组号
		Pattern p3=Pattern.compile("(\\d{3,5})([a-z]{2})");
		String s1="123aa-12323bb-456cc-00";
		Matcher m3=p3.matcher(s1);
		while(m3.find()){
			p(m3.group());//按组找
			p(m3.group(1));
			p(m3.group(2));
		}
		/*123aa
		123
		aa
		12323bb
		12323
		bb
		456cc
		456
		cc*/
		


	}
	
	public static void p(Object o){
		System.out.println(o);
	}


}


3.实例：利用正则表达式写简单的邮件爬虫

把qiu_email.htm这个网页文件中的所有信息中属于邮箱地址的信息搜索出来

package cn.edu.RegularExpressions;


import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class EmailSpider {
		public static void main(String[] args) {
			try {
     BufferedReader br=new BufferedReader(new FileReader("F:\\Talk\\qiu_email.htm"));
				String line="";
				while((line=br.readLine())!=null){
					parse(line);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}




		private static void parse(String line) {
                        //email的正则表达式
			Pattern p=Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
			Matcher m=p.matcher(line);
			while(m.find()){
				System.out.println(m.group());
			}
			
		}
}

转载请注明出处：http://blog.csdn.net/acmman/article/details/45078731

weixin_33860722
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解linux正则表达式（基础正则表达式+扩展正则表达式）
12-13
正则表达式应用非常广泛，例如：php，Python，java等，但在linux中最常用的正则表达式的命令就是grep(egrep)，sed,awk等，换句话 说linux三剑客要想能工作的更高效，就一定离不开正则表达式的配合。 1、什么是正则...
正则表达式-匹配横杠-本身
LiGuogang
02-27 5377
package com.liguogang.utils; import java.util.regex.Pattern; public class RegexUtil { public static void main(String[] args) { String regex = "[0-9]"; match(1, "匹配数字1", regex, "1"); match(2, "匹配-字符本身", regex, "-"); re
java 正则匹配 短横线,【已解决】js中正则无法匹配短横线
weixin_34276402的博客
03-13 1850
折腾：期间，虽然解决了问号问题，但是却还是无法用：let accessTokenRegex = new RegExp("\\?accessToken=([\w\-]+)", "g");去匹配：/uapp/?accessToken=75872da5-56b8-4fd3-96be-7ad69d56a6e4中的短横线且调试时，正则打印出来的竟然没了短横线：accessTokenRegex=/\?acce...
正则表达式
liujiujiang的博客
03-14 1893
正则表达式： 正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。 字符类 [abc] a、b 或 c（简单类） [^abc] 任何字符，除了 a、b 或 c（否定） [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围...
c#（正则表达式）
诡白丷的博客
09-27 441
c# 正则表达式 使用方法 位于System.Text.RegularExpressions下的Regex类下的一些方法 bool IsMatch(string input, string pattern); 判断input串是否符合正则表达式pattern Match Match(string input,string pattern); 从字符串input中找出第一个符合正则表达式pattern的串 MatchCollection Matches(string input,string pattern
JAVA时间字符串去空格、冒号和横杠
qq_15855917的博客
09-24 1330
String date = "2017-09-19 14:40:01"; String response = date.replaceAll("[[\\s-:punct:]]","");
Java正则表达式基础入门知识
01-19
大家都知道，正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它 用以描述在查找文字主体时待匹配的一个或多个字符串。正则...
java正则表达式简单应用
09-03
主要介绍了java正则表达式简单应用，在之前几篇文章中已经深入学习了java正则表达式基础知识，本文对java正则表达式应用进行研究，感兴趣的小伙伴们可以参考一下
Java 正则表达式
01-03
Java 正则表达式 正则表达式定义了字符串的模式。 正则表达式可以用来搜索、编辑或处理文本。 正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。 正则表达式实例 一个字符串其实就是一个简单的正则...
Java 正则表达式 短横线"-"转义
和光同尘的博客
01-12 8322
过滤特殊字符的正则如下： /** * 过滤特殊字符串正则（含中英文字符） */ public static final String STR_SPECIAL = "[`~!@#$%^&amp;*()_+=|{}':;'\",\\[\\].&lt;&gt;/?·~！@#￥%……&amp;*（）——+|{}《》【】‘；：”“’。，、？]"; 可以发现上面的字符中...
正则表达式短横线＂-＂的转义写法示例
程序狗的成长之路
11-11 1万+
一直以为正则方括号内的短横线是要转义的，例： [a-z\-] 其实“-”在紧挨边界的时候不需要转义，也就是说可以写成： [a-z-] 或 [-a-z] 经过自己验证，我们暂且称“a-z”为“组”，结论是“在方括号边界或是组边界的都不需要转义。” [a-z-0-9] 再试一试发现这样也可以，这样结论又变成“只要短横线（-）不能构成组，就可以不专一”，不知道这样说是否严密。 [a-z!-
正则表达式匹配数字或者短横杠至多三次，数字可以不填写，学习正则表达式
IT小黑
06-22 8709
先上正则表达式：^[+-]?[-]?([0-9]*\.?[0-9]*|[0-9]?\.?[0-9]*)?$ 这个表达式主要用来验证数字，如果不想填写数字的情况下可以使用---来进行代替 在实际的生产环境中，往往可能会有这种需求，现在进行验证，往往要在前台和后台均做验证， 那么前台的验证框架最经典也是最有效的，则为正则表达式 学习正则表达式可能刚开始看没有任何的感觉，或
使用正则表达式去掉时间中的-和：
刘不怂的博客
08-29 1519
使用string的replaceAll方法 time = time.replaceAll("[[\\s-:punct:]]", ""); \ 标记向后引用 \s 空格 -- 横杠 :punct: 任何标点符号
删除/清除/过滤标点（所有中英文标点）的正则表达式——Desktop Search开发笔记【经验积累】
热门推荐
Harry Huang
09-22 2万+
在进行文本分析的时候我们经常需要过滤掉停用词，标点等，本文给大家介绍一下如何识别并删除文本中的所有标点符号。下面是三个可行的正则表达式方案，童鞋们来试试吧^_^ (1) s.replaceAll( "\\p{Punct}", "" ); (2) s.replaceAll("\\pP" , ""); (3) s.replaceAll("\\p{P}" , ""); (1)不能完全清楚所有标点，(2)和(3)等价都能完全清楚标点（中文和英文都能清除） 需要注意的是，还是存在一些系统
java 中的空格符、换行符等怎么表示
xiansibao的博客
11-10 1万+
8、\S 非空白符号 [^\t\n\x0B\f\r]10、\W 非单独字符 [^a-zA-Z_0-9]7、\s 空白符号 [\t\n\x0B\f\r]9、\w 单独字符 [a-zA-Z_0-9]1、\t 空格 ('\u0009')2、\n 换行 ('\u000A')4、\r 回车 ('\u000D')6、\D 非数字等价于[^0-9]5、\d 数字等价于[0-9]
Java正则表达式中各种字符以及转义字符的解释说明
iteye_1653的博客
04-11 325
1.字符 x    字符 x。例如a表示字符a \\    反斜线字符。在书写时要写为\\\\。（注意：因为java在第一次解析时,把\\\\解析成正则表达式\\，在第二次解析时再解析为\，所以凡是不是1.1列举到的转义字符，包括1.1的\\,而又带有\的都要写两次） \0n    带有八进制值 0的字符 n (0 &lt;= n &lt;= 7) \0nn    带有八进制值 0的字符 n...
黑马程序员__正则表达式总结
tempsitegoogle
06-22 194
---------------------- android培训、java培训、期待与您交流！ ---------------------- 正则表达式：符合一定规则的表达式 作用：专门用于操作字符串 用一些特定的符号来表示一些代码操作，这样就简化书写，所以学习正则表达式就是在学习一些特殊符号的使用。 好处：可以简化对字符串的复杂操作 弊端:符号定义越多，正则越长，阅读性越差 具体...
Java正则表达式
MatthewChen Piscesky
04-16 198
　　在Sun的Java JDK 1.40版本中，Java自带了支持正则表达式的包，本文就抛砖引玉地介绍了如何使用java.util.regex包。 　　可粗略估计一下，除了偶尔用Linux的外，其他Linu x用户都会遇到正则表达式。正则表达式是个极端强大工具，而且在字符串模式-匹配和字符串模式-替换方面富有弹性。在Unix世界里，正则表达式几乎没有什么限制，可肯定的是，它应用非常之广泛。 　　正...
【韩顺平讲java】java 正则表达式专题 课件
最新发布
07-31
讲解正则表达式的课件从基础开始，梳理了正则表达式的语法规则和常用的模式匹配符号，然后通过实例演示了如何使用正则表达式进行字符串的匹配、替换和提取等操作。 课件首先介绍了正则表达式的基本概念和使用场景，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值