码迷，mamicode.com
首页 > 编程语言 > 详细

Java正则表达式

时间：2015-07-10 15:26:10      阅读：456      评论：0      收藏：0      [点我收藏+]

标签：java   正则表达式   

正在学习Java正则表达式，我哥人感觉有难度，反正书看完了就全忘记了，还是要做一下笔记。还是从最基础开始吧。

下面是从网上找来的资料，贡以后看的，当然，直接复制粘贴的。

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

众所周知，在程序开发中，难免会遇到需要匹配、查找、替换、判断字符串的情况发生，而这些情况有时又比较复杂，如果用纯编码方式解决，往往会浪费程序员的时间及精力。因此，学习及使用正则表达式，便成了解决这一矛盾的主要手段。
大家都知道，正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
自从jdk1.4推出java.util.regex包，就为我们提供了很好的JAVA正则表达式应用平台。

因为正则表达式是一个很庞杂的体系，所以我仅例举些入门的概念，更多的请参阅相关书籍及自行摸索。 

// 反斜杠
/t 间隔 (‘/u0009‘)
/n 换行 (‘/u000A‘)
/r 回车 (‘/u000D‘)
/d 数字 等价于[0-9]
/D 非数字 等价于[^0-9]
/s 空白符号 [/t/n/x0B/f/r]
/S 非空白符号 [^/t/n/x0B/f/r]
/w 单独字符 [a-zA-Z_0-9]
/W 非单独字符 [^a-zA-Z_0-9]
/f 换页符
/e Escape
/b 一个单词的边界
/B 一个非单词的边界
/G 前一个匹配的结束

^为限制开头
^java 条件限制为以Java为开头字符
$为限制结尾
java$ 条件限制为以java为结尾字符
. 条件限制除/n以外任意一个单独字符
java.. 条件限制为java后除换行外任意两个字符


加入特定限制条件「[]」
[a-z] 条件限制在小写a to z范围中一个字符
[A-Z] 条件限制在大写A to Z范围中一个字符
[a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
[0-9] 条件限制在小写0 to 9范围中一个字符
[0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
[0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)

[]中加入^后加再次限制条件「[^]」
[^a-z] 条件限制在非小写a to z范围中一个字符
[^A-Z] 条件限制在非大写A to Z范围中一个字符
[^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
[^0-9] 条件限制在非小写0 to 9范围中一个字符
[^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
[^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)

在限制条件为特定字符出现0次以上时，可以使用「*」
J* 0个以上J
.* 0个以上任意字符
J.*D J与D之间0个以上任意字符

在限制条件为特定字符出现1次以上时，可以使用「+」
J+ 1个以上J
.+ 1个以上任意字符
J.+D J与D之间1个以上任意字符

在限制条件为特定字符出现有0或1次以上时，可以使用「?」
JA? J或者JA出现

限制为连续出现指定次数字符「{a}」
J{2} JJ
J{3} JJJ
文字a个以上，并且「{a,}」
J{3,} JJJ,JJJJ,JJJJJ,???(3次以上J并存)
文字个以上，b个以下「{a,b}」
J{3,5} JJJ或JJJJ或JJJJJ
两者取一「|」
J|A J或A
Java|Hello Java或Hello

「()」中规定一个组合类型
比如，我查询<a href=/"index.html/">index</a>中<a href></a>间的数据，可写作<a.*href=/".*/">(.+?)</a>

在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
Pattern Pattern.compile(String regex, int flag)

flag的取值范围如下：
Pattern.CANON_EQ 当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a/u030A"会匹配"?"。默认情况下，不考虑"规范相等性(canonical equivalence)"。
Pattern.CASE_INSENSITIVE(?i) 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配，只要将UNICODE_CASE与这个标志合起来就行了。
Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"//s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
Pattern.DOTALL(?s) 在这种模式下，表达式‘.‘可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式‘.‘不匹配行的结束符。
Pattern.MULTILINE
(?m) 在这种模式下，‘^‘和‘$‘分别匹配一行的开始和结束。此外，‘^‘仍然匹配字符串的开始，‘$‘也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。
Pattern.UNICODE_CASE
(?u) 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。
Pattern.UNIX_LINES(?d) 在这个模式下，只有‘/n‘才被认作一行的中止，并且与‘.‘，‘^‘，以及‘$‘进行匹配。


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

我自己也没看完，不想看了，还是开始打开eclipse，练习，搞一些基础的，之前我用Java的String类提供的方法完美解析出游久的DOTA RSS，不过这要依赖String类强大的封装。估计String类内部也是通过正则表达式实现的。

好了，下面开始了


1.检测以某指定字符串开头或结尾

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern=Pattern.compile("^Java.*");  
  7.         Matcher matcher=pattern.matcher("Java   开发android必须精通");  
  8.         boolean b=matcher.matches();  
  9.         System.out.println(b);  
  10.     }  
  11. }  

注意，前面资料里有两条如下

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

^为限制开头
^java 条件限制为以Java为开头字符
. 条件限制除/n以外任意一个单独字符
在限制条件为特定字符出现0次以上时，可以使用「*」
.* 0个以上任意字符
.+ 1个以上任意字符
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

所以.*不可以省略，可以换成.+，我通过测试得到证实，结果如下

  1. true  

结尾的话，代码如下：

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern=Pattern.compile(".*Java$");  
  7.         Matcher matcher=pattern.matcher("Java   开发android必须精通,你好Java");  
  8.         boolean b=matcher.matches();  
  9.         System.out.println(b);  
  10.     }  
  11. }  

照样可以将.*换成.+,结果如下：

  1. true  
使用Java的String类照样可以完成这两个功能

String str="dadadada";
str.startsWith("ll");

str.endsWith("dddd");

2.多条件分割字符串

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("[\\]\\[]+");  
  7.         String[] strs = pattern.split("[01:34.50][00:38.22]一天过了一天 我的日记却病恹恹");  
  8.         for (int i=0;i<strs.length;i++)  
  9.         {  
  10.             System.out.println(strs[i]);  
  11.         }   
  12.             System.out.println(strs.length);  
  13.       
  14.   
  15.     }  
  16. }  

这个功能很实用啊，在做一个Android音乐播放器的时候，解析LRC文件的时候会用到，具体的资料为上面的

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

加入特定限制条件「[]」

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

不过在输出结果有四个字符串先看结果

  1.   
  1. 01:34.50  
  2. 00:38.22  
  3. 一天过了一天 我的日记却病恹恹  
  4. 4  
这也很容易理解，因为我们输入的字符串是以“[”开头的，所以第一个字符串是空的。

这个功能String类也实现了方法为

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("[\\]\\[]+");  
  7.         String[] strs = pattern.split("[01:34.50][00:38.22]一天过了一天 我的日记却病恹恹");  
  8.         for (int i=0;i<strs.length;i++)  
  9.         {  
  10.             //System.out.println(strs[i]);  
  11.         }   
  12.             //System.out.println(strs.length);  
  13.           
  14.               
  15.             String sp="[\\]\\[]+";  
  16.             String str="[01:34.50][00:38.22]一天过了一天 我的日记却病恹恹";  
  17.             String []s=str.split(sp);  
  18.             for(String d:s)  
  19.             {  
  20.                 System.out.println(d);  
  21.             }  
  22.   
  23.     }  
  24. }  

输出结果为

  1.   
  1. 01:34.50  
  2. 00:38.22  
  3. 一天过了一天 我的日记却病恹恹  

结果一样。

3.文字替换

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("正则表达式");  
  7.         Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");  
  8.         //替换第一个符合正则的数据  
  9.         System.out.println(matcher.replaceFirst("Java"));  
  10.   
  11.     }  
  12. }  

这个代码是替换首次出现的字符，结果如下：

  1. Java Hello World,正则表达式 Hello World  

下面是全部替换

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("正则表达式");  
  7.         Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");  
  8.         //替换第一个符合正则的数据  
  9.         System.out.println(matcher.replaceAll("Java"));  
  10.   
  11.   
  12.     }  
  13. }  

结果是：

  1. Java Hello World,Java Hello World  

下面是将给定的字符串中的类容换掉，重新获得一个字符全：

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("正则表达式");  
  7.         Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World ");  
  8.         StringBuffer sbr = new StringBuffer();  
  9.         while (matcher.find()) {  
  10.           matcher.appendReplacement(sbr, "Java");  
  11.         }  
  12.         matcher.appendTail(sbr);  
  13.         System.out.println(sbr.toString());  
  14.   
  15.   
  16.   
  17.     }  
  18. }  

同样，String类也实现了置换的方法

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         String string="你好，Java,我是张译成，正在学习Java";  
  7.           
  8.         String s1=string.replaceFirst("Java", "张译成");  
  9.         System.out.println(s1);  
  10.           
  11.           
  12.           
  13.         String ss=string.replace("Java", "张译成");  
  14.         System.out.println(ss);  
  15.   
  16.   
  17.     }  
  18. }  

结果是：

  1. 你好，张译成,我是张译成，正在学习Java  
  2. 你好，张译成,我是张译成，正在学习张译成  





4.除去HTML标志

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL);  
  7.         Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>");  
  8.         String string = matcher.replaceAll("");  
  9.         System.out.println(string);  
  10.   
  11.   
  12.   
  13.     }  
  14. }  

这个方法很重要，如果要解析html文件就可以派上用场。



5.找到符合已知条件的的字符串

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("href=\"(.+?)\"");  
  7.         Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>");  
  8.         if(matcher.find())  
  9.           System.out.println(matcher.group(1));  
  10.     }  
  11.   
  12.   
  13.   
  14.       
  15. }  

用这种方法可以找到第一个匹配的字符全，用下面的方法可以找到全部的字符全

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("href=\"(.+?)\"");  
  7.         Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>" +  
  8.                 "<a href=\"fsdfsfsfsfsfs\">地址</a>");  
  9.         while(matcher.find())  
  10.           System.out.println(matcher.group(1));  
  11.     }  
  12.   
  13.   
  14.   
  15.       
  16. }  

结果为

  1. index.html  
  2. fsdfsfsfsfsfs  

如果把matcher.group(1)换成matcher.group(0)则可以获得下面的结果

  1. href="index.html"  
  2. href="fsdfsfsfsfsfs"  

6.在字符串中检测网址

  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3. public class Test {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-\\:/]+");  
  7.         Matcher matcher = pattern.matcher("http://bolg.csdn.net/zhy_cheng，这是我的博客主页");  
  8.         StringBuffer buffer = new StringBuffer();  
  9.         while(matcher.find()){    
  10.           buffer.append(matcher.group(0));    
  11.              
  12.         System.out.println(buffer.toString());  
  13.         }  
  14.   
  15.     }  
  16.   
  17.   
  18.   
  19.       
  20. }  
输出结果

  1. http://bolg.csdn.net/zhy_cheng  

当然，正则表达式还有很多用法，在这里我就仅仅举例这些用途。


说实话，这些知识不好记忆，我们只需要知道一些基础就行了，在项目中遇到了，可以现学现卖也行，看情况行事。

版权声明：本文为博主http://www.zuiniusn.com原创文章，未经博主允许不得转载。

Java正则表达式

标签：java   正则表达式   

原文地址：http://blog.csdn.net/u013948187/article/details/46828989
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！