五分钟搞定正则表达式，如果没搞定，再加两分钟
【这是 ZY 第 18 篇原创文章】   
文章概览
一、正则表达式介绍
 正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
不用过多介绍，大家对正则表达式应该不太陌生。即使没有用过，也一定听说过。 
 我们先看几个常见的正则表达式：
匹配 IP 地址
((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)

匹配电子邮箱
([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})
对于正则表达式，第一映像是一串神秘的字符串。如果不是真正了解其规则，看到这字符串，定然是摸不着头脑。  
 不过说实话，了解其规则以后，看到这数字，也有点头疼。毕竟正则这个东西，写时爽歪歪，看时如天书。    
 话虽这样说，正则表达式说白了，也就是一连串的规则而已，只要了解了规则，一点一点总能看懂。所以不要有畏难情绪。  
我们从最简单的例子开始，一点一点添加规则，争取让大家在学会正则表达式的过程中感觉不到丝毫痛苦。 
 （这里有一个网站，http://tool.oschina.net/regex/#，可以在线测试正则表达式的正确性，读者朋友们可以在这上面进行测试，方便学习，我们后面的例子讲解，也用这个工具）。   
二、几个常用规则
前面看了那么复杂的例子，我们这里回归本源，从一个简单的例子开始看。   
2.1 完全匹配
正则表达式是用来匹配文本的，现在假设我们要匹配 "abcdefg" 这一字符串中的 "abc" 三个字母，我们该怎么写呢？   
abc
对，不要怀疑，就是这么简单。 
 如果想匹配 "def"，那么就是
def
是不是很简单呢？是不是小脑瓜中又透露出一丝疑惑？ 
 如果正则表达式的匹配内容很简单，也很明确，可以进行完全匹配，写出来的结果就是这样的。   
2.2 符号 |
那我们再继续往后看。  
 还是 "abcdefg" 字符串，我们想匹配其中的 "ab" 和 "ef" 两个子串，怎么写呢？按照上面的写法，就是写两个正则 "ab" 和 "ef" 来匹配。这样可以，不过略显麻烦。我们写法如下：   
ab|ef
这里我们新加了 "|" 这个字符，表示 或，即匹配 ab 或者 ef，是不是就方便了许多。  
再继续看，这次我们需要改变一下待匹配的字符串。 
 我们在 "acabcdefgh acbbcdefgh accbcdefgh" 字符串中，要匹配 "abcdef"，"bbcdef"，"cbcdef" 三个子串。 
 读者朋友们一看，这题非常简单，用上面的方法，正则表达式如下：   
abcdef|bbcdef|cbcdef
写法正确，不过略显繁琐。我们的写法如下：    
(a|b|c)bcdef
是不是有些理解 "|" 的使用了呢。 那我们要匹配 "acabcdef"，"acbbcdef"，"accbcdef" 这三个子串怎么写呢？   
ac(a|b|c)bcdef
这下子理解 "|" 的使用了吧。而且我们现在的的写法，是不是长得有些 ”像“ 正则表达式了呢？
2.3 符号 []
我们继续。 
 上面的例子，我们如果不用 "|"，可以实现么？  
 答案是可以的，写法如下：   
ac[abc]bcdef
是不是看着比上面更清爽一点呢？  
 我们这里引入了一个新的字符 "[]"。 这对中括号是字符集的意思，里面包含的字符，都是或（"|"）的关系。 
 我们还可以这样写：   
ac[a-c]bcdef
"[a-c]" 表示的是匹配 a-c 之间的任意字符。   
这里对 "[]" 稍微多说一些，[] 除了可以放字符集合以及字符范围以外，还可以做取反操作。 
 比如 "[^a-c]" 表示的是匹配 a-c 范围以外其他的字符。"[^0-8]" 表示的是匹配 0-8 范围以外的其他字符。   
到了这里，我们已经可以写一些简单的匹配规则了。   
2.4 限制符号 * + ? {}
我们继续往下看。 
 我们现在想匹配 类似 "fooooooooooooooooof" 这样子的字符串，中间的 "o" 个数我们不能确定，上面讲到的规则就有点无能为力了。 
 那我们该怎么写呢？   
fo*f
这里的 "*" 表示匹配前面的子表达式零次或多次。   
那么有些读者朋友会问了，如果想匹配至少有一个 "o" 该怎么写呢？  
fo+f
这里的 "+" 表示匹配前面的子表达式一次或多次。  
那么读者朋友又问了，如果想匹配 0 个或者者 1 个 该怎么写呢？
fo?f
这里的 "?" 表示匹配前面的子表达式零次或一次。  
那么有些读者朋友又会问了，如果想匹配确定次数的 "o" 该怎么写呢？ 
 我们可以这样写：   
fo{2}f
上面的规则，会匹配 foof，即匹配 2 个 "o"。 
 所以，"{n}" 表示匹配前面子表达式 n 次。   
那读者朋友们再次发问，如果想匹配至少 n 个 "o" 该怎么写呢？
fo{2,}f
"{n,}" 表示匹配前面子表达式至少 n 次。 
那读者朋友们这次不发问了，会举一反三了，那如果想匹配 最少 n 个，最多 m 个呢？
fo{2,5}f
"{n,m}" 表示匹配前面子表达式至少 n 次，至多 m 次。 
所以 "*" 等价于 "{0,}"，"+" 等价于 "{1,}"，"?" 等价于 "{0,1}"。   
到这里，我们能写的匹配规则更多了，而且可以说大部分匹配运用上面的规则都可以实现了。  
 大家可以回头看看文章开头贴的几段正则表达式，看看是否能看懂了。
当然除此之外，正则里的规则其实还是不少的，除了上面几个，我们再看几个比较常用的。   
2.5 几个转义字符
在正则表达式里，也有一些转义字符，表示一些特殊的含义。 "d" 表示匹配数字字符，等价于 "[0-9]"。  
 "D" 表示匹配非数字字符，等价于 "[^0-9]"。  
 "n" 表示匹配换行符。  
 "s" 表示匹配任何空白字符，等价于 "[fnrtv]"。  
 "S" 表示匹配任何非空白字符，等价于 "[^fnrtv]"。    
2.6 符号 .
符号 "." 会匹配 "n" 以外的所有字符，也是比较常用的。  
2.7 符号 ?
到目前为止，我们已经学习了大部分常用的正则表达式规则，日常开发基本已经够用了。 
 不过使用正则表达式时，限制字符 "* + ? {}" 默认的匹配规则是贪婪的。什么意思呢？  
 比如说有一个字符串 "abbbbb"，我们使用正则表达式 "ab+" 去匹配，匹配的结果是 "abbbbbbb"，会尽可能多的去匹配满足的字符。  
 我们如果想尽可能少的匹配满足的字符，那么就在限定符后面加 "?"。  
 "ab+?" 匹配的结果就是 ab。 
 "?" 符号的非贪婪匹配，在某些情况下也是很有用的。   
2.8 符号 ()
最后我们再来看一个符号 "()"，小括号的含义是分组，可以理解为被小括号包含的子表达式就是一个分组，在前面介绍 "|" 的时候我们使用过。 
 不过分组也分很多类型。 
 "(pattern)" 小括号单纯的包含了子表达式，表示此分组可以被捕获。捕获的意思就是此分组的内容会被保存下来，后续可以从匹配的集合中获取到。 
 "(?:pattern)" 小括号中增加了 ?: 前缀，表示此分组不可以被捕获。后续匹配的集合中就不会包含此分组信息。 
 这样说下来，不太好理解。这里需要结合具体开发语言的实现来说。先留个悬念，后面会讲到。   
"(?=pattern)" 小括号中增加了 ?= 前缀，表示的是匹配此分组，但是此分组里的内容不需要被获取。 
 "(?!pattern)" 小括号中增加了 ?! 前缀，表示的是匹配此分组之外的内容，但是此分组里的内容不需要被获取。  
 举个栗子：  
 正则表达式 "Windows(?=95|98|NT|2000)" 可以匹配字符串 "Windows2000" 中的 "Windows"，但是不能匹配 "Windows3.1" 中的 Windowds。 正则表达式 "Windows(?!95|98|NT|2000)" 可以匹配字符串 "Windows3.1" 中的 "Windows"，但是不能匹配 "Windows2000" 中的 Windowds。
以上就是正则表达式里一些常见的规则解析。
2.9 看看文章开头的例子
我们在文章开头放了两个例子，这里来分析一下。   
匹配 IP 地址的正则表达式： 
 "((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)"  
 我们分段来看。  
 先看第一段 "(2[0-4]d|25[0-5]|[01]?dd?).)"，这里用 "|" 分割了三种匹配情况。  
 第一种是 "2[0-4]d"，即三位数字，第一位是 2，第二位是 0 - 4 之间，第三位是任意数字。  
 第二种是 "25[0-5]"，三位数字，第一位是 2，第二位是 5，第三位是 0 - 5 之间。 
 第三种是 "[01]?dd?"，第一位是 0 或者 1，匹配零次或一次，第二位和第三位是任意数字，第三位数字匹配零次或一次，也就是 一位数，两位数，三位数都可能满足这种情况。 
 第一段末尾是 "." 作为分隔符。   
再来看第二段 "{3}"，这个表示前面的子表达式重复三次，也就是 IP 地址的前三个字节。   
再看第三段 "(2[0-4]d|25[0-5]|[01]?dd?)"，和第一段是一样的。   
匹配电子邮箱：  
 "([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})" 
 也是分段来看。 
 第一段 "([a-z0-9_.-]+)"，表示匹配 a-z 范围内的字母，0-9 范围的数字，以及 "_"，"."，"-" 三个字符，"+" 表示至少有一个字符。 
 第二段 "@" 表示匹配 "@" 字符。 
 第三段 "([da-z.-]+)"，"d" 表示匹配任意数字，a-z 范围的字母，"."，"-" 两个字符，"+" 至少有一个字符。 
 第四段 "." 表示匹配 "." 字符。 
 第五段 "([a-z.]{2,6})"，表示匹配 a-z 范围的字母，"." 字符，"{2,6}" 表示至少 2 个字符，至多 6 个字符。   
经过上面的讲解，大家应该对正则表达式有了进一步的了解。   
三、在代码中如何使用
在了解了正则表达式的规则以后，我们看一下在实际代码中是如何使用的。 这里以 Java 代码作为示例。
在 Java 中，关于正则表达式的主要有两个类，Pattern 和 Matcher。 
 我们看一下具体如何使用。
package 
上面代码运行的结果如下：
match boy: boy1
match boy number: 1
match boy: boy2
match boy number: 2
match boy: boy3
match boynumber: 3
is phone number: true
split res: gril
split res: girl
split res: 
split res: girl

Process finished with exit code 0
在 Java 中使用正则表达式分三步走： 1. 写好正则表达式 2. Pattern.compile 生成 Pattern 对象 3. 调用 Pattern 相关的正则操作
Pattern 类中有几个方法会比较常用： Pattern#matcher 生成 Matcher，可以对正则表达式进行匹配，以及获取匹配的内容。 
 Pattern#split 根据正则表达式内容划分字符串。   
Matcher 类中也有几个方法比较常用： Matcher#find 寻找下一个满足规则的子串，通常用在查找子串中。  
 Matcher#matches 用来判断整个字符串是否满足匹配规则，常用的类似匹配电话号码，邮箱等等。  
 Matcher#group 就是获取我们在上面讲到的 "()" 小括号分组。默认 group(0) 整个串的匹配，group(1)，group(2) 等等往后顺延，就是小括号内的分组。 在我们上面的例子中的正则表达式是 "boy([0-9])"，用来获取字符串中的 boy，而括号中的分组是 boy 的编号，在生成 Matcher 以后，调用 Matcher#group(0) 获取的是整个匹配内容，Matcher#group(1) 获取的是小括号分组的内容。   
通过上面例子，大家应该明白 "()" 的作用了吧。
四、规则全集
下面总结一下正则表达式的所有规则，在使用时可以查阅，引用自 https://tool.oschina.net/uploads/apidocs/jquery/regexp.html：
总结
最后，大家只要多多练习，实际开发中多使用，掌握正则表达式不是难事～   
参考资料
https://tool.oschina.net/uploads/apidocs/jquery/regexp.html

前言
贪婪模式和非贪婪模式是正则匹配中的重要特性
在理解贪婪和非贪婪的区别时，可以根据实例，一步一步的循序渐进
大纲
匹配规则简介
贪婪模式与非贪婪模式快速理解
实例练习
回溯现象与匹配失败
匹配规则简介
var str='aabcab';
var reg=/ab/;
var res=str.match(reg);
// ab index 为 1
console.log(res);
要快速理解正则的匹配规则，可以先尝试理解上述的例子
匹配步骤是这样的:
初始index=0，匹配到了字符a
接下来匹配下一个字符a，但是由于aa和/ab/不匹配，因此此次匹配失败
index挪到下一个，从1开始，又重新匹配了a
接下来匹配下一个字符b，刚好和/ab/匹配，因此此次匹配成功，返回了ab，index=1
如果正则的匹配后面有g这种关键字，则会继续开始下一组的匹配(但是本例中没有g，因此只有一组结果)
要点
最先开始的匹配拥有最高的优先权
这一个要点的详细解释是: 例如第一个匹配的字符是a，假设之后的匹配没有出现匹配失败的情况。则它将一直匹配下去，直到匹配完成，也就是说index=0不会变，直到匹配完成(如果出现匹配失败并且无法回溯，index才会继续往下挪)
这一点适用于下面的贪婪模式与非贪婪模式中(并且优先级高于它们)，因此请谨记
贪婪模式与非贪婪模式快速理解
贪婪匹配模式
定义
正则表达式去匹配时，会尽量多的匹配符合条件的内容
标识符
+，?，*，{n}，{n,}，{n,m}
匹配时，如果遇到上述标识符，代表是贪婪匹配，会尽可能多的去匹配内容
示例
var str='aacbacbc';
var reg=/a.*b/;
var res=str.match(reg);
// aacbacb index为0
console.log(res);
上例中，匹配到第一个a后，开始匹配.*，由于是贪婪模式，它会一直往后匹配，直到最后一个满足条件的b为止，因此匹配结果是aacbacb
示例2
var str='aacbacbc';
var reg=/ac.*b/;
var res=str.match(reg);
// acbacb index为1
console.log(res);
第一个匹配的是a，然后再匹配下一个字符a时，和正则不匹配，因此匹配失败，index挪到1，接下来匹配成功了ac，继续往下匹配，由于是贪婪模式，尽可能多的去匹配结果，直到最后一个符合要求的b为止，因此匹配结果是acbacb
非贪婪匹配模式
定义
正则表达式去匹配时，会尽量少的匹配符合条件的内容
也就是说，一旦发现匹配符合要求，立马就匹配成功，而不会继续匹配下去(除非有g，开启下一组匹配)
标识符
+?，??，*?，{n}?，{n,}?，{n,m}?
可以看到，非贪婪模式的标识符很有规律，就是贪婪模式的标识符后面加上一个?
示例
var str='aacbacbc';
var reg=/a.*?b/;
var res=str.match(reg);
// aacb index为0
console.log(res);
上例中，匹配到第一个a后，开始匹配.*?，由于是非贪婪模式，它在匹配到了第一个b后，就匹配成功了，因此匹配结果是aacb
为什么是aacb而不是acb呢？
因为前面有提到过一个正在匹配的优先规则: 最先开始的匹配拥有最高的优先权
第一个a匹配到了，只要之后没有发生匹配失败的情况，它就会一直匹配下去，直到匹配成功
示例2
var str='aacbacbc';
var reg=/ac.*?b/;
var res=str.match(reg);
// acb index为1
console.log(res);
先匹配的a，接下来匹配第二个a时，匹配失败了index变为1，继续匹配ac成功，继续匹配b，由于是非贪婪模式，此时acb已经满足了正则的最低要求了，因此匹配成功，结果为acb
示例3
var str='aacbacbc';
var reg=/a.*?/;
var res=str.match(reg);
// a index为0
console.log(res);
var reg2=/a.*/;
var res2=str.match(reg2);
// aacbacbc index为0
console.log(res2);
这一个例子则是对示例1的补充，可以发现，当后面没有b时，由于是非贪婪模式，匹配到第一个a就直接匹配成功了
而后面一个贪婪模式的匹配则是会匹配所有
实例练习
在初步理解了贪婪模式与非贪婪模式后，可以通过练习加深理解
提取HTML中的Div标签
给出一个HTML字符串，如下
其它元素
用户:张三
密码:123456
其它元素
__需求__: 提取出div包裹的内容(包括div标签本身)，并将各个结果存入数组
__代码__: 通过非贪婪模式的全局匹配来完成，如下
var reg=/
.*?/g;
var res=str.match(reg);
// ["
用户:张三
", "
密码:123456
"]
console.log(res);
__详解__: 用到了两个知识点，.*?的非贪婪模式匹配以及g全局匹配
.*?代表每次只会匹配一次div，这样可以确保每一个div不会越界
最后的g代表全局匹配，即第一次匹配成功后，会将匹配结果放入数组，然后从下一个index重新开始匹配新的结果
__另外__: 假设使用了/
.*/g进行贪婪模式的匹配，结果则是
["
用户:张三
密码:123456
"]
因为贪婪模式匹配了第一个
后会无限贪婪的匹配接下来的字符，直到最后一个符合条件的
为止，导致了将中间所有的div标签都一起匹配上了
提取两个""中的子串，其中不能再包含""
"The phrase \"regular expression\" is called \"Regex\" for short"
__需求__: 提取两个引号之间的子串，其中不能再包括引号，例如上述的提取结果应该是: "regular expression" 与 "Regex"(每一个结束的"后面都接空格)
__错误解法__: 通过如下的非贪婪匹配(请注意空格)
var str='"The phrase \"regular expression\" is called \"Regex\" for short"';
var reg=/".*?" /g;
var res=str.match(reg);
// ['"The phrase "regular expression"  ', '"Regex"  ']
console.log(res);
可以看到，上述的匹配完全就是匹配错误了，这个正则匹配到第一个符合条件的"+空格后就自动停下来了
__正确解法__: 使用贪婪模式进行匹配
var reg=/"[^"]*" /g;
var res=str.match(reg);
// ['"regular expression" ', '"Regex" ']
console.log(res);
这个匹配中
从第一个"开始匹配，接下来到12位时("r的")，不满足[^"]，也不满足之后的"+空格，因此匹配失败了，index挪到下一个，开始下一次匹配
第二个匹配从"r的"开始，一直匹配到n"空格的空格，这一组刚刚好匹配成功(因为最后符合了正则的"空格)，匹配好了"regular expression"空格
第三个匹配匹配到了"Regex"空格(过程不再复述)
到最后时，仅剩一个"直接匹配失败(因为首先得符合"才能开始挣扎匹配)
至此，正则匹配结束，匹配成功，并且符合预期
__最后__:  这个例子相对来说复杂一点，如要更好的理解，可以参考引用来源中的文章，里面有就原理进行介绍
另外，参考文章中还有对非贪婪模式的匹配失败，回溯影响性能等特性进行原理分析与讲解
回溯现象与匹配失败
你真的已经理解了贪婪模式和非贪婪模式么？
回溯现象
不知道对上面最后例子中提到的回溯这词有没有概念？
这里仍然以上例引用来源中的示例来分析
原字符串
"Regex"
贪婪匹配过程分析
".*"
第一个"取得控制权，匹配正则中的"，匹配成功，控制权交给.*
.*取得控制权后，匹配接下来的字符，.代表匹配任何字符，*代表可匹配可不匹配，这属于贪婪模式的标识符，会优先尝试匹配，于是接下来从1位置处的R开始匹配，依次成功匹配了R，e，g，e，x，接着继续匹配最后一个字符"，匹配成功，这时候已经匹配到了字符串的结尾，所以.*匹配结束，将控制符交给正则式中最后的"
"取得控制权后，由于已经是到了字符串的结尾，因此匹配失败，向前查找可供回溯的状态，控制权交给.*，.*让出一个字符"，再把控制权交给"，此时刚好匹配成功
至此，整个正则表达式匹配完毕，匹配结果为"Regex"，匹配过程中回溯了1次
非贪婪匹配表达式
".*?"
第一个"取得控制权，匹配正则中的"，匹配成功，控制权交给.*?
.*?取得控制权后，由于这是非贪婪模式下的标识符，因此在可匹配可不匹配的情况下会优先不匹配，因此尝试不匹配任何内容，将控制权交给"，此时index在1处(R字符处)
"取得控制权后，开始匹配1处的R，匹配失败，向前查找可供回溯的状态，控制权交给.*?，.*?吃进一个字符，index到了2处，再把控制权交给"
"取得控制权后，开始匹配2处的e，匹配失败，重复上述的回溯过程，直到.*?吃进了x字符，再将控制权交给”
"取得控制权后，开始匹配6处的"，匹配成功
至此，整个正则表达式匹配完毕，匹配结果为"Regex"，匹配过程中回溯了5次
优化去除回溯
上述的贪婪匹配中，出现了一次回溯现象，其实也可以通过优化表达式来防止回溯的，比如
"[^"]*"
这个表达式中构建了一个子表达式-[]中的^"，它的作用是排除"匹配，这样*的贪婪匹配就不会主动吃进"，这样最后就直接是"匹配"，匹配成功，不会进行回溯
总结
上述的分析中可以看出，在匹配成功的情况下，贪婪模式进行了更少的回溯(可以自行通过更多的实验进行验证)，因此在应用中，在对正则掌握不是很精通的情况下，可以优先考虑贪婪模式的匹配，这样可以避免很多性能上的问题
匹配失败的情况
上述的回溯分析都是基于匹配成功的情况，那如果是匹配失败呢？
var str = '"Regex'
var reg = /"[^"]*"/g;
这个原字符中，没有最后的"，因此匹配是会失败的，它的过程大致如下
"匹配"，接着[]的^"与*匹配R，e，g，e，x
接着到了最后，"获取控制权，由于到了最后，开始回溯
依次回溯的结果是*让出x，e，g，e，R，直到*已经无法再让出字符，第一轮匹配失败
接着index开始往下挪，依次用"匹配R，e，g，e，x都失败了，一直到最后也没有再匹配到结果，因此此次正则表达式的匹配失败，没有匹配到结果(或者返回null)
那非贪婪模式呢？
/"[^"]*?"/g
"匹配"，接着*尝试不匹配，"匹配R，失败，然后回溯，*吃进R
接下来类似于上一步，*依次回溯吃进e，g，e，x，一直到最后，*再次回溯想吃进时，已经到了字符串结尾了，无法继续，因此第一轮匹配失败
接着index开始往下挪，依次用"匹配R，e，g，e，x都失败了，返回null
总结
通过匹配失败的例子可以看出贪婪和非贪婪的模式区别。贪婪是先吃进，回溯再让出，非贪婪是先忽略，回溯再吃进
而且，在匹配失败的情况下，贪婪模式也会进行不少的回溯(非贪婪当然一直都很多回溯)
但是，实际情况中是可以通过子表达式优化的，比如构建^xxx，可以当匹配到不符合条件的时候提前匹配失败，这样就会少很多回溯
var str = '"cccccc'
var reg = /"[^"c]*"/g;
这个由于直接排除了c，因此*不会吃进它，直接就匹配失败了，减少了很多回溯(当然，上述只是最简单的例子，实际情况要更复杂)
写在最后的话
正则匹配中，贪婪模式与非贪婪模式乍看之下一看便知，很容易理解，但是真正的深入理解需要掌握正则的原理才行，并且，真正理解它们后，就不仅仅只是写出普通的正则表达式，而是高性能的正则表达式了，比如理解非贪婪模式中的回溯特性后更容易写出高性能的表达式
本文也只是做一些浅显的分析与引导，更多是起到抛砖引玉的作用，要深入理解还请去了解正则的原理
附录
博客
初次发布2017.07.06于个人博客
参考资料

串（string）是由零个或多个宇符组成的有限序列，又名叫字符串。

定义的解释： 

  串中的字符数目n称为串的长度，定义中谈到“有限”是指长度n是一个有限的数值。 

  零个字符的串称为空串（null string），它的长度为零，可以直接用两双引号一表示，也可以用希腊Φ字母来表示。 

  所谓的序列，说明串的相邻字符之间具有前驱和后继的关系。

下面是串的一些概念性东西：

  空格串，是只包含空格的串。注意它与空串的区别，空格串是有内容有长度的，而且可以不止一个空格。   

  子串与主串，串中任意个数的连续字符组成的子序列称为该串的子串，相应地，包含子串的串称为主串。子串在主串中的位置就是子串的第一个字符在主串中的序号。

  串的比较是通过组成串的字符之间的编码来进行的，而字符的编码指的是字符在对应字符集中的序号。比较两个串是否相等，必须是它们串的长度以及它们各个对应位置的字符都相等时，才算是相等。

串与线性表的比较： 

  两者的逻辑结构比较相似，不同的是串针对的是字符集（即串中的元素都是字符）。 

  线性表更关注的是单个元素的操作，比如査找一个元素，插入或删除一个元素，但串中更多的是査找子串位置、得到指定位置子串、替换子串等操作。 

  串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区。一般是用定长数组来定义。

注意： 

  串的连接操作，需要注意串长问题，可能遇到的问题就是两个串连接后会不会溢出，所以需要进行截断操作。

查找子串在主串中的位置，操作如下： 

 1. 设i用于主串s1中当前位置下标值，j用于子串sub中当前位置下标值。 

 2. 首先我们比较s1[1]与sub[1]，如果相同的话，可能子串就开始了。 

 3. 如果不相等，那么子串仍然是从sub[1]开始，而主串s1则以s1[2]与其比较。 

 4. 如果连续出现子串长度次或以上匹配，那么就找到子串了，此时的j必然大于子串长度sub[0]。

KMP模式匹配算法： 

  这个东西有些难懂，下面是我的学习的时候的一些经验，希望对大家有所帮助。

KMP模式匹配算法，不懂的话建议去鱼C看视频：http://study.163.com/course/courseMain.htm?courseId=468002，讲的很不错，很详细； 

然后对于前后缀视频里面讲的还不是很详细清楚，不好理解的话可以去看阮一峰的这篇文章http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html

还有两篇KMP推荐： 

从头到尾彻底理解KMP（2014年8月22日版） - 结构之法 算法之道 - 博客频道 - CSDN.NET 
http://blog.csdn.net/v_july_v/article/details/7041827

KMP算法学习初步 | 海虹不老阁——遥望北方的狼 
http://haihongblog.com/archives/911.html

下面是我的Java实现版本： 


package com.phn.string;
import java.util.Arrays;
/**
 * @author 潘海南
 * @Email 1016593477@qq.com
 * @TODO 模式匹配算法
 * @date 2015年7月26日
 */
public class FOKMP {
    private static int[] getNext(String Str) {
        int[] next = new int[Str.length()];
        int i, j;
        i = 0;
        j = -1;
        next[0] = -1;
        while (i < Str.length() - 1) {
            if (j == -1 || Str.charAt(i) == Str.charAt(j)) {
                i++;
                j++;
                if (Str.charAt(i) != Str.charAt(j)) {
                    next[i] = j;
                } else {
                    next[i] = next[j];
                }
            } else {
                j = next[j];
            }
        }
        return next;
    }
    public static int indexKMP(String S, String T) {
        int i = 0;
        int j = 0;
        int[] next = getNext(T);
        System.out.println(Arrays.toString(next));
        while (i <= S.length() - 1 && j <= T.length() - 1) {
            if (j == -1 || S.charAt(i) == T.charAt(j)) {
                i++;
                j++;
            } else {
                j = next[j];
            }
        }
        if (j >= T.length())
            return i - T.length();
        return -1;
    }
}

如前所述,您将需要转义内部的双引号
全部的
你的琴弦。
如果你想得到“1000”,你需要使用
group(1)
,否则您将得到完全匹配的模式。
结果代码:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class gfile
{
public static void main(String args[]) {
// create a Pattern
Pattern p = Pattern.compile("
(.*?)
");
// create a Matcher and use the Matcher.group() method
String can="
"+
"
"+
"
1,000
" +
"
"font-weight:bold\">times
"+
"
"+
"
";
Matcher matcher = p.matcher(can);
if(matcher.find())
{
System.out.println(matcher.group(1));
}
else
System.out.println("could not find");
}
}