updates

Author: JackChan1999

第4章 常见对象/img/regex.png

@@ -1,4 +1,8 @@
-## 常用正则表达式
+### [常用正则表达式](https://deerchao.net/tutorials/regex/common.htm)
+
+说明：正则表达式通常用于两种任务：1.验证，2.搜索/替换。用于验证时，通常需要在前后分别加上\^和\$，以匹配整个待验证字符串；搜索/替换时是否加上此限定则根据搜索的要求而定，此外，也有可能要在前后加上\b而不是\^和\$。此表所列的常用正则表达式，除个别外均未在前后加上任何限定，请根据需要，自行处理。
+
+![](img/常用正则表达式.png)
 
 ### 校验数字的表达式
 ```

第4章 常见对象/img/regex1.png

@@ -6,6 +6,8 @@
 
 # 1. 正则表达式概述
 
+在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。
+
 正则表达式，又称正规表示法、常规表示法（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器里，正则表达式通常被用来检索、替换那些符合某个模式的文本
 
 许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen
@@ -16,7 +18,7 @@
 - 给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）
 - 可以通过正则表达式，从字符串中获取我们想要的特定部分
 
-## 1.2 正则表达式的特点是
+## 1.2 正则表达式的特点
 
 - 灵活性、逻辑性和功能性非常的强；
 - 可以迅速地用极简单的方式达到字符串的复杂控制。
@@ -116,7 +118,10 @@
 | \Z   | 输入的结尾，仅用于最后的结束符（如果有的话） |
 | \z   | 输入的结尾                  |
 
-### 2.4.1 Greedy数量词
+### 2.4.1 贪婪与懒惰数量词
+
+- 贪婪数量词
+
 | 符号     | 说明    |
 | ------ | ----- |
 | X?     | 0次或1次 |
@@ -126,6 +131,24 @@
 | X{n,}  | 至少n次  |
 | X{n,m} | n-m次  |
 
+当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。以这个表达式为例：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。
+
+有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。在贪婪数量词后面加上?就是懒惰匹配。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：
+
+a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。
+
+为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：**最先开始的匹配拥有最高的优先权——The match that begins earliest wins**。
+
+- 懒惰限定符
+
+| 代码/语法  | 说明               |
+| ------ | ---------------- |
+| *?     | 重复任意次，但尽可能少重复    |
+| +?     | 重复1次或更多次，但尽可能少重复 |
+| ??     | 重复0次或1次，但尽可能少重复  |
+| {n,m}? | 重复n到m次，但尽可能少重复   |
+| {n,}?  | 重复n次以上，但尽可能少重复   |
+
 ### 2.4.2 分组和捕获
 
 分组可以分为两种形式，捕获组和非捕获组。
@@ -191,39 +214,39 @@ Back引用（\n）是说在后面的表达式中我们可以使用组的编号
 | ?<=  | 后置约束-存在 |
 | ?<!  | 后置约束-排除 |
 
-### `?=...` 前置约束(存在)
+### `?=exp`前置约束(存在)
 
-`?=...` 前置约束(存在), 表示第一部分表达式必须跟在 `?=...`定义的表达式之后.
+?=exp 前置约束(存在), 表示第一部分表达式必须跟在 ?=exp 定义的表达式之后.
 
-返回结果只瞒住第一部分表达式. 定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`.
+返回结果只瞒住第一部分表达式. 定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: (?=exp).
 
 前置约束的内容写在括号中的等号后面. 例如, 表达式 `[T|t]he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
 
 ```
 "[T|t]he(?=\sfat)" => The fat cat sat on the mat.
 ```
 
-### `?!...` 前置约束-排除
+### `?!exp`前置约束-排除
 
-前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式 `前置约束-排除` 定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
+前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式 `前置约束-排除` 定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 (?!exp).
 
 表达式 `[T|t]he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
 
 ```
 "[T|t]he(?!\sfat)" => The fat cat sat on the mat.
 ```
 
-### `?<= ...` 后置约束-存在
+### `?<=exp`后置约束-存在
 
-后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式. 例如, 表达式 `(?<=[T|t]he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
+后置约束-存在 记作(?<=exp)用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式. 例如, 表达式 `(?<=[T|t]he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
 
 ```
 "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
 ```
 
-### `?<!...` 后置约束-排除
+### `?<!exp`后置约束-排除
 
-后置约束-排除 记作 `(?<!...)` 用于筛选所有匹配结果, 筛选条件为 其前不跟着定义的格式. 例如, 表达式 `(?<!(T|t)he\s)(cat)`匹配 `cat`, 且其前不跟着 `The` 或 `the`.
+后置约束-排除 记作 (?<!exp)用于筛选所有匹配结果, 筛选条件为 其前不跟着定义的格式. 例如, 表达式 `(?<!(T|t)he\s)(cat)`匹配 `cat`, 且其前不跟着 `The` 或 `the`.
 
 ```
 "(?<![T|t]he\s)(cat)" => The cat sat on cat.
@@ -275,6 +298,10 @@ Back引用（\n）是说在后面的表达式中我们可以使用组的编号
                   on the mat.
 ```
 
-# [3. learn-regex](https://github.com/zeeshanu/learn-regex)
+# 3. 更多正则表达式教程
+
+[learn-regex](https://github.com/zeeshanu/learn-regex)：一个学习正则的开源项目，由浅入深，很容易入手，而且教程有中文版。
+
+[正则表达式30分钟入门教程](https://deerchao.net/tutorials/regex/regex.htm#mission)
 
-一个学习正则的开源项目，由浅入深，很容易入手，而且教程有中文版
+[Java正则表达式的应用](http://www.cnblogs.com/kissazi2/p/3287206.html)

第4章 常见对象/img/regex2.png

@@ -137,26 +137,6 @@ public class RegexDemo {
 }
 ```
 
-```java
-public static String setHtmlCotentSupportImagePreview(String body) {
-    // 读取用户设置：是否加载文章图片--默认有wifi下始终加载图片
-    if (AppContext.get(AppConfig.KEY_LOAD_IMAGE, true)
-            || TDevice.isWifiOpen()) { 
-        // 过滤掉 img标签的width,height属性
-        body = body.replaceAll("(<img[^>]*?)\\s+width\\s*=\\s*\\S+", "$1");
-        body = body.replaceAll("(<img[^>]*?)\\s+height\\s*=\\s*\\S+", "$1");
-        // 添加点击图片放大支持
-        // 添加点击图片放大支持
-        body = body.replaceAll("(<img[^>]+src=\")(\\S+)\"",
-                "$1$2\" onClick=\"showImagePreview('$2')\"");
-    } else {
-        // 过滤掉 img标签
-        body = body.replaceAll("<\\s*img\\s+([^>]*)\\s*>", "");
-    }
-    return body;
-}
-```
-
 ### 1.4 获取功能
 
 Pattern和Matcher类的使用
@@ -190,7 +170,7 @@ public class RegexDemo {
 	}
 }
 ```
-- Pattern 匹配模式
+### 1.5 Pattern 匹配模式
 
 Pattern类为正则表达式的编译表示形式。指定为字符串的表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一个模式。
 
@@ -199,18 +179,115 @@ Pattern类为正则表达式的编译表示形式。指定为字符串的表达
 | compile() | 把正则表达式编译成匹配模式         |
 | matcher() | 根据匹配模式去匹配指定的字符串，得到匹配器 |
 
-- Matcher 匹配器
+### 1.6 Matcher 匹配器
 
-| 方法声明      | 功能描述         |
-| :-------- | :----------- |
-| matches() | 匹配字符串        |
-| find()    | 查找有没有满足条件的子串 |
-| group()   | 获取满足条件的子串    |
+| 方法声明                      | 功能描述                                     |
+| :------------------------ | :--------------------------------------- |
+| matches()                 | 匹配字符串                                    |
+| find()                    | 查找有没有满足条件的子串                             |
+| group()                   | 获取满足条件的子串                                |
+| reset()                   | 将Matcher的状态重新设置为最初的状态                    |
+| reset(CharSequence input) | 重新设置Matcher的状态，并且将候选字符序列设置为input后进行Matcher, 这个方法和重新创建一个Matcher一样，只是这样可以重用以前的对象。 |
+| start()                   | 返回Matcher所匹配的字符串在整个字符串的的开始下标             |
+| start(int group)          | 指定你感兴趣的sub group,然后返回sup group(子分组)匹配的开始位置。 |
+| end()                     | 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。      |
 
 - 注意事项
 
 Pattern类为正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式
 
+分组：简单的说，分组其实就是为了能够指定同一个规则可以使用多少次。正则表达式中的分组就是整个大的正则表达式和用（）圈起来的内容。
+
+在这个正则表达式"\\w(\\d\\d)(\\w+)"中
+
+- 分组0：是"\\w(\\d\\d)(\\w+)"
+- 分组1：是(\\d\\d)
+- 分组2：是(\\w+)
+
+如果我们稍稍变换一下，将原先的正则表达式改为"（\\w）(\\d\\d)(\\w+)"，我们的分组就变成了
+
+- 分组0：是"\\w(\\d\\d)(\\w+)"
+- 分组1：是"(\\w)"
+- 分组2：是"(\\d\\d)"
+- 分组3：是"(\\w+)"
+
+我们看看和正则表达式”\\w(\\d\\d)(\\w+)”匹配的一个字符串A22happy
+
+- group(0)是匹配整个表达式的字符串的那部分A22happy 
+- group(1)是第1组(\d\d)匹配的部分:22 
+- group(2)是第2组(\w+)匹配的那部分happy
+
+```java
+public static void main(String[] args) {
+	String Regex="\\w(\\d\\d)(\\w+)";
+	String TestStr="A22happy";
+	Pattern p=Pattern.compile(Regex);
+	Matcher matcher=p.matcher(TestStr);
+	if (matcher.find()) {
+	    int gc=matcher.groupCount();
+	    for (int i = 0; i <= gc; i++) {
+	        System.out.println("group "+i+" :"+matcher.group(i));
+	    }
+	}
+}
+```
+
+- start()方法的使用
+
+```java
+public static void testStart(){
+    //创建一个 Matcher ，使用 Matcher.start()方法
+    String candidateString = "My name is Bond. James Bond.";
+    String matchHelper[] ={"          ^","                      ^"};
+    Pattern p = Pattern.compile("Bond");
+    Matcher matcher = p.matcher(candidateString);
+    //找到第一个 'Bond'的开始下标
+    matcher.find();
+    int startIndex = matcher.start();
+    System.out.println(candidateString);
+    System.out.println(matchHelper[0] + startIndex);
+    //找到第二个'Bond'的开始下标
+    matcher.find();
+    int nextIndex = matcher.start();
+    System.out.println(candidateString);
+    System.out.println(matchHelper[1] + nextIndex);        
+}
+```
+
+运行结果：
+
+![](img/regex.png)
+
+```java
+/**
+  * 测试matcher.group方法
+  */
+public static void testGroup() {
+    // 创建一个 Pattern
+    Pattern p = Pattern.compile("Bond");
+    // 创建一个 Matcher ，以便使用 Matcher.group() 方法
+    String candidateString = "My name is Bond. James Bond.";
+    Matcher matcher = p.matcher(candidateString);
+    // 提取 group
+    matcher.find();
+    System.out.println(String.format("group匹配的字符串 : %s",matcher.group()));
+    System.out.println(String.format("匹配的开始位置 : %d", matcher.start()));
+    System.out.println(String.format("匹配的结束位置 : %d", matcher.end()));
+
+    System.out
+            .println("---再次使用matcher.find()方法，看看matcher中group、start、end方法的效果");
+    matcher.find();
+    System.out.println(String.format("group匹配的字符串 : %s",matcher.group()));;
+    System.out.println(String.format("匹配的开始位置 : %d", matcher.start()));
+    System.out.println(String.format("匹配的结束位置 : %d", matcher.end()));
+    System.out.println(String.format("candidateString字符串的长度 : %d", candidateString.length()));
+}
+```
+
+运行结果：
+
+![](img/regex1.png)
+
 - 获取由三个字符组成的单词
 
 ```java
@@ -261,6 +338,64 @@ public class RegexDemo2 {
 }
 ```
 
+- 判断身份证：要么是15位，要么是18位，最后一位可以为字母，并写程序提出其中的年月日。
+
+```java
+public static void main(String[] args) {
+    testID_Card();
+}
+
+public static void testID_Card() {
+    // 测试是否为合法的身份证号码
+    String[] strs = { "130681198712092019", "13068119871209201x",
+            "13068119871209201", "123456789012345", "12345678901234x",
+            "1234567890123" };
+    // 准备正则表达式（身份证有15位和18位两种，身份证的最后一位可能是字母）
+    String regex = "(\\d{14}\\w)|\\d{17}\\w";
+    // 准备开始匹配，判断所有的输入是否是正确的
+    Pattern regular = Pattern.compile(regex); // 创建匹配的规则Patter
+
+    StringBuilder sb = new StringBuilder();
+    // 遍历所有要匹配的字符串
+    for (int i = 0; i < strs.length; i++) {
+
+        Matcher matcher = regular.matcher(strs[i]);// 创建一个Matcher
+        sb.append("身份证:  ");
+        sb.append(strs[i]);
+        sb.append("   匹配:");
+        sb.append(matcher.matches());
+        System.out.println(sb.toString());
+        sb.delete(0, sb.length());// 清空StringBuilder的方法
+    }
+
+    GetBirthDay(strs);
+
+}
+
+private static void GetBirthDay(String[] strs) {
+    System.out.println("准备开始获取出生日期");
+    // 准备验证规则
+    Pattern BirthDayRegular = Pattern.compile("(\\d{6})(\\d{8})(.*)");
+    // .*连在一起就意味着任意数量的不包含换行的字符
+    Pattern YearMonthDayRegular = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");
+    for (int i = 0; i < strs.length; i++) {
+        Matcher matcher = BirthDayRegular.matcher(strs[i]);
+
+        if (matcher.matches()) {
+            Matcher matcher2 = YearMonthDayRegular.matcher(matcher.group(2));
+            if (matcher2.matches()) {
+                System.out.println(strs[i]+"    中的出生年月分解为： "+"年" + matcher2.group(1) + "   月：" + matcher2.group(2) + "  日：" + matcher2.group(3));
+
+            }
+        }
+    }
+}
+```
+
+运行结果：
+
+![](img/regex2.png)
+
 ## 2. 正则表达式工具类
 
 ```java