amgm-coder
diff --git a/‎docs/_sidebar.md
Lines changed: 2 additions & 0 deletions b/‎docs/_sidebar.md
Lines changed: 2 additions & 0 deletions
diff --git a/‎docs/basics/java-basic/integer-scope.md
Lines changed: 3 additions & 1 deletion b/‎docs/basics/java-basic/integer-scope.md
Lines changed: 3 additions & 1 deletion
diff --git a/‎docs/basics/java-basic/replace-in-string.md
Lines changed: 14 additions & 69 deletions b/‎docs/basics/java-basic/replace-in-string.md
Lines changed: 14 additions & 69 deletions
diff --git a/‎docs/basics/java-basic/string-append.md
Lines changed: 28 additions & 2 deletions b/‎docs/basics/java-basic/string-append.md
Lines changed: 28 additions & 2 deletions
@@ -73,6 +73,8 @@
             * [String对“+”的重载](/basics/java-basic/string-append.md)
 
             * [字符串拼接的几种方式和区别](/basics/java-basic/string-concat.md)
+            
+            * [Java 8中的StringJoiner](/basics/java-basic/stringjoiner-in-java8.md)
 
             * [String.valueOf和Integer.toString的区别](/basics/java-basic/value-of-vs-to-string.md)
 
 
@@ -3,9 +3,11 @@ Java中的整型主要包含byte、short、int和long这四种，表示的数字
 先来个简单的科普，1字节=8位（bit）。java中的整型属于有符号数。
 
 先来看计算中8bit可以表示的数字：
+
 最小值：10000000 （-128）(-2^7)
+
 最大值：01111111（127）(2^7-1)
-具体计算方式参考：[Java中，为什么byte类型的取值范围为-128~127? - CSDN博客](https://blog.csdn.net/qq_23418393/article/details/57421688)
+
 
 整型的这几个类型中，
 
 
@@ -12,72 +12,17 @@ replaceAll和replaceFirst的区别主要是替换的内容不同，replaceAll是
 
 ### 用法例子
 
-一以下例子参考：http://www.51gjie.com/java/771.html
-
-1. replaceAll() 替换符合正则的所有文字
-
-```
-//文字替换（全部） 
-Pattern pattern = Pattern.compile("正则表达式"); 
-Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World"); 
-//替换所有符合正则的数据 
-System.out.println(matcher.replaceAll("Java")); 
-
-```
-   
-
-2. replaceFirst() 替换第一个符合正则的数据
-
-```
-//文字替换（首次出现字符） 
-Pattern pattern = Pattern.compile("正则表达式"); 
-Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World"); 
-//替换第一个符合正则的数据 
-System.out.println(matcher.replaceFirst("Java")); 
-    
-```
-    
-3. replaceAll()替换所有html标签
-
-```
-//去除html标记 
-Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL); 
-Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>"); 
-String string = matcher.replaceAll(""); 
-System.out.println(string); 
-
-```
-
-4. replaceAll() 替换指定文字 
-```
-//替换指定{}中文字 
-String str = "Java目前的发展史是由{0}年-{1}年";
-String[][] object = {
-    new String[] {
-        "\\{0\\}",
-        "1995"
-    },
-    new String[] {
-        "\\{1\\}",
-        "2007"
-    }
-};
-System.out.println(replace(str, object));
-public static String replace(final String sourceString, Object[] object) {
-    String temp = sourceString;
-    for (int i = 0; i < object.length; i++) {
-        String[] result = (String[]) object[i];
-        Pattern pattern = Pattern.compile(result[0]);
-        Matcher matcher = pattern.matcher(temp);
-        temp = matcher.replaceAll(result[1]);
-    }
-    return temp;
-}
-
-```
-
-5. replace()替换字符串
-
-```
-System.out.println("abac".replace("a", "\\a")); //\ab\ac 
-```
+    String string = "abc123adb23456aa";
+    System.out.println(string);//abc123adb23456aa
+
+    //使用replace将a替换成H
+    System.out.println(string.replace("a","H"));//Hbc123Hdb23456HH
+    //使用replaceFirst将第一个a替换成H
+    System.out.println(string.replaceFirst("a","H"));//Hbc123adb23456aa
+    //使用replace将a替换成H
+    System.out.println(string.replaceAll("a","H"));//Hbc123Hdb23456HH
+
+    //使用replaceFirst将第一个数字替换成H
+    System.out.println(string.replaceFirst("\\d","H"));//abcH23adb23456aa
+    //使用replaceFirst将所有数字替换成H
+    System.out.println(string.replaceAll("\\d","H"));//abcHHHadbHHHHHaa
@@ -1,3 +1,29 @@
-1. String s = "a" + "b"，编译器会进行常量折叠(因为两个都是编译期常量，编译期可知)，即变成 String s = "ab"
+有人把Java中使用+拼接字符串的功能理解为运算符重载。其实并不是，Java是不支持运算符重载的。这其实只是Java提供的一个语法糖。
 
-2. 对于能够进行优化的(String s = "a" + 变量 等)用 StringBuilder 的 append() 方法替代，最后调用 toString() 方法 (底层就是一个 new String())
+>运算符重载：在计算机程序设计中，运算符重载（英语：operator overloading）是多态的一种。运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
+
+>语法糖：语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。
+
+前面提到过，使用+拼接字符串，其实只是Java提供的一个语法糖， 那么，我们就来解一解这个语法糖，看看他的内部原理到底是如何实现的。
+
+还是这样一段代码。我们把他生成的字节码进行反编译，看看结果。
+
+    String wechat = "Hollis";
+    String introduce = "每日更新Java相关技术文章";
+    String hollis = wechat + "," + introduce;
+    
+反编译后的内容如下，反编译工具为jad。
+
+    String wechat = "Hollis";
+    String introduce = "\u6BCF\u65E5\u66F4\u65B0Java\u76F8\u5173\u6280\u672F\u6587\u7AE0";//每日更新Java相关技术文章
+    String hollis = (new StringBuilder()).append(wechat).append(",").append(introduce).toString();
+
+通过查看反编译以后的代码，我们可以发现，原来字符串常量在拼接过程中，是将String转成了StringBuilder后，使用其append方法进行处理的。
+
+那么也就是说，Java中的+对字符串的拼接，其实现原理是使用StringBuilder.append。
+
+但是，String的使用+字符串拼接也不全都是基于StringBuilder.append，还有种特殊情况，那就是如果是两个固定的字面量拼接，如：
+
+    String s = "a" + "b"
+
+编译器会进行常量折叠(因为两个都是编译期常量，编译期可知)，直接变成 String s = "ab"。