android studio 搜索正则 android 正则表达式

7速记理解技巧

四个字符是所有语言都支持的正则表达式，所以这个四个是基础的正则表达式。正则难理解因为里面有一个等价的概念，这个概念大大增加了理解难度，让很多初学者看起来会蒙，如果把等价都恢复成原始写法，自己书写正则就超级简单了，就像说话一样去写你的正则了：

　　 等价：
　　?,*,+,\d,\w 都是等价字符
　　？等价于匹配长度{0,1}
　　*等价于匹配长度{0,} 
　　+等价于匹配长度{1,}
　　\d等价于[0-9]
　　\w等价于[A-Za-z0-9]。

常用运算符与表达式：
　　^ 开始
　　（） 域段
　　[] 包含,默认是一个字符长度
　　[^] 不包含,默认是一个字符长度
　　{n,n} 匹配长度 
　　. 任何单个字符(\. 字符点)
　　| 或
　　\ 转义
　　$ 结尾
　　[A-Z] 26个大写字母
　　[a-z] 26个小写字母
　　[0-9] 0至9数字

[A-Za-z0-9] 26个大写字母、26个小写字母和0至9数字
　　， 分割
　　.
　　
　　 分割语法：
　　[A,H,T,W] 包含A或H或T或W字母
　　[a,h,t,w] 包含a或h或t或w字母
　　[0,3,6,8] 包含0或3或6或8数字

　　 语法与释义：
　　基础语法 "^([]{})([]{})([]{})$"
　　正则字符串 = "开始（[包含内容]{长度}）（[包含内容]{长度}）（[包含内容]{长度}）结束" 
　　
　　?,*,+,\d,\w 这些都是简写的,完全可以用[]和{}代替，在(?:)(?=)(?!)(?<=)(?<!)(?i)(*?)(+?)这种特殊组合情况下除外。
　　初学者可以忽略?,*,+,\d,\w一些简写标示符，学会了基础使用再按表自己去等价替换

　　
　　 实例：
　　字符串；tel:[phone]
　　原始正则："^tel:[0-9]{1,3}-[0][0-9]{2,3}-[0-9]{8,11}$" 
　　速记理解：开始 "tel:普通文本"[0-9数字]{1至3位}"-普通文本"[0数字][0-9数字]{2至3位}"-普通文本"[0-9数字]{8至11位} 结束"
　　等价简写后正则写法："^tel:\d{1,3}-[0]\d{2,3}-\d{8,11}$" ，简写语法不是所有语言都支持。

========================================================================================

1.简介： 

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。 
它包括两个类：Pattern和Matcher 。

Pattern： 一个Pattern是一个正则表达式经编译后的表现模式。 

Matcher： 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。

首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。 

以下我们就分别来看看这两个类：

2.Pattern类: 
Pattern的方法如下：

static Pattern compile(String regex) 
  将给定的正则表达式编译并赋予给Pattern类 
static Pattern compile(String regex, int flags) 
  同上，但增加flag参数的指定，可选的flag参数包括：CASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ 
int flags() 
  返回当前Pattern的匹配flag参数. 
Matcher matcher(CharSequence input) 
  生成一个给定命名的Matcher对象 
static boolean matches(String regex, CharSequence input) 
  编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生   成一个Matcher实例。 
String pattern() 
  返回该Patter对象所编译的正则表达式。 
String[] split(CharSequence input) 
  将目标字符串按照Pattern里所包含的正则表达式为模进行分割。 
String[] split(CharSequence input, int limit) 
  作用同上，增加参数limit目的在于要指定分割的段数，如将limi设为2，那么目标字符串将根据正则表达式分为割为两段。 

一个正则表达式，也就是一串有特定意义的字符，必须首先要编译成为一个Pattern类的实例，这个Pattern对象将会使用matcher()方法来生成一个Matcher实例，接着便可以使用该 Matcher实例以编译的正则表达式为基础对目标字符串进行匹配工作，多个Matcher是可以共用一个Pattern对象的。

现在我们先来看一个简单的例子，再通过分析它来了解怎样生成一个Pattern对象并且编译一个正则表达式，最后根据这个正则表达式将目标字符串进行分割：

import java.util.regex.*; 
public class Replacement{ 
public static void main(String[] args) throws Exception { 
// 生成一个Pattern,同时编译一个正则表达式 
Pattern p = Pattern.compile("[/]+"); 
//用Pattern的split()方法把字符串按"/"分割 
String[] result = p.split( 
"Kevin has seen《LEON》seveal times,because it is a good film." 
+"/ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部" 
+"好电影。/名词:凯文。"); 
for (int i=0; i<result.length; i++) 
System.out.println(result[i]); 
} 
}

输出结果为： 
Kevin has seen《LEON》seveal times,because it is a good film. 
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。 
名词:凯文。

很明显，该程序将字符串按"/"进行了分段。

 我们以下再使用 split(CharSequence input, int limit)方法来指定分段的段数，程序改动为： 
tring[] result = p.split("Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。"，2); 
这里面的参数"2"表明将目标语句分为两段。 
输出结果则为： 
Kevin has seen《LEON》seveal times,because it is a good film. 
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。

===================================================================================================

原来，group是针对（）来说的，group（0）就是指的整个串，group（1） 指的是第一个括号里的东西，group（2）指的第二个括号里的东西。

  最近学习正则表达式，发现Java中的一些术语与其他地方描述的有所差异。比如Java正则表达式中的“组”概念与《正则表达式必知必会》一书中讲述的“子表达式”其实是一样的，只是表述不同而已。由此也引发了使用JavaAPI时对group(int group)、start(int group)、end(int group)不是太理解。在阅读了关于正则表达式问题：有谁用过Matcher类的group()方法没有 之后彻底明白，并写了一个小程序测试。 

程序如下 

程序的运行结果为： 

1. package
2.   
3. import
4. import
5.   
6. public class
7.   
8. /**
9. * @param args
10. */
11. public static void
12. // TODO Auto-generated method stub
13. "Hello,World! in Java.";  
14. "W(or)(ld!)");  
15.    Matcher matcher = pattern.matcher(str);  
16. while(matcher.find()){  
17. "Group 0:"+matcher.group(0));//得到第0组——整个匹配
18. "Group 1:"+matcher.group(1));//得到第一组匹配——与(or)匹配的
19. "Group 2:"+matcher.group(2));//得到第二组匹配——与(ld!)匹配的，组也就是子表达式
20. "Start 0:"+matcher.start(0)+" End 0:"+matcher.end(0));//总匹配的索引
21. "Start 1:"+matcher.start(1)+" End 1:"+matcher.end(1));//第一组匹配的索引
22. "Start 2:"+matcher.start(2)+" End 2:"+matcher.end(2));//第二组匹配的索引
23. 0),matcher.end(1)));//从总匹配开始索引到第1组匹配的结束索引之间子串——Wor
24.    }  
25. }  
26.   
27. }

1. Group 0:World!  
2. Group 1:or  
3. Group 2:ld!  
4. Start 0:6 End 0:12
5. Start 1:7 End 1:9
6. Start 2:9 End 2:12
7. Wor

总结：其实group(),start(),end()所带的参数i就是正则表达式中的子表达式索引（第几个子表达式），由于刚开始对Java正则表达式中的组的概念不清晰，导致理解困难。当将“组”的概念与“子表达式”对应起来之后，理解matcher的group,start,end就完全没有障碍了。