converter = something::startsWith;
+String converted = converter.convert("Java");
+System.out.println(converted); // "J"
+```
+
+接下来看看构造函数是如何使用`::`关键字来引用的，首先我们定义一个包含多个构造函数的简单类：
+
+```java
+class Person {
+ String firstName;
+ String lastName;
+
+ Person() {}
+
+ Person(String firstName, String lastName) {
+ this.firstName = firstName;
+ this.lastName = lastName;
+ }
+}
+```
+接下来我们指定一个用来创建Person对象的对象工厂接口：
+
+```java
+interface PersonFactory {
+ P create(String firstName, String lastName);
+}
+```
+
+这里我们使用构造函数引用来将他们关联起来，而不是手动实现一个完整的工厂：
+
+```java
+PersonFactory personFactory = Person::new;
+Person person = personFactory.create("Peter", "Parker");
+```
+我们只需要使用 `Person::new` 来获取Person类构造函数的引用，Java编译器会自动根据`PersonFactory.create`方法的参数类型来选择合适的构造函数。
+
+### Lamda 表达式作用域(Lambda Scopes)
+
+#### 访问局部变量
+
+我们可以直接在 lambda 表达式中访问外部的局部变量：
+
+```java
+final int num = 1;
+Converter stringConverter =
+ (from) -> String.valueOf(from + num);
+
+stringConverter.convert(2); // 3
+```
+
+但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确：
+
+```java
+int num = 1;
+Converter stringConverter =
+ (from) -> String.valueOf(from + num);
+
+stringConverter.convert(2); // 3
+```
+
+不过这里的 num 必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译：
+
+```java
+int num = 1;
+Converter stringConverter =
+ (from) -> String.valueOf(from + num);
+num = 3;//在lambda表达式中试图修改num同样是不允许的。
+```
+
+#### 访问字段和静态变量
+
+与局部变量相比，我们对lambda表达式中的实例字段和静态变量都有读写访问权限。 该行为和匿名对象是一致的。
+
+```java
+class Lambda4 {
+ static int outerStaticNum;
+ int outerNum;
+
+ void testScopes() {
+ Converter stringConverter1 = (from) -> {
+ outerNum = 23;
+ return String.valueOf(from);
+ };
+
+ Converter stringConverter2 = (from) -> {
+ outerStaticNum = 72;
+ return String.valueOf(from);
+ };
+ }
+}
+```
+
+#### 访问默认接口方法
+
+还记得第一节中的 formula 示例吗？ `Formula` 接口定义了一个默认方法`sqrt`，可以从包含匿名对象的每个 formula 实例访问该方法。 这不适用于lambda表达式。
+
+无法从 lambda 表达式中访问默认方法,故以下代码无法编译：
+
+```java
+Formula formula = (a) -> sqrt(a * 100);
+```
+
+### 内置函数式接口(Built-in Functional Interfaces)
+
+JDK 1.8 API包含许多内置函数式接口。 其中一些借口在老版本的 Java 中是比较常见的比如： `Comparator` 或`Runnable`，这些接口都增加了`@FunctionalInterface`注解以便能用在 lambda 表达式上。
+
+但是 Java 8 API 同样还提供了很多全新的函数式接口来让你的编程工作更加方便，有一些接口是来自 [Google Guava](https://code.google.com/p/guava-libraries/) 库里的，即便你对这些很熟悉了，还是有必要看看这些是如何扩展到lambda上使用的。
+
+#### Predicates
+
+Predicate 接口是只有一个参数的返回布尔类型值的 **断言型** 接口。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）：
+
+**译者注：** Predicate 接口源码如下
+
+```java
+package java.util.function;
+import java.util.Objects;
+
+@FunctionalInterface
+public interface Predicate {
+
+ // 该方法是接受一个传入类型,返回一个布尔值.此方法应用于判断.
+ boolean test(T t);
+
+ //and方法与关系型运算符"&&"相似，两边都成立才返回true
+ default Predicate and(Predicate other) {
+ Objects.requireNonNull(other);
+ return (t) -> test(t) && other.test(t);
+ }
+ // 与关系运算符"!"相似，对判断进行取反
+ default Predicate negate() {
+ return (t) -> !test(t);
+ }
+ //or方法与关系型运算符"||"相似，两边只要有一个成立就返回true
+ default Predicate or(Predicate other) {
+ Objects.requireNonNull(other);
+ return (t) -> test(t) || other.test(t);
+ }
+ // 该方法接收一个Object对象,返回一个Predicate类型.此方法用于判断第一个test的方法与第二个test方法相同(equal).
+ static Predicate isEqual(Object targetRef) {
+ return (null == targetRef)
+ ? Objects::isNull
+ : object -> targetRef.equals(object);
+ }
+```
+
+示例：
+
+```java
+Predicate predicate = (s) -> s.length() > 0;
+
+predicate.test("foo"); // true
+predicate.negate().test("foo"); // false
+
+Predicate nonNull = Objects::nonNull;
+Predicate isNull = Objects::isNull;
+
+Predicate isEmpty = String::isEmpty;
+Predicate isNotEmpty = isEmpty.negate();
+```
+
+#### Functions
+
+Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起（compose, andThen）：
+
+**译者注：** Function 接口源码如下
+
+```java
+
+package java.util.function;
+
+import java.util.Objects;
+
+@FunctionalInterface
+public interface Function {
+
+ //将Function对象应用到输入的参数上，然后返回计算结果。
+ R apply(T t);
+ //将两个Function整合，并返回一个能够执行两个Function对象功能的Function对象。
+ default Function compose(Function before) {
+ Objects.requireNonNull(before);
+ return (V v) -> apply(before.apply(v));
+ }
+ //
+ default Function andThen(Function after) {
+ Objects.requireNonNull(after);
+ return (T t) -> after.apply(apply(t));
+ }
+
+ static Function identity() {
+ return t -> t;
+ }
+}
+```
+
+
+
+```java
+Function toInteger = Integer::valueOf;
+Function backToString = toInteger.andThen(String::valueOf);
+backToString.apply("123"); // "123"
+```
+
+#### Suppliers
+
+Supplier 接口产生给定泛型类型的结果。 与 Function 接口不同，Supplier 接口不接受参数。
+
+```java
+Supplier personSupplier = Person::new;
+personSupplier.get(); // new Person
+```
+
+#### Consumers
+
+Consumer 接口表示要对单个输入参数执行的操作。
+
+```java
+Consumer greeter = (p) -> System.out.println("Hello, " + p.firstName);
+greeter.accept(new Person("Luke", "Skywalker"));
+```
+
+#### Comparators
+
+Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法：
+
+```java
+Comparator comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
+
+Person p1 = new Person("John", "Doe");
+Person p2 = new Person("Alice", "Wonderland");
+
+comparator.compare(p1, p2); // > 0
+comparator.reversed().compare(p1, p2); // < 0
+```
+
+## Optionals
+
+Optionals不是函数式接口，而是用于防止 NullPointerException 的漂亮工具。这是下一节的一个重要概念，让我们快速了解一下Optionals的工作原理。
+
+Optional 是一个简单的容器，其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象但是有时却什么也没有返回，而在Java 8中，你应该返回 Optional 而不是 null。
+
+译者注：示例中每个方法的作用已经添加。
+
+```java
+//of（）：为非null的值创建一个Optional
+Optional optional = Optional.of("bam");
+// isPresent（）： 如果值存在返回true，否则返回false
+optional.isPresent(); // true
+//get()：如果Optional有值则将其返回，否则抛出NoSuchElementException
+optional.get(); // "bam"
+//orElse（）：如果有值则将其返回，否则返回指定的其它值
+optional.orElse("fallback"); // "bam"
+//ifPresent（）：如果Optional实例有值则为其调用consumer，否则不做处理
+optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
+```
+
+推荐阅读：[[Java8]如何正确使用Optional](https://blog.kaaass.net/archives/764)
+
+## Streams(流)
+
+`java.util.Stream` 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如` java.util.Collection` 的子类，List 或者 Set， Map 不支持。Stream 的操作可以串行执行或者并行执行。
+
+首先看看Stream是怎么用，首先创建实例代码的用到的数据List：
+
+```java
+List stringCollection = new ArrayList<>();
+stringCollection.add("ddd2");
+stringCollection.add("aaa2");
+stringCollection.add("bbb1");
+stringCollection.add("aaa1");
+stringCollection.add("bbb3");
+stringCollection.add("ccc");
+stringCollection.add("bbb2");
+stringCollection.add("ddd1");
+```
+
+Java 8扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。下面几节将详细解释常用的Stream操作：
+
+### Filter(过滤)
+
+过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于**中间操作**，所以我们可以在过滤后的结果来应用其他Stream操作（比如forEach）。forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行其他Stream操作。
+
+```java
+ // 测试 Filter(过滤)
+ stringList
+ .stream()
+ .filter((s) -> s.startsWith("a"))
+ .forEach(System.out::println);//aaa2 aaa1
+```
+
+forEach 是为 Lambda 而设计的，保持了最紧凑的风格。而且 Lambda 表达式本身是可以重用的，非常方便。
+
+### Sorted(排序)
+
+排序是一个 **中间操作**，返回的是排序好后的 Stream。**如果你不指定一个自定义的 Comparator 则会使用默认排序。**
+
+```java
+ // 测试 Sort (排序)
+ stringList
+ .stream()
+ .sorted()
+ .filter((s) -> s.startsWith("a"))
+ .forEach(System.out::println);// aaa1 aaa2
+```
+
+需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，排序之后原数据stringCollection是不会被修改的：
+
+```java
+ System.out.println(stringList);// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
+```
+
+### Map(映射)
+
+中间操作 map 会将元素根据指定的 Function 接口来依次将元素转成另外的对象。
+
+下面的示例展示了将字符串转换为大写字符串。你也可以通过map来讲对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。
+
+```java
+ // 测试 Map 操作
+ stringList
+ .stream()
+ .map(String::toUpperCase)
+ .sorted((a, b) -> b.compareTo(a))
+ .forEach(System.out::println);// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
+```
+
+
+
+### Match(匹配)
+
+Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是 **最终操作** ，并返回一个 boolean 类型的值。
+
+```java
+ // 测试 Match (匹配)操作
+ boolean anyStartsWithA =
+ stringList
+ .stream()
+ .anyMatch((s) -> s.startsWith("a"));
+ System.out.println(anyStartsWithA); // true
+
+ boolean allStartsWithA =
+ stringList
+ .stream()
+ .allMatch((s) -> s.startsWith("a"));
+
+ System.out.println(allStartsWithA); // false
+
+ boolean noneStartsWithZ =
+ stringList
+ .stream()
+ .noneMatch((s) -> s.startsWith("z"));
+
+ System.out.println(noneStartsWithZ); // true
+```
+
+
+
+### Count(计数)
+
+计数是一个 **最终操作**，返回Stream中元素的个数，**返回值类型是 long**。
+
+```java
+ //测试 Count (计数)操作
+ long startsWithB =
+ stringList
+ .stream()
+ .filter((s) -> s.startsWith("b"))
+ .count();
+ System.out.println(startsWithB); // 3
+```
+
+### Reduce(规约)
+
+这是一个 **最终操作** ，允许通过指定的函数来讲stream中的多个元素规约为一个元素，规约后的结果是通过Optional 接口表示的：
+
+```java
+ //测试 Reduce (规约)操作
+ Optional reduced =
+ stringList
+ .stream()
+ .sorted()
+ .reduce((s1, s2) -> s1 + "#" + s2);
+
+ reduced.ifPresent(System.out::println);//aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2
+```
+
+
+
+**译者注：** 这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相当于`Integer sum = integers.reduce(0, (a, b) -> a+b);`也有没有起始值的情况，这时会把 Stream 的前面两个元素组合起来，返回的是 Optional。
+
+```java
+// 字符串连接，concat = "ABCD"
+String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
+// 求最小值，minValue = -3.0
+double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
+// 求和，sumValue = 10, 有起始值
+int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
+// 求和，sumValue = 10, 无起始值
+sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
+// 过滤，字符串连接，concat = "ace"
+concat = Stream.of("a", "B", "c", "D", "e", "F").
+ filter(x -> x.compareTo("Z") > 0).
+ reduce("", String::concat);
+```
+
+上面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，请留意这个区别。更多内容查看： [IBM：Java 8 中的 Streams API 详解](https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html)
+
+## Parallel Streams(并行流)
+
+前面提到过Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。
+
+下面的例子展示了是如何通过并行Stream来提升性能：
+
+首先我们创建一个没有重复元素的大表：
+
+```java
+int max = 1000000;
+List values = new ArrayList<>(max);
+for (int i = 0; i < max; i++) {
+ UUID uuid = UUID.randomUUID();
+ values.add(uuid.toString());
+}
+```
+
+我们分别用串行和并行两种方式对其进行排序，最后看看所用时间的对比。
+
+### Sequential Sort(串行排序)
+
+```java
+//串行排序
+long t0 = System.nanoTime();
+long count = values.stream().sorted().count();
+System.out.println(count);
+
+long t1 = System.nanoTime();
+
+long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
+System.out.println(String.format("sequential sort took: %d ms", millis));
+```
+
+```
+1000000
+sequential sort took: 709 ms//串行排序所用的时间
+```
+
+### Parallel Sort(并行排序)
+
+```java
+//并行排序
+long t0 = System.nanoTime();
+
+long count = values.parallelStream().sorted().count();
+System.out.println(count);
+
+long t1 = System.nanoTime();
+
+long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
+System.out.println(String.format("parallel sort took: %d ms", millis));
+
+```
+
+```java
+1000000
+parallel sort took: 475 ms//串行排序所用的时间
+```
+
+上面两个代码几乎是一样的，但是并行版的快了 50% 左右，唯一需要做的改动就是将 `stream()` 改为`parallelStream()`。
+
+## Maps
+
+前面提到过，Map 类型不支持 streams，不过Map提供了一些新的有用的方法来处理一些日常任务。Map接口本身没有可用的 `stream（）`方法，但是你可以在键，值上创建专门的流或者通过 `map.keySet().stream()`,`map.values().stream()`和`map.entrySet().stream()`。
+
+此外,Maps 支持各种新的和有用的方法来执行常见任务。
+
+```java
+Map map = new HashMap<>();
+
+for (int i = 0; i < 10; i++) {
+ map.putIfAbsent(i, "val" + i);
+}
+
+map.forEach((id, val) -> System.out.println(val));//val0 val1 val2 val3 val4 val5 val6 val7 val8 val9
+```
+
+`putIfAbsent` 阻止我们在null检查时写入额外的代码;`forEach`接受一个 consumer 来对 map 中的每个元素操作。
+
+此示例显示如何使用函数在 map 上计算代码：
+
+```java
+map.computeIfPresent(3, (num, val) -> val + num);
+map.get(3); // val33
+
+map.computeIfPresent(9, (num, val) -> null);
+map.containsKey(9); // false
+
+map.computeIfAbsent(23, num -> "val" + num);
+map.containsKey(23); // true
+
+map.computeIfAbsent(3, num -> "bam");
+map.get(3); // val33
+```
+
+接下来展示如何在Map里删除一个键值全都匹配的项：
+
+```java
+map.remove(3, "val3");
+map.get(3); // val33
+map.remove(3, "val33");
+map.get(3); // null
+```
+
+另外一个有用的方法：
+
+```java
+map.getOrDefault(42, "not found"); // not found
+```
+
+对Map的元素做合并也变得很容易了：
+
+```java
+map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
+map.get(9); // val9
+map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
+map.get(9); // val9concat
+```
+
+Merge 做的事情是如果键名不存在则插入，否则则对原键对应的值做合并操作并重新插入到map中。
+
+## Date API(日期相关API)
+
+Java 8在 `java.time` 包下包含一个全新的日期和时间API。新的Date API与Joda-Time库相似，但它们不一样。以下示例涵盖了此新 API 的最重要部分。译者对这部分内容参考相关书籍做了大部分修改。
+
+**译者注(总结)：**
+
+- Clock 类提供了访问当前日期和时间的方法，Clock 是时区敏感的，可以用来取代 `System.currentTimeMillis()` 来获取当前的微秒数。某一个特定的时间点也可以使用 `Instant` 类来表示，`Instant` 类也可以用来创建旧版本的`java.util.Date` 对象。
+
+- 在新API中时区使用 ZoneId 来表示。时区可以很方便的使用静态方法of来获取到。 抽象类`ZoneId`（在`java.time`包中）表示一个区域标识符。 它有一个名为`getAvailableZoneIds`的静态方法，它返回所有区域标识符。
+
+- jdk1.8中新增了 LocalDate 与 LocalDateTime等类来解决日期处理方法，同时引入了一个新的类DateTimeFormatter 来解决日期格式化问题。可以使用Instant代替 Date，LocalDateTime代替 Calendar，DateTimeFormatter 代替 SimpleDateFormat。
+
+
+
+### Clock
+
+Clock 类提供了访问当前日期和时间的方法，Clock 是时区敏感的，可以用来取代 `System.currentTimeMillis()` 来获取当前的微秒数。某一个特定的时间点也可以使用 `Instant` 类来表示，`Instant` 类也可以用来创建旧版本的`java.util.Date` 对象。
+
+```java
+Clock clock = Clock.systemDefaultZone();
+long millis = clock.millis();
+System.out.println(millis);//1552379579043
+Instant instant = clock.instant();
+System.out.println(instant);
+Date legacyDate = Date.from(instant); //2019-03-12T08:46:42.588Z
+System.out.println(legacyDate);//Tue Mar 12 16:32:59 CST 2019
+```
+
+### Timezones(时区)
+
+在新API中时区使用 ZoneId 来表示。时区可以很方便的使用静态方法of来获取到。 抽象类`ZoneId`（在`java.time`包中）表示一个区域标识符。 它有一个名为`getAvailableZoneIds`的静态方法，它返回所有区域标识符。
+
+```java
+//输出所有区域标识符
+System.out.println(ZoneId.getAvailableZoneIds());
+
+ZoneId zone1 = ZoneId.of("Europe/Berlin");
+ZoneId zone2 = ZoneId.of("Brazil/East");
+System.out.println(zone1.getRules());// ZoneRules[currentStandardOffset=+01:00]
+System.out.println(zone2.getRules());// ZoneRules[currentStandardOffset=-03:00]
+```
+
+### LocalTime(本地时间)
+
+LocalTime 定义了一个没有时区信息的时间，例如 晚上10点或者 17:30:15。下面的例子使用前面代码创建的时区创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差：
+
+```java
+LocalTime now1 = LocalTime.now(zone1);
+LocalTime now2 = LocalTime.now(zone2);
+System.out.println(now1.isBefore(now2)); // false
+
+long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
+long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
+
+System.out.println(hoursBetween); // -3
+System.out.println(minutesBetween); // -239
+```
+
+LocalTime 提供了多种工厂方法来简化对象的创建，包括解析时间字符串.
+
+```java
+LocalTime late = LocalTime.of(23, 59, 59);
+System.out.println(late); // 23:59:59
+DateTimeFormatter germanFormatter =
+ DateTimeFormatter
+ .ofLocalizedTime(FormatStyle.SHORT)
+ .withLocale(Locale.GERMAN);
+
+LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
+System.out.println(leetTime); // 13:37
+```
+
+### LocalDate(本地日期)
+
+LocalDate 表示了一个确切的日期，比如 2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的，操作返回的总是一个新实例。
+
+```java
+LocalDate today = LocalDate.now();//获取现在的日期
+System.out.println("今天的日期: "+today);//2019-03-12
+LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
+System.out.println("明天的日期: "+tomorrow);//2019-03-13
+LocalDate yesterday = tomorrow.minusDays(2);
+System.out.println("昨天的日期: "+yesterday);//2019-03-11
+LocalDate independenceDay = LocalDate.of(2019, Month.MARCH, 12);
+DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
+System.out.println("今天是周几:"+dayOfWeek);//TUESDAY
+```
+
+从字符串解析一个 LocalDate 类型和解析 LocalTime 一样简单,下面是使用 `DateTimeFormatter` 解析字符串的例子：
+
+```java
+ String str1 = "2014==04==12 01时06分09秒";
+ // 根据需要解析的日期、时间字符串定义解析所用的格式器
+ DateTimeFormatter fomatter1 = DateTimeFormatter
+ .ofPattern("yyyy==MM==dd HH时mm分ss秒");
+
+ LocalDateTime dt1 = LocalDateTime.parse(str1, fomatter1);
+ System.out.println(dt1); // 输出 2014-04-12T01:06:09
+
+ String str2 = "2014$$$四月$$$13 20小时";
+ DateTimeFormatter fomatter2 = DateTimeFormatter
+ .ofPattern("yyy$$$MMM$$$dd HH小时");
+ LocalDateTime dt2 = LocalDateTime.parse(str2, fomatter2);
+ System.out.println(dt2); // 输出 2014-04-13T20:00
+
+```
+
+再来看一个使用 `DateTimeFormatter` 格式化日期的示例
+
+```java
+LocalDateTime rightNow=LocalDateTime.now();
+String date=DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(rightNow);
+System.out.println(date);//2019-03-12T16:26:48.29
+DateTimeFormatter formatter=DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss");
+System.out.println(formatter.format(rightNow));//2019-03-12 16:26:48
+```
+
+### LocalDateTime(本地日期时间)
+
+LocalDateTime 同时表示了时间和日期，相当于前两节内容合并到一个对象上了。LocalDateTime 和 LocalTime还有 LocalDate 一样，都是不可变的。LocalDateTime 提供了一些能访问具体字段的方法。
+
+```java
+LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
+
+DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
+System.out.println(dayOfWeek); // WEDNESDAY
+
+Month month = sylvester.getMonth();
+System.out.println(month); // DECEMBER
+
+long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
+System.out.println(minuteOfDay); // 1439
+```
+
+只要附加上时区信息，就可以将其转换为一个时间点Instant对象，Instant时间点对象可以很容易的转换为老式的`java.util.Date`。
+
+```java
+Instant instant = sylvester
+ .atZone(ZoneId.systemDefault())
+ .toInstant();
+
+Date legacyDate = Date.from(instant);
+System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014
+```
+
+格式化LocalDateTime和格式化时间和日期一样的，除了使用预定义好的格式外，我们也可以自己定义格式：
+
+```java
+DateTimeFormatter formatter =
+ DateTimeFormatter
+ .ofPattern("MMM dd, yyyy - HH:mm");
+LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
+String string = formatter.format(parsed);
+System.out.println(string); // Nov 03, 2014 - 07:13
+```
+
+和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的，所以它是线程安全的。
+关于时间日期格式的详细信息在[这里](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)。
+
+## Annotations(注解)
+
+在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。
+首先定义一个包装类Hints注解用来放置一组具体的Hint注解：
+
+```java
+@interface Hints {
+ Hint[] value();
+}
+@Repeatable(Hints.class)
+@interface Hint {
+ String value();
+}
+```
+
+Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下`@Repeatable`即可。
+
+例 1: 使用包装类当容器来存多个注解（老方法）
+
+```java
+@Hints({@Hint("hint1"), @Hint("hint2")})
+class Person {}
+```
+
+例 2：使用多重注解（新方法）
+
+```java
+@Hint("hint1")
+@Hint("hint2")
+class Person {}
+```
+
+第二个例子里java编译器会隐性的帮你定义好@Hints注解，了解这一点有助于你用反射来获取这些信息：
+
+```java
+Hint hint = Person.class.getAnnotation(Hint.class);
+System.out.println(hint); // null
+Hints hints1 = Person.class.getAnnotation(Hints.class);
+System.out.println(hints1.value().length); // 2
+
+Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
+System.out.println(hints2.length); // 2
+```
+
+即便我们没有在 `Person`类上定义 `@Hints`注解，我们还是可以通过 `getAnnotation(Hints.class) `来获取 `@Hints`注解，更加方便的方法是使用 `getAnnotationsByType` 可以直接获取到所有的`@Hint`注解。
+另外Java 8的注解还增加到两种新的target上了：
+
+```java
+@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
+@interface MyAnnotation {}
+```
+
+
+
+## Whete to go from here?
+
+关于Java 8的新特性就写到这了，肯定还有更多的特性等待发掘。JDK 1.8里还有很多很有用的东西，比如`Arrays.parallelSort`, `StampedLock`和`CompletableFuture`等等。
+
diff --git "a/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md" "b/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md"
new file mode 100644
index 00000000000..43e4539ccac
--- /dev/null
+++ "b/docs/java/What's New in JDK8/Java8\346\225\231\347\250\213\346\216\250\350\215\220.md"
@@ -0,0 +1,20 @@
+
+
+### 书籍
+
+- **《Java8 In Action》**
+- **《写给大忙人看的Java SE 8》**
+
+上述书籍的PDF版本见 https://shimo.im/docs/CPB0PK05rP4CFmI2/ 中的 “Java 书籍推荐”。
+
+### 开源文档
+
+- **【译】Java 8 简明教程**：
+- **30 seconds of java8:**
+
+### 视频
+
+- **尚硅谷 Java 8 新特性**
+
+视频资源见： https://shimo.im/docs/CPB0PK05rP4CFmI2/ 。
+
diff --git "a/docs/java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/docs/java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md"
new file mode 100644
index 00000000000..359c4714473
--- /dev/null
+++ "b/docs/java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md"
@@ -0,0 +1,235 @@
+JDK8--Lambda表达式
+===
+## 1.什么是Lambda表达式
+**Lambda表达式实质上是一个可传递的代码块，Lambda又称为闭包或者匿名函数，是函数式编程语法，让方法可以像普通参数一样传递**
+
+## 2.Lambda表达式语法
+```(参数列表) -> {执行代码块}```
+
参数列表可以为空```()->{}```
+
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值.
+
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}```
+
(lambda有点像动态类型语言语法。lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言)
+
+## 3.函数式接口
+在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
+**函数式接口指的是有且只有一个抽象(abstract)方法的接口**
+当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子:
+
+```java
+ Thread thread = new Thread(() -> {
+ System.out.println("This is JDK8's Lambda!");
+ });
+```
+这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？
+```java
+public Thread(Runnable target) {...}
+
+/**
+ * Runnable Interface
+ */
+@FunctionalInterface
+public interface Runnable {
+ public abstract void run();
+}
+```
+到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于
+```java
+ Thread thread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ System.out.println("Anonymous class");
+ }
+ });
+```
+也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都
+由编译器帮我们推断，因此可以减少很多代码量)。
+
Lambda也可以这样用 :
+```java
+ Runnable runnable = () -> {...};
+```
+其实这和上面的用法没有什么本质上的区别。
+
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范，
+目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了，
+因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]()
+
+除了上面说的Runnable接口之外，JDK中已经存在了很多函数式接口
+比如(当然不止这些):
+- ```java.util.concurrent.Callable```
+- ```java.util.Comparator```
+- ```java.io.FileFilter```
+
**关于JDK中的预定义的函数式接口**
+
+- JDK在```java.util.function```下预定义了很多函数式接口
+ - ```Function {R apply(T t);}``` 接受一个T对象，然后返回一个R对象，就像普通的函数。
+ - ```Consumer {void accept(T t);}``` 消费者 接受一个T对象，没有返回值。
+ - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。
+ - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。
+ - 其他的跟上面的相似，大家可以看一下function包下的具体接口。
+## 4.变量作用域
+```java
+public class VaraibleHide {
+ @FunctionalInterface
+ interface IInner {
+ void printInt(int x);
+ }
+ public static void main(String[] args) {
+ int x = 20;
+ IInner inner = new IInner() {
+ int x = 10;
+ @Override
+ public void printInt(int x) {
+ System.out.println(x);
+ }
+ };
+ inner.printInt(30);
+
+ inner = (s) -> {
+ //Variable used in lambda expression should be final or effectively final
+ //!int x = 10;
+ //!x= 50; error
+ System.out.print(x);
+ };
+ inner.printInt(30);
+ }
+}
+输出 :
+30
+20
+```
+对于lambda表达式```java inner = (s) -> {System.out.print(x);};```,变量x并不是在lambda表达式中定义的，像这样并不是在lambda中定义或者通过lambda的参数列表()获取的变量成为自由变量，它是被lambda表达式捕获的。
+
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值，
+同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该
+不难理解。
+## 5.方法引用
+**只需要提供方法的名字，具体的调用过程由Lambda和函数式接口来确定，这样的方法调用成为方法引用。**
+
下面的例子会打印list中的每个元素:
+```java
+List list = new ArrayList<>();
+ for (int i = 0; i < 10; ++i) {
+ list.add(i);
+ }
+ list.forEach(System.out::println);
+```
+其中```System.out::println```这个就是一个方法引用，等价于Lambda表达式 ```(para)->{System.out.println(para);}```
+
我们看一下List#forEach方法 ```default void forEach(Consumer action)```可以看到它的参数是一个Consumer接口，该接口是一个函数式接口
+```java
+@FunctionalInterface
+public interface Consumer {
+ void accept(T t);
+```
+大家能发现这个函数接口的方法和```System.out::println```有什么相似的么？没错，它们有着相似的参数列表和返回值。
+
我们自己定义一个方法，看看能不能像标准输出的打印函数一样被调用
+```java
+public class MethodReference {
+ public static void main(String[] args) {
+ List list = new ArrayList<>();
+ for (int i = 0; i < 10; ++i) {
+ list.add(i);
+ }
+ list.forEach(MethodReference::myPrint);
+ }
+
+ static void myPrint(int i) {
+ System.out.print(i + ", ");
+ }
+}
+
+输出: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+```
+可以看到，我们自己定义的方法也可以当做方法引用。
+
到这里大家多少对方法引用有了一定的了解，我们再来说一下方法引用的形式。
+- 方法引用
+ - 类名::静态方法名
+ - 类名::实例方法名
+ - 类名::new (构造方法引用)
+ - 实例名::实例方法名
+可以看出，方法引用是通过(方法归属名)::(方法名)来调用的。通过上面的例子已经讲解了一个`类名::静态方法名`的使用方法了，下面再依次介绍其余的几种
+方法引用的使用方法。
+**类名::实例方法名**
+先来看一段代码
+```java
+ String[] strings = new String[10];
+ Arrays.sort(strings, String::compareToIgnoreCase);
+```
+**上面的String::compareToIgnoreCase等价于(x, y) -> {return x.compareToIgnoreCase(y);}**
+我们看一下`Arrays#sort`方法`public static void sort(T[] a, Comparator c)`,
+可以看到第二个参数是一个Comparator接口，该接口也是一个函数式接口，其中的抽象方法是`int compare(T o1, T o2);`，再看一下
+`String#compareToIgnoreCase`方法,`public int compareToIgnoreCase(String str)`，这个方法好像和上面讲方法引用中`类名::静态方法名`不大一样啊，它
+的参数列表和函数式接口的参数列表不一样啊，虽然它的返回值一样？
+
是的，确实不一样但是别忘了，String类的这个方法是个实例方法，而不是静态方法，也就是说，这个方法是需要有一个接收者的。所谓接收者就是
+instance.method(x)中的instance，
+它是某个类的实例，有的朋友可能已经明白了。上面函数式接口的`compare(T o1, T o2)`中的第一个参数作为了实例方法的接收者，而第二个参数作为了实例方法的
+参数。我们再举一个自己实现的例子:
+```java
+public class MethodReference {
+ static Random random = new Random(47);
+ public static void main(String[] args) {
+ MethodReference[] methodReferences = new MethodReference[10];
+ Arrays.sort(methodReferences, MethodReference::myCompare);
+ }
+ int myCompare(MethodReference o) {
+ return random.nextInt(2) - 1;
+ }
+}
+```
+上面的例子可以在IDE里通过编译，大家有兴趣的可以模仿上面的例子自己写一个程序，打印出排序后的结果。
+
**构造器引用**
+构造器引用仍然需要与特定的函数式接口配合使用，并不能像下面这样直接使用。IDE会提示String不是一个函数式接口
+```java
+ //compile error : String is not a functional interface
+ String str = String::new;
+```
+下面是一个使用构造器引用的例子，可以看出构造器引用可以和这种工厂型的函数式接口一起使用的。
+```java
+ interface IFunctional {
+ T func();
+}
+
+public class ConstructorReference {
+
+ public ConstructorReference() {
+ }
+
+ public static void main(String[] args) {
+ Supplier supplier0 = () -> new ConstructorReference();
+ Supplier supplier1 = ConstructorReference::new;
+ IFunctional functional = () -> new ConstructorReference();
+ IFunctional functional1 = ConstructorReference::new;
+ }
+}
+```
+下面是一个JDK官方的例子
+```java
+ public static , DEST extends Collection>
+ DEST transferElements(
+ SOURCE sourceCollection,
+ Supplier collectionFactory) {
+
+ DEST result = collectionFactory.get();
+ for (T t : sourceCollection) {
+ result.add(t);
+ }
+ return result;
+ }
+
+ ...
+
+ Set rosterSet = transferElements(
+ roster, HashSet::new);
+```
+
+**实例::实例方法**
+
+其实开始那个例子就是一个实例::实例方法的引用
+```java
+List list = new ArrayList<>();
+ for (int i = 0; i < 10; ++i) {
+ list.add(i);
+ }
+ list.forEach(System.out::println);
+```
+其中System.out就是一个实例，println是一个实例方法。相信不用再给大家做解释了。
+## 总结
+Lambda表达式是JDK8引入Java的函数式编程语法，使用Lambda需要直接或者间接的与函数式接口配合，在开发中使用Lambda可以减少代码量，
+但是并不是说必须要使用Lambda(虽然它是一个很酷的东西)。有些情况下使用Lambda会使代码的可读性急剧下降，并且也节省不了多少代码，
+所以在实际开发中还是需要仔细斟酌是否要使用Lambda。和Lambda相似的还有JDK10中加入的var类型推断，同样对于这个特性需要斟酌使用。
diff --git a/docs/java/What's New in JDK8/README.md b/docs/java/What's New in JDK8/README.md
new file mode 100644
index 00000000000..fa71e907410
--- /dev/null
+++ b/docs/java/What's New in JDK8/README.md
@@ -0,0 +1,556 @@
+JDK8新特性总结
+======
+总结了部分JDK8新特性，另外一些新特性可以通过Oracle的官方文档查看，毕竟是官方文档，各种新特性都会介绍，有兴趣的可以去看。
+[Oracle官方文档:What's New in JDK8](https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html)
+-----
+- [Java语言特性](#JavaProgrammingLanguage)
+ - [Lambda表达式是一个新的语言特性，已经在JDK8中加入。它是一个可以传递的代码块，你也可以把它们当做方法参数。
+ Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。](#LambdaExpressions)
+
+ - [方法引用为已经存在的具名方法提供易于阅读的Lambda表达式](#MethodReferences)
+
+ - [默认方法允许将新功能添加到库的接口，并确保与为这些接口的旧版本编写的代码的二进制兼容性。](#DefaultMethods)
+
+ - [改进的类型推断。](#ImprovedTypeInference)
+
+ - [方法参数反射(通过反射获得方法参数信息)](#MethodParameterReflection)
+
+- [流(stream)](#stream)
+ - [新java.util.stream包中的类提供Stream API以支持对元素流的功能样式操作。流(stream)和I/O里的流不是同一个概念
+ ，使用stream API可以更方便的操作集合。]()
+
+- [国际化]()
+ - 待办
+- 待办
+___
+
+
+
+
+
+
+
+## Lambda表达式
+### 1.什么是Lambda表达式
+**Lambda表达式实质上是一个可传递的代码块，Lambda又称为闭包或者匿名函数，是函数式编程语法，让方法可以像普通参数一样传递**
+
+### 2.Lambda表达式语法
+```(参数列表) -> {执行代码块}```
+
参数列表可以为空```()->{}```
+
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值.
+
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}```
+
(lambda有点像动态类型语言语法。lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言)
+
+### 3.函数式接口
+在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
+**函数式接口指的是有且只有一个抽象(abstract)方法的接口**
+当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子:
+
+```java
+ Thread thread = new Thread(() -> {
+ System.out.println("This is JDK8's Lambda!");
+ });
+```
+这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？
+```java
+public Thread(Runnable target) {...}
+
+/**
+ * Runnable Interface
+ */
+@FunctionalInterface
+public interface Runnable {
+ public abstract void run();
+}
+```
+到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于
+```java
+ Thread thread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ System.out.println("Anonymous class");
+ }
+ });
+```
+也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都
+由编译器帮我们推断，因此可以减少很多代码量)。
+
Lambda也可以这样用 :
+```java
+ Runnable runnable = () -> {...};
+```
+其实这和上面的用法没有什么本质上的区别。
+
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范，
+目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了，
+因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]()
+
+除了上面说的Runnable接口之外，JDK中已经存在了很多函数式接口
+比如(当然不止这些):
+- ```java.util.concurrent.Callable```
+- ```java.util.Comparator```
+- ```java.io.FileFilter```
+
**关于JDK中的预定义的函数式接口**
+
+- JDK在```java.util.function```下预定义了很多函数式接口
+ - ```Function {R apply(T t);}``` 接受一个T对象，然后返回一个R对象，就像普通的函数。
+ - ```Consumer {void accept(T t);}``` 消费者 接受一个T对象，没有返回值。
+ - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。
+ - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。
+ - 其他的跟上面的相似，大家可以看一下function包下的具体接口。
+### 4.变量作用域
+```java
+public class VaraibleHide {
+ @FunctionalInterface
+ interface IInner {
+ void printInt(int x);
+ }
+ public static void main(String[] args) {
+ int x = 20;
+ IInner inner = new IInner() {
+ int x = 10;
+ @Override
+ public void printInt(int x) {
+ System.out.println(x);
+ }
+ };
+ inner.printInt(30);
+
+ inner = (s) -> {
+ //Variable used in lambda expression should be final or effectively final
+ //!int x = 10;
+ //!x= 50; error
+ System.out.print(x);
+ };
+ inner.printInt(30);
+ }
+}
+输出 :
+30
+20
+```
+对于lambda表达式```java inner = (s) -> {System.out.print(x);};```,变量x并不是在lambda表达式中定义的，像这样并不是在lambda中定义或者通过lambda
+的参数列表()获取的变量成为自由变量，它是被lambda表达式捕获的。
+
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值，同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该不难理解。
+
+### 5.方法引用
+**只需要提供方法的名字，具体的调用过程由Lambda和函数式接口来确定，这样的方法调用成为方法引用。**
+
下面的例子会打印list中的每个元素:
+```java
+List list = new ArrayList<>();
+ for (int i = 0; i < 10; ++i) {
+ list.add(i);
+ }
+ list.forEach(System.out::println);
+```
+其中```System.out::println```这个就是一个方法引用，等价于Lambda表达式 ```(para)->{System.out.println(para);}```
+
我们看一下List#forEach方法 ```default void forEach(Consumer action)```可以看到它的参数是一个Consumer接口，该接口是一个函数式接口
+```java
+@FunctionalInterface
+public interface Consumer {
+ void accept(T t);
+```
+大家能发现这个函数接口的方法和```System.out::println```有什么相似的么？没错，它们有着相似的参数列表和返回值。
+
我们自己定义一个方法，看看能不能像标准输出的打印函数一样被调用
+```java
+public class MethodReference {
+ public static void main(String[] args) {
+ List list = new ArrayList<>();
+ for (int i = 0; i < 10; ++i) {
+ list.add(i);
+ }
+ list.forEach(MethodReference::myPrint);
+ }
+
+ static void myPrint(int i) {
+ System.out.print(i + ", ");
+ }
+}
+
+输出: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+```
+可以看到，我们自己定义的方法也可以当做方法引用。
+
到这里大家多少对方法引用有了一定的了解，我们再来说一下方法引用的形式。
+- 方法引用
+ - 类名::静态方法名
+ - 类名::实例方法名
+ - 类名::new (构造方法引用)
+ - 实例名::实例方法名
+可以看出，方法引用是通过(方法归属名)::(方法名)来调用的。通过上面的例子已经讲解了一个`类名::静态方法名`的使用方法了，下面再依次介绍其余的几种
+方法引用的使用方法。
+**类名::实例方法名**
+先来看一段代码
+```java
+ String[] strings = new String[10];
+ Arrays.sort(strings, String::compareToIgnoreCase);
+```
+**上面的String::compareToIgnoreCase等价于(x, y) -> {return x.compareToIgnoreCase(y);}**
+我们看一下`Arrays#sort`方法`public static void sort(T[] a, Comparator c)`,
+可以看到第二个参数是一个Comparator接口，该接口也是一个函数式接口，其中的抽象方法是`int compare(T o1, T o2);`，再看一下
+`String#compareToIgnoreCase`方法,`public int compareToIgnoreCase(String str)`，这个方法好像和上面讲方法引用中`类名::静态方法名`不大一样啊，它
+的参数列表和函数式接口的参数列表不一样啊，虽然它的返回值一样？
+
是的，确实不一样但是别忘了，String类的这个方法是个实例方法，而不是静态方法，也就是说，这个方法是需要有一个接收者的。所谓接收者就是
+instance.method(x)中的instance，
+它是某个类的实例，有的朋友可能已经明白了。上面函数式接口的`compare(T o1, T o2)`中的第一个参数作为了实例方法的接收者，而第二个参数作为了实例方法的
+参数。我们再举一个自己实现的例子:
+```java
+public class MethodReference {
+ static Random random = new Random(47);
+ public static void main(String[] args) {
+ MethodReference[] methodReferences = new MethodReference[10];
+ Arrays.sort(methodReferences, MethodReference::myCompare);
+ }
+ int myCompare(MethodReference o) {
+ return random.nextInt(2) - 1;
+ }
+}
+```
+上面的例子可以在IDE里通过编译，大家有兴趣的可以模仿上面的例子自己写一个程序，打印出排序后的结果。
+
**构造器引用**
+构造器引用仍然需要与特定的函数式接口配合使用，并不能像下面这样直接使用。IDE会提示String不是一个函数式接口
+```java
+ //compile error : String is not a functional interface
+ String str = String::new;
+```
+下面是一个使用构造器引用的例子，可以看出构造器引用可以和这种工厂型的函数式接口一起使用的。
+```java
+ interface IFunctional {
+ T func();
+}
+
+public class ConstructorReference {
+
+ public ConstructorReference() {
+ }
+
+ public static void main(String[] args) {
+ Supplier supplier0 = () -> new ConstructorReference();
+ Supplier supplier1 = ConstructorReference::new;
+ IFunctional functional = () -> new ConstructorReference();
+ IFunctional functional1 = ConstructorReference::new;
+ }
+}
+```
+下面是一个JDK官方的例子
+```java
+ public static , DEST extends Collection>
+ DEST transferElements(
+ SOURCE sourceCollection,
+ Supplier collectionFactory) {
+
+ DEST result = collectionFactory.get();
+ for (T t : sourceCollection) {
+ result.add(t);
+ }
+ return result;
+ }
+
+ ...
+
+ Set rosterSet = transferElements(
+ roster, HashSet::new);
+```
+
+**实例::实例方法**
+
+其实开始那个例子就是一个实例::实例方法的引用
+```java
+List list = new ArrayList<>();
+ for (int i = 0; i < 10; ++i) {
+ list.add(i);
+ }
+ list.forEach(System.out::println);
+```
+其中System.out就是一个实例，println是一个实例方法。相信不用再给大家做解释了。
+### 总结
+Lambda表达式是JDK8引入Java的函数式编程语法，使用Lambda需要直接或者间接的与函数式接口配合，在开发中使用Lambda可以减少代码量，
+但是并不是说必须要使用Lambda(虽然它是一个很酷的东西)。有些情况下使用Lambda会使代码的可读性急剧下降，并且也节省不了多少代码，
+所以在实际开发中还是需要仔细斟酌是否要使用Lambda。和Lambda相似的还有JDK10中加入的var类型推断，同样对于这个特性需要斟酌使用。
+
+
+___
+
+
+## JDK8接口规范
+### 在JDK8中引入了lambda表达式，出现了函数式接口的概念，为了在扩展接口时保持向前兼容性(JDK8之前扩展接口会使得实现了该接口的类必须实现添加的方法，否则会报错。为了保持兼容性而做出妥协的特性还有泛型，泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)，Java接口规范发生了一些改变。
+### 1.JDK8以前的接口规范
+- JDK8以前接口可以定义的变量和方法
+ - 所有变量(Field)不论是否显式 的声明为```public static final```，它实际上都是```public static final```的。
+ - 所有方法(Method)不论是否显示 的声明为```public abstract```，它实际上都是```public abstract```的。
+```java
+public interface AInterfaceBeforeJDK8 {
+ int FIELD = 0;
+ void simpleMethod();
+}
+```
+以上接口信息反编译以后可以看到字节码信息里Filed是public static final的，而方法是public abstract的，即是你没有显示的去声明它。
+```java
+{
+ public static final int FIELD;
+ descriptor: I
+ flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
+ ConstantValue: int 0
+
+ public abstract void simpleMethod();
+ descriptor: ()V
+ flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT
+}
+```
+### 2.JDK8之后的接口规范
+- JDK8之后接口可以定义的变量和方法
+ - 变量(Field)仍然必须是 ```java public static final```的
+ - 方法(Method)除了可以是public abstract之外，还可以是public static或者是default(相当于仅public修饰的实例方法)的。
+从以上改变不难看出，修改接口的规范主要是为了能在扩展接口时保持向前兼容。
+
下面是一个JDK8之后的接口例子
+```java
+public interface AInterfaceInJDK8 {
+ int simpleFiled = 0;
+ static int staticField = 1;
+
+ public static void main(String[] args) {
+ }
+ static void staticMethod(){}
+
+ default void defaultMethod(){}
+
+ void simpleMethod() throws IOException;
+
+}
+```
+进行反编译(去除了一些没用信息)
+```java
+{
+ public static final int simpleFiled;
+ flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
+
+ public static final int staticField;
+ flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
+
+ public static void main(java.lang.String[]);
+ flags: (0x0009) ACC_PUBLIC, ACC_STATIC
+
+ public static void staticMethod();
+ flags: (0x0009) ACC_PUBLIC, ACC_STATIC
+
+ public void defaultMethod();
+ flags: (0x0001) ACC_PUBLIC
+
+ public abstract void simpleMethod() throws java.io.IOException;
+ flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT
+ Exceptions:
+ throws java.io.IOException
+}
+```
+可以看到 default关键字修饰的方法是像实例方法(就是普通类中定义的普通方法)一样定义的，所以我们来定义一个只有default方法的接口并且实现一下这个接口试一
+试。
+```java
+interface Default {
+ default int defaultMethod() {
+ return 4396;
+ }
+}
+
+public class DefaultMethod implements Default {
+ public static void main(String[] args) {
+ DefaultMethod defaultMethod = new DefaultMethod();
+ System.out.println(defaultMethod.defaultMethod());
+ //compile error : Non-static method 'defaultMethod()' cannot be referenced from a static context
+ //! DefaultMethod.defaultMethod();
+ }
+}
+```
+可以看到default方法确实像实例方法一样，必须有实例对象才能调用，并且子类在实现接口时，可以不用实现default方法，也可以选择覆盖该方法。
+这有点像子类继承父类实例方法。
+
+接口静态方法就像是类静态方法，唯一的区别是**接口静态方法只能通过接口名调用，而类静态方法既可以通过类名调用也可以通过实例调用**
+```java
+interface Static {
+ static int staticMethod() {
+ return 4396;
+ }
+}
+ ... main(String...args)
+ //!compile error: Static method may be invoked on containing interface class only
+ //!aInstanceOfStatic.staticMethod();
+ ...
+```
+另一个问题是多继承问题，大家知道Java中类是不支持多继承的，但是接口是多继承和多实现(implements后跟多个接口)的，
+那么如果一个接口继承另一个接口，两个接口都有同名的default方法会怎么样呢？答案是会像类继承一样覆写(@Override)，以下代码在IDE中可以顺利编译
+```java
+interface Default {
+ default int defaultMethod() {
+ return 4396;
+ }
+}
+interface Default2 extends Default {
+ @Override
+ default int defaultMethod() {
+ return 9527;
+ }
+}
+public class DefaultMethod implements Default,Default2 {
+ public static void main(String[] args) {
+ DefaultMethod defaultMethod = new DefaultMethod();
+ System.out.println(defaultMethod.defaultMethod());
+ }
+}
+
+输出 : 9527
+```
+出现上面的情况时，会优先找继承树上近的方法，类似于“短路优先”。
+
+那么如果一个类实现了两个没有继承关系的接口，且这两个接口有同名方法的话会怎么样呢？IDE会要求你重写这个冲突的方法，让你自己选择去执行哪个方法，因为IDE它还没智能到你不告诉它，它就知道你想执行哪个方法。可以通过```java 接口名.super```指针来访问接口中定义的实例(default)方法。
+```java
+interface Default {
+ default int defaultMethod() {
+ return 4396;
+ }
+}
+
+interface Default2 {
+ default int defaultMethod() {
+ return 9527;
+ }
+}
+//如果不重写
+//compile error : defaults.DefaultMethod inherits unrelated defaults for defaultMethod() from types defaults.Default and defaults.Default2
+public class DefaultMethod implements Default,Default2 {
+@Override
+ public int defaultMethod() {
+ System.out.println(Default.super.defaultMethod());
+ System.out.println(Default2.super.defaultMethod());
+ return 996;
+ }
+ public static void main(String[] args) {
+ DefaultMethod defaultMethod = new DefaultMethod();
+ System.out.println(defaultMethod.defaultMethod());
+ }
+}
+
+运行输出 :
+4396
+9527
+996
+```
+
+
+___
+
+
+## 改进的类型推断
+### 1.什么是类型推断
+类型推断就像它的字面意思一样，编译器根据你显示声明的已知的信息 推断出你没有显示声明的类型，这就是类型推断。
+看过《Java编程思想 第四版》的朋友可能还记得里面讲解泛型一章的时候，里面很多例子是下面这样的:
+```java
+ Map map = new Map();
+```
+而我们平常写的都是这样的:
+```java
+ Map map = new Map<>();
+```
+这就是类型推断，《Java编程思想 第四版》这本书出书的时候最新的JDK只有1.6(JDK7推出的类型推断)，在Java编程思想里Bruce Eckel大叔还提到过这个问题
+(可能JDK的官方人员看了Bruce Eckel大叔的Thinking in Java才加的类型推断，☺)，在JDK7中推出了上面这样的类型推断，可以减少一些无用的代码。
+(Java编程思想到现在还只有第四版，是不是因为Bruce Eckel大叔觉得Java新推出的语言特性“然并卵”呢？/滑稽)
+
+在JDK7中，类型推断只有上面例子的那样的能力，即只有在使用**赋值语句**时才能自动推断出泛型参数信息(即<>里的信息)，下面的官方文档里的例子在JDK7里会编译
+错误
+```java
+ List stringList = new ArrayList<>();
+ stringList.add("A");
+ //error : addAll(java.util.Collection)in List cannot be applied to (java.util.List)
+ stringList.addAll(Arrays.asList());
+```
+但是上面的代码在JDK8里可以通过，也就说，JDK8里，类型推断不仅可以用于赋值语句，而且可以根据代码中上下文里的信息推断出更多的信息，因此我们需要些的代码
+会更少。加强的类型推断还有一个就是用于Lambda表达式了。
+
+大家其实不必细究类型推断，在日常使用中IDE会自动判断，当IDE自己无法推断出足够的信息时，就需要我们额外做一下工作，比如在<>里添加更多的类型信息，
+相信随着Java的进化，这些便利的功能会越来越强大。
+
+
+____
+
+
+## 通过反射获得方法的参数信息
+JDK8之前 .class文件是不会存储方法参数信息的，因此也就无法通过反射获取该信息(想想反射获取类信息的入口是什么？当然就是Class类了)。即是是在JDK11里
+也不会默认生成这些信息，可以通过在javac加上-parameters参数来让javac生成这些信息(javac就是java编译器，可以把java文件编译成.class文件)。生成额外
+的信息(运行时非必须信息)会消耗内存并且有可能公布敏感信息(某些方法参数比如password，JDK文档里这么说的)，并且确实很多信息javac并不会为我们生成，比如
+LocalVariableTable，javac就不会默认生成，需要你加上 -g:vars来强制让编译器生成，同样的，方法参数信息也需要加上
+-parameters来让javac为你在.class文件中生成这些信息，否则运行时反射是无法获取到这些信息的。在讲解Java语言层面的方法之前，先看一下javac加上该
+参数和不加生成的信息有什么区别(不感兴趣想直接看运行代码的可以跳过这段)。下面是随便写的一个类。
+```java
+public class ByteCodeParameters {
+ public String simpleMethod(String canUGetMyName, Object yesICan) {
+ return "9527";
+ }
+}
+```
+先来不加参数编译和反编译一下这个类javac ByteCodeParameters.java , javap -v ByteCodeParameters:
+```java
+ //只截取了部分信息
+ public java.lang.String simpleMethod(java.lang.String, java.lang.Object);
+ descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;
+ flags: (0x0001) ACC_PUBLIC
+ Code:
+ stack=1, locals=3, args_size=3
+ 0: ldc #2 // String 9527
+ 2: areturn
+ LineNumberTable:
+ line 5: 0
+ //这个方法的描述到这里就结束了
+```
+接下来我们加上参数javac -parameters ByteCodeParameters.java 再来看反编译的信息:
+```java
+ public java.lang.String simpleMethod(java.lang.String, java.lang.Object);
+ descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;
+ flags: (0x0001) ACC_PUBLIC
+ Code:
+ stack=1, locals=3, args_size=3
+ 0: ldc #2 // String 9527
+ 2: areturn
+ LineNumberTable:
+ line 8: 0
+ MethodParameters:
+ Name Flags
+ canUGetMyName
+ yesICan
+```
+可以看到.class文件里多了一个MethodParameters信息，这就是参数的名字，可以看到默认是不保存的。
+
下面看一下在Intelj Idea里运行的这个例子，我们试一下通过反射获取方法名 :
+```java
+public class ByteCodeParameters {
+ public String simpleMethod(String canUGetMyName, Object yesICan) {
+ return "9527";
+ }
+
+ public static void main(String[] args) throws NoSuchMethodException {
+ Class clazz = ByteCodeParameters.class;
+ Method simple = clazz.getDeclaredMethod("simpleMethod", String.class, Object.class);
+ Parameter[] parameters = simple.getParameters();
+ for (Parameter p : parameters) {
+ System.out.println(p.getName());
+ }
+ }
+}
+输出 :
+arg0
+arg1
+```
+？？？说好的方法名呢？？？？别急，哈哈。前面说了，默认是不生成参数名信息的，因此我们需要做一些配置，我们找到IDEA的settings里的Java Compiler选项，在
+Additional command line parameters:一行加上-parameters(Eclipse 也是找到Java Compiler选中Stoer information about method parameters)，或者自
+己编译一个.class文件放在IDEA的out下，然后再来运行 :
+```java
+输出 :
+canUGetMyName
+yesICan
+```
+这样我们就通过反射获取到参数信息了。想要了解更多的同学可以自己研究一下 [官方文档]
+(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html)
+
+## 总结与补充
+在JDK8之后，可以通过-parameters参数来让编译器生成参数信息然后在运行时通过反射获取方法参数信息，其实在SpringFramework
+里面也有一个LocalVariableTableParameterNameDiscoverer对象可以获取方法参数名信息，有兴趣的同学可以自行百度(这个类在打印日志时可能会比较有用吧，个人感觉)。
+
+____
+
+
+
+
+___
diff --git a/docs/java/What's New in JDK8/Stream.md b/docs/java/What's New in JDK8/Stream.md
new file mode 100644
index 00000000000..de7c86e3f2e
--- /dev/null
+++ b/docs/java/What's New in JDK8/Stream.md
@@ -0,0 +1,75 @@
+Stream API 旨在让编码更高效率、干净、简洁。
+
+### 从迭代器到Stream操作
+
+当使用 `Stream` 时，我们一般会通过三个阶段建立一个流水线：
+
+1. 创建一个 `Stream`；
+2. 进行一个或多个中间操作;
+3. 使用终止操作产生一个结果,`Stream` 就不会再被使用了。
+
+**案例1：统计 List 中的单词长度大于6的个数**
+
+```java
+/**
+* 案例1：统计 List 中的单词长度大于6的个数
+*/
+ArrayList wordsList = new ArrayList();
+wordsList.add("Charles");
+wordsList.add("Vincent");
+wordsList.add("William");
+wordsList.add("Joseph");
+wordsList.add("Henry");
+wordsList.add("Bill");
+wordsList.add("Joan");
+wordsList.add("Linda");
+int count = 0;
+```
+Java8之前我们通常用迭代方法来完成上面的需求：
+
+```java
+//迭代（Java8之前的常用方法）
+//迭代不好的地方：1. 代码多；2 很难被并行运算。
+for (String word : wordsList) {
+ if (word.length() > 6) {
+ count++;
+ }
+}
+System.out.println(count);//3
+```
+Java8之前我们使用 `Stream` 一行代码就能解决了，而且可以瞬间转换为并行执行的效果：
+
+```java
+//Stream
+//将stream()改为parallelStream()就可以瞬间将代码编程并行执行的效果
+long count2=wordsList.stream()
+ .filter(w->w.length()>6)
+ .count();
+long count3=wordsList.parallelStream()
+ .filter(w->w.length()>6)
+ .count();
+System.out.println(count2);
+System.out.println(count3);
+```
+
+### `distinct()`
+
+去除 List 中重复的 String
+
+```java
+List list = list.stream()
+ .distinct()
+ .collect(Collectors.toList());
+```
+
+### `map`
+
+map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：
+
+```java
+List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
+// 获取 List 中每个元素对应的平方数并去重
+List squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
+System.out.println(squaresList.toString());//[9, 4, 49, 25]
+```
+
diff --git "a/docs/java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" "b/docs/java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md"
new file mode 100644
index 00000000000..b5cff7bb0c0
--- /dev/null
+++ "b/docs/java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md"
@@ -0,0 +1,30 @@
+## 改进的类型推断
+### 1.什么是类型推断
+类型推断就像它的字面意思一样，编译器根据你显示声明的已知的信息 推断出你没有显示声明的类型，这就是类型推断。
+看过《Java编程思想 第四版》的朋友可能还记得里面讲解泛型一章的时候，里面很多例子是下面这样的:
+```java
+ Map map = new Map();
+```
+而我们平常写的都是这样的:
+```java
+ Map map = new Map<>();
+```
+这就是类型推断，《Java编程思想 第四版》这本书出书的时候最新的JDK只有1.6(JDK7推出的类型推断)，在Java编程思想里Bruce Eckel大叔还提到过这个问题
+(可能JDK的官方人员看了Bruce Eckel大叔的Thinking in Java才加的类型推断，☺)，在JDK7中推出了上面这样的类型推断，可以减少一些无用的代码。
+(Java编程思想到现在还只有第四版，是不是因为Bruce Eckel大叔觉得Java新推出的语言特性“然并卵”呢？/滑稽)
+
+在JDK7中，类型推断只有上面例子的那样的能力，即只有在使用**赋值语句**时才能自动推断出泛型参数信息(即<>里的信息)，下面的官方文档里的例子在JDK7里会编译
+错误
+```java
+ List stringList = new ArrayList<>();
+ stringList.add("A");
+ //error : addAll(java.util.Collection)in List cannot be applied to (java.util.List)
+ stringList.addAll(Arrays.asList());
+```
+但是上面的代码在JDK8里可以通过，也就说，JDK8里，类型推断不仅可以用于赋值语句，而且可以根据代码中上下文里的信息推断出更多的信息，因此我们需要些的代码
+会更少。加强的类型推断还有一个就是用于Lambda表达式了。
+
+大家其实不必细究类型推断，在日常使用中IDE会自动判断，当IDE自己无法推断出足够的信息时，就需要我们额外做一下工作，比如在<>里添加更多的类型信息，
+相信随着Java的进化，这些便利的功能会越来越强大。
+
+
diff --git "a/docs/java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" "b/docs/java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md"
new file mode 100644
index 00000000000..a1d91c4b2fe
--- /dev/null
+++ "b/docs/java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md"
@@ -0,0 +1,79 @@
+## 通过反射获得方法的参数信息
+JDK8之前 .class文件是不会存储方法参数信息的，因此也就无法通过反射获取该信息(想想反射获取类信息的入口是什么？当然就是Class类了)。即是是在JDK11里
+也不会默认生成这些信息，可以通过在javac加上-parameters参数来让javac生成这些信息(javac就是java编译器，可以把java文件编译成.class文件)。生成额外
+的信息(运行时非必须信息)会消耗内存并且有可能公布敏感信息(某些方法参数比如password，JDK文档里这么说的)，并且确实很多信息javac并不会为我们生成，比如
+LocalVariableTable，javac就不会默认生成，需要你加上 -g:vars来强制让编译器生成，同样的，方法参数信息也需要加上
+-parameters来让javac为你在.class文件中生成这些信息，否则运行时反射是无法获取到这些信息的。在讲解Java语言层面的方法之前，先看一下javac加上该
+参数和不加生成的信息有什么区别(不感兴趣想直接看运行代码的可以跳过这段)。下面是随便写的一个类。
+```java
+public class ByteCodeParameters {
+ public String simpleMethod(String canUGetMyName, Object yesICan) {
+ return "9527";
+ }
+}
+```
+先来不加参数编译和反编译一下这个类javac ByteCodeParameters.java , javap -v ByteCodeParameters:
+```java
+ //只截取了部分信息
+ public java.lang.String simpleMethod(java.lang.String, java.lang.Object);
+ descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;
+ flags: (0x0001) ACC_PUBLIC
+ Code:
+ stack=1, locals=3, args_size=3
+ 0: ldc #2 // String 9527
+ 2: areturn
+ LineNumberTable:
+ line 5: 0
+ //这个方法的描述到这里就结束了
+```
+接下来我们加上参数javac -parameters ByteCodeParameters.java 再来看反编译的信息:
+```java
+ public java.lang.String simpleMethod(java.lang.String, java.lang.Object);
+ descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;
+ flags: (0x0001) ACC_PUBLIC
+ Code:
+ stack=1, locals=3, args_size=3
+ 0: ldc #2 // String 9527
+ 2: areturn
+ LineNumberTable:
+ line 8: 0
+ MethodParameters:
+ Name Flags
+ canUGetMyName
+ yesICan
+```
+可以看到.class文件里多了一个MethodParameters信息，这就是参数的名字，可以看到默认是不保存的。
+
下面看一下在Intelj Idea里运行的这个例子，我们试一下通过反射获取方法名 :
+```java
+public class ByteCodeParameters {
+ public String simpleMethod(String canUGetMyName, Object yesICan) {
+ return "9527";
+ }
+
+ public static void main(String[] args) throws NoSuchMethodException {
+ Class clazz = ByteCodeParameters.class;
+ Method simple = clazz.getDeclaredMethod("simpleMethod", String.class, Object.class);
+ Parameter[] parameters = simple.getParameters();
+ for (Parameter p : parameters) {
+ System.out.println(p.getName());
+ }
+ }
+}
+输出 :
+arg0
+arg1
+```
+？？？说好的方法名呢？？？？别急，哈哈。前面说了，默认是不生成参数名信息的，因此我们需要做一些配置，我们找到IDEA的settings里的Java Compiler选项，在
+Additional command line parameters:一行加上-parameters(Eclipse 也是找到Java Compiler选中Stoer information about method parameters)，或者自
+己编译一个.class文件放在IDEA的out下，然后再来运行 :
+```java
+输出 :
+canUGetMyName
+yesICan
+```
+这样我们就通过反射获取到参数信息了。想要了解更多的同学可以自己研究一下 [官方文档]
+(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html)
+
+## 总结与补充
+在JDK8之后，可以通过-parameters参数来让编译器生成参数信息然后在运行时通过反射获取方法参数信息，其实在SpringFramework
+里面也有一个LocalVariableTableParameterNameDiscoverer对象可以获取方法参数名信息，有兴趣的同学可以自行百度(这个类在打印日志时可能会比较有用吧，个人感觉)。
diff --git "a/Java\347\233\270\345\205\263/synchronized.md" b/docs/java/synchronized.md
similarity index 94%
rename from "Java\347\233\270\345\205\263/synchronized.md"
rename to docs/java/synchronized.md
index dfca675f14a..0a1f4f2b073 100644
--- "a/Java\347\233\270\345\205\263/synchronized.md"
+++ b/docs/java/synchronized.md
@@ -1,6 +1,4 @@
-以下内容摘自我的 Gitchat ：[Java 程序员必备：并发知识系统总结](https://gitbook.cn/gitchat/activity/5bc2b6af56f0425673d299bb)，欢迎订阅！
-Github 地址：[https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/synchronized.md](https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/synchronized.md)
@@ -12,7 +10,7 @@ Github 地址：[https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/
下面我已一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。
-面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单利模式的原理呗！”
+面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！”
@@ -48,7 +46,7 @@ uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueIns
2. 初始化 uniqueInstance
3. 将 uniqueInstance 指向分配的内存地址
-但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
+但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
@@ -141,7 +139,7 @@ JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、
**⑤ 锁粗化**
-原则上，我们再编写代码的时候，总是推荐将同步快的作用范围限制得尽量小——只在共享数据的实际作用域才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待线程也能尽快拿到锁。
+原则上，我们在编写代码的时候，总是推荐将同步块的作用范围限制得尽量小，——直在共享数据的实际作用域才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待线程也能尽快拿到锁。
大部分情况下，上面的原则都是没有问题的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，那么会带来很多不必要的性能消耗。
@@ -168,4 +166,4 @@ synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团
**④ 性能已不是选择标准**
-在JDK1.6之前，synchronized 的性能是比 ReenTrantLock 差很多。具体表示为：synchronized 关键字吞吐量岁线程数的增加，下降得非常严重。而ReenTrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。**JDK1.6 之后，synchronized 和 ReenTrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReenTrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReenTrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReenTrantLock一样，在很多地方都是用到了CAS操作**。
+在JDK1.6之前，synchronized 的性能是比 ReenTrantLock 差很多。具体表示为：synchronized 关键字吞吐量随线程数的增加，下降得非常严重。而ReenTrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。**JDK1.6 之后，synchronized 和 ReenTrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReenTrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReenTrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReenTrantLock一样，在很多地方都是用到了CAS操作**。
diff --git "a/docs/java/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" "b/docs/java/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md"
new file mode 100644
index 00000000000..754d3b98a16
--- /dev/null
+++ "b/docs/java/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md"
@@ -0,0 +1,417 @@
+
+
+- [Java 内存区域详解](#java-内存区域详解)
+ - [写在前面 (常见面试题)](#写在前面-常见面试题)
+ - [基本问题](#基本问题)
+ - [拓展问题](#拓展问题)
+ - [一 概述](#一-概述)
+ - [二 运行时数据区域](#二-运行时数据区域)
+ - [2.1 程序计数器](#21-程序计数器)
+ - [2.2 Java 虚拟机栈](#22-java-虚拟机栈)
+ - [2.3 本地方法栈](#23-本地方法栈)
+ - [2.4 堆](#24-堆)
+ - [2.5 方法区](#25-方法区)
+ - [2.5.1 方法区和永久代的关系](#251-方法区和永久代的关系)
+ - [2.5.2 常用参数](#252-常用参数)
+ - [2.5.3 为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) 呢?](#253-为什么要将永久代-permgen-替换为元空间-metaspace-呢)
+ - [2.6 运行时常量池](#26-运行时常量池)
+ - [2.7 直接内存](#27-直接内存)
+ - [三 HotSpot 虚拟机对象探秘](#三-hotspot-虚拟机对象探秘)
+ - [3.1 对象的创建](#31-对象的创建)
+ - [Step1:类加载检查](#step1类加载检查)
+ - [Step2:分配内存](#step2分配内存)
+ - [Step3:初始化零值](#step3初始化零值)
+ - [Step4:设置对象头](#step4设置对象头)
+ - [Step5:执行 init 方法](#step5执行-init-方法)
+ - [3.2 对象的内存布局](#32-对象的内存布局)
+ - [3.3 对象的访问定位](#33-对象的访问定位)
+ - [四 重点补充内容](#四--重点补充内容)
+ - [4.1 String 类和常量池](#41-string-类和常量池)
+ - [4.2 String s1 = new String("abc");这句话创建了几个字符串对象？](#42-string-s1--new-stringabc这句话创建了几个字符串对象)
+ - [4.3 8 种基本类型的包装类和常量池](#43-8-种基本类型的包装类和常量池)
+ - [参考](#参考)
+
+
+
+# Java 内存区域详解
+
+## 写在前面 (常见面试题)
+
+### 基本问题
+
+- **介绍下 Java 内存区域（运行时数据区）**
+- **Java 对象的创建过程（五步，建议能默写出来并且要知道每一步虚拟机做了什么）**
+- **对象的访问定位的两种方式（句柄和直接指针两种方式）**
+
+### 拓展问题
+
+- **String 类和常量池**
+- **8 种基本类型的包装类和常量池**
+
+## 一 概述
+
+对于 Java 程序员来说，在虚拟机自动内存管理机制下，不再需要像 C/C++程序开发程序员这样为内一个 new 操作去写对应的 delete/free 操作，不容易出现内存泄漏和内存溢出问题。正是因为 Java 程序员把内存控制权利交给 Java 虚拟机，一旦出现内存泄漏和溢出方面的问题，如果不了解虚拟机是怎样使用内存的，那么排查错误将会是一个非常艰巨的任务。
+
+## 二 运行时数据区域
+Java 虚拟机在执行 Java 程序的过程中会把它管理的内存划分成若干个不同的数据区域。JDK. 1.8 和之前的版本略有不同，下面会介绍到。
+
+**JDK 1.8 之前：**
+
+
+
+
+
+
+
+
+
+
+
+### 3.2 复制算法
+
+为了解决效率问题，“复制”收集算法出现了。它可以将内存分为大小相同的两块，每次使用其中的一块。当这一块的内存使用完后，就将还存活的对象复制到另一块去，然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。
+
+
+
+### 3.3 标记-整理算法
+根据老年代的特点特出的一种标记算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象回收，而是让所有存活的对象向一端移动，然后直接清理掉端边界以外的内存。
+
+
+
+### 3.4 分代收集算法
+
+当前虚拟机的垃圾收集都采用分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不同将内存分为几块。一般将 java 堆分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
+
+**比如在新生代中，每次收集都会有大量对象死去，所以可以选择复制算法，只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的，而且没有额外的空间对它进行分配担保，所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集。**
+
+**延伸面试问题：** HotSpot 为什么要分为新生代和老年代？
+
+根据上面的对分代收集算法的介绍回答。
+
+## 4 垃圾收集器
+
+
+
+**如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。**
+
+虽然我们对各个收集器进行比较，但并非要挑选出一个最好的收集器。因为知道现在为止还没有最好的垃圾收集器出现，更加没有万能的垃圾收集器，**我们能做的就是根据具体应用场景选择适合自己的垃圾收集器**。试想一下：如果有一种四海之内、任何场景下都适用的完美收集器存在，那么我们的 HotSpot 虚拟机就不会实现那么多不同的垃圾收集器了。
+
+
+### 4.1 Serial 收集器
+Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 **“单线程”** 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（ **"Stop The World"** ），直到它收集结束。
+
+ **新生代采用复制算法，老年代采用标记-整理算法。**
+
+
+虚拟机的设计者们当然知道 Stop The World 带来的不良用户体验，所以在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。
+
+但是 Serial 收集器有没有优于其他垃圾收集器的地方呢？当然有，它**简单而高效（与其他收集器的单线程相比）**。Serial 收集器由于没有线程交互的开销，自然可以获得很高的单线程收集效率。Serial 收集器对于运行在 Client 模式下的虚拟机来说是个不错的选择。
+
+
+
+### 4.2 ParNew 收集器
+**ParNew 收集器其实就是 Serial 收集器的多线程版本，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和 Serial 收集器完全一样。**
+
+ **新生代采用复制算法，老年代采用标记-整理算法。**
+
+
+它是许多运行在 Server 模式下的虚拟机的首要选择，除了 Serial 收集器外，只有它能与 CMS 收集器（真正意义上的并发收集器，后面会介绍到）配合工作。
+
+**并行和并发概念补充：**
+
+- **并行（Parallel）** ：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
+
+- **并发（Concurrent）**：指用户线程与垃圾收集线程同时执行（但不一定是并行，可能会交替执行），用户程序在继续运行，而垃圾收集器运行在另一个 CPU 上。
+
+
+### 4.3 Parallel Scavenge 收集器
+
+Parallel Scavenge 收集器类似于 ParNew 收集器。 **那么它有什么特别之处呢？**
+
+```
+-XX:+UseParallelGC
+
+ 使用 Parallel 收集器+ 老年代串行
+
+-XX:+UseParallelOldGC
+
+ 使用 Parallel 收集器+ 老年代并行
+
+```
+
+**Parallel Scavenge 收集器关注点是吞吐量（高效率的利用 CPU）。CMS 等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是 CPU 中用于运行用户代码的时间与 CPU 总消耗时间的比值。** Parallel Scavenge 收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解的话，手工优化存在的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。
+
+ **新生代采用复制算法，老年代采用标记-整理算法。**
+
+
+
+### 4.4.Serial Old 收集器
+**Serial 收集器的老年代版本**，它同样是一个单线程收集器。它主要有两大用途：一种用途是在 JDK1.5 以及以前的版本中与 Parallel Scavenge 收集器搭配使用，另一种用途是作为 CMS 收集器的后备方案。
+
+### 4.5 Parallel Old 收集器
+ **Parallel Scavenge 收集器的老年代版本**。使用多线程和“标记-整理”算法。在注重吞吐量以及 CPU 资源的场合，都可以优先考虑 Parallel Scavenge 收集器和 Parallel Old 收集器。
+
+### 4.6 CMS 收集器
+
+**CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它而非常符合在注重用户体验的应用上使用。**
+
+**CMS（Concurrent Mark Sweep）收集器是 HotSpot 虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。**
+
+从名字中的**Mark Sweep**这两个词可以看出，CMS 收集器是一种 **“标记-清除”算法**实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：
+
+- **初始标记：** 暂停所有的其他线程，并记录下直接与 root 相连的对象，速度很快 ；
+- **并发标记：** 同时开启 GC 和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象。因为用户线程可能会不断的更新引用域，所以 GC 线程无法保证可达性分析的实时性。所以这个算法里会跟踪记录这些发生引用更新的地方。
+- **重新标记：** 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
+- **并发清除：** 开启用户线程，同时 GC 线程开始对为标记的区域做清扫。
+
+
+
+从它的名字就可以看出它是一款优秀的垃圾收集器，主要优点：**并发收集、低停顿**。但是它有下面三个明显的缺点：
+
+- **对 CPU 资源敏感；**
+- **无法处理浮动垃圾；**
+- **它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。**
+
+### 4.7 G1 收集器
+
+
+**G1 (Garbage-First) 是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足 GC 停顿时间要求的同时,还具备高吞吐量性能特征.**
+
+被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具备一下特点：
+
+- **并行与并发**：G1 能充分利用 CPU、多核环境下的硬件优势，使用多个 CPU（CPU 或者 CPU 核心）来缩短 Stop-The-World 停顿时间。部分其他收集器原本需要停顿 Java 线程执行的 GC 动作，G1 收集器仍然可以通过并发的方式让 java 程序继续执行。
+- **分代收集**：虽然 G1 可以不需要其他收集器配合就能独立管理整个 GC 堆，但是还是保留了分代的概念。
+- **空间整合**：与 CMS 的“标记--清理”算法不同，G1 从整体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。
+- **可预测的停顿**：这是 G1 相对于 CMS 的另一个大优势，降低停顿时间是 G1 和 CMS 共同的关注点，但 G1 除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为 M 毫秒的时间片段内。
+
+
+G1 收集器的运作大致分为以下几个步骤：
+
+- **初始标记**
+- **并发标记**
+- **最终标记**
+- **筛选回收**
+
+
+**G1 收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的 Region(这也就是它的名字 Garbage-First 的由来)**。这种使用 Region 划分内存空间以及有优先级的区域回收方式，保证了 GF 收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。
+
+## 参考
+
+- 《深入理解 Java 虚拟机：JVM 高级特性与最佳实践（第二版》
+- https://my.oschina.net/hosee/blog/644618
+-
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/Java\347\233\270\345\205\263/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" "b/docs/java/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md"
similarity index 73%
rename from "Java\347\233\270\345\205\263/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md"
rename to "docs/java/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md"
index f934d914d5f..16d7a41adea 100644
--- "a/Java\347\233\270\345\205\263/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md"
+++ "b/docs/java/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md"
@@ -1,27 +1,38 @@
-> 本文是“最最最常见Java面试题总结”系列第三周的文章。
-> 主要内容：
-> 1. Arraylist 与 LinkedList 异同
-> 2. ArrayList 与 Vector 区别
-> 3. HashMap的底层实现
-> 4. HashMap 和 Hashtable 的区别
-> 5. HashMap 的长度为什么是2的幂次方
-> 6. HashMap 多线程操作导致死循环问题
-> 7. HashSet 和 HashMap 区别
-> 8. ConcurrentHashMap 和 Hashtable 的区别
-> 9. ConcurrentHashMap线程安全的具体实现方式/底层具体实现
-> 10. 集合框架底层数据结构总结
+
+
+- [Arraylist 与 LinkedList 异同](#arraylist-与-linkedlist-异同)
+ - [补充：数据结构基础之双向链表](#补充：数据结构基础之双向链表)
+- [ArrayList 与 Vector 区别](#arraylist-与-vector-区别)
+- [HashMap的底层实现](#hashmap的底层实现)
+ - [JDK1.8之前](#jdk18之前)
+ - [JDK1.8之后](#jdk18之后)
+- [HashMap 和 Hashtable 的区别](#hashmap-和-hashtable-的区别)
+- [HashMap 的长度为什么是2的幂次方](#hashmap-的长度为什么是2的幂次方)
+- [HashMap 多线程操作导致死循环问题](#hashmap-多线程操作导致死循环问题)
+- [HashSet 和 HashMap 区别](#hashset-和-hashmap-区别)
+- [ConcurrentHashMap 和 Hashtable 的区别](#concurrenthashmap-和-hashtable-的区别)
+- [ConcurrentHashMap线程安全的具体实现方式/底层具体实现](#concurrenthashmap线程安全的具体实现方式底层具体实现)
+ - [JDK1.7（上面有示意图）](#jdk17（上面有示意图）)
+ - [JDK1.8 （上面有示意图）](#jdk18-（上面有示意图）)
+- [集合框架底层数据结构总结](#集合框架底层数据结构总结)
+ - [Collection](#collection)
+ - [1. List](#1-list)
+ - [2. Set](#2-set)
+ - [Map](#map)
+ - [推荐阅读：](#推荐阅读：)
+
+
## Arraylist 与 LinkedList 异同
- **1. 是否保证线程安全：** ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
-- **2. 底层数据结构：** Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向循环链表数据结构；
+- **2. 底层数据结构：** Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向链表数据结构（JDK1.6之前为循环链表，JDK1.7取消了循环。注意双向链表和双向循环链表的区别：）； 详细可阅读[JDK1.7-LinkedList循环链表优化](https://www.cnblogs.com/xingele0917/p/3696593.html)
- **3. 插入和删除是否受元素位置的影响：** ① **ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e) `方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（`add(int index, E element) `）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（1）而数组为近似 O（n）。**
- **4. 是否支持快速随机访问：** LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index) `方法)。
- **5. 内存空间占用：** ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。
-
-**补充内容:RandomAccess接口**
+- **6.补充内容:RandomAccess接口**
```java
public interface RandomAccess {
@@ -42,12 +53,13 @@ public interface RandomAccess {
}
```
-ArraysList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArraysList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O（1），所以称为快速随机访问。实际上链表也是支持的，不过需要遍历到特定位置才行，时间复杂度为 O（n）。所以，ArraysList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArraysList 实现 RandomAccess 接口才具有快速随机访问功能的！
-
+ArrayList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArrayList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O（1），所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O（n），所以不支持快速随机访问。，ArrayList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArrayList 实现 RandomAccess 接口才具有快速随机访问功能的！
+
+
**下面再总结一下 list 的遍历方式选择：**
-- 实现了RadmoAcces接口的list，优先选择普通for循环 ，其次foreach,
-- 未实现RadmoAcces接口的ist， 优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环
+- 实现了RandomAccess接口的list，优先选择普通for循环 ，其次foreach,
+- 未实现RandomAccess接口的ist， 优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环
### 补充：数据结构基础之双向链表
@@ -68,7 +80,7 @@ Arraylist不是同步的，所以在不需要保证线程安全时时建议使
### JDK1.8之前
-JDK1.8 之前 HashMap 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 `(n - 1) & hash` 判断当前元素存放的位置（这里的 n 指的时数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。**
+JDK1.8 之前 HashMap 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 `(n - 1) & hash` 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。**
**所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。**
@@ -165,7 +177,7 @@ static int hash(int h) {
## HashMap 的长度为什么是2的幂次方
-为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483648，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ `(n - 1) & hash` ”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。
+为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ `(n - 1) & hash` ”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。
**这个算法应该如何设计呢？**
@@ -173,23 +185,9 @@ static int hash(int h) {
## HashMap 多线程操作导致死循环问题
-在多线程下，进行 put 操作会导致 HashMap 死循环，原因在于 HashMap 的扩容 resize()方法。由于扩容是新建一个数组，复制原数据到数组。由于数组下标挂有链表，所以需要复制链表，但是多线程操作有可能导致环形链表。复制链表过程如下:
-以下模拟2个线程同时扩容。假设，当前 HashMap 的空间为2（临界值为1），hashcode 分别为 0 和 1，在散列地址 0 处有元素 A 和 B，这时候要添加元素 C，C 经过 hash 运算，得到散列地址为 1，这时候由于超过了临界值，空间不够，需要调用 resize 方法进行扩容，那么在多线程条件下，会出现条件竞争，模拟过程如下：
-
- 线程一：读取到当前的 HashMap 情况，在准备扩容时，线程二介入
-
-
-
-线程二：读取 HashMap，进行扩容
-
-
-
-线程一：继续执行
-
-
-
-这个过程为，先将 A 复制到新的 hash 表中，然后接着复制 B 到链头（A 的前边：B.next=A），本来 B.next=null，到此也就结束了（跟线程二一样的过程），但是，由于线程二扩容的原因，将 B.next=A，所以，这里继续复制A，让 A.next=B，由此，环形链表出现：B.next=A; A.next=B
+主要原因在于 并发下的Rehash 会造成元素之间会形成一个循环链表。不过，jdk 1.8 后解决了这个问题，但是还是不建议在多线程下使用 HashMap,因为多线程下使用 HashMap 还是会存在其他问题比如数据丢失。并发环境下推荐使用 ConcurrentHashMap 。
+详情请查看：
## HashSet 和 HashMap 区别
@@ -203,7 +201,7 @@ static int hash(int h) {
ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。
- **底层数据结构：** JDK1.7的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
-- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。（默认分配16个Segment，比Hashtable效率提高16倍。） **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。
+- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。
**两者的对比图：**
@@ -237,7 +235,7 @@ static class Segment extends ReentrantLock implements Serializable {
### JDK1.8 （上面有示意图）
-ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证并发安全。数据结构跟HashMap1.8的结构类似，数组+链表/红黑二叉树。
+ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证并发安全。数据结构跟HashMap1.8的结构类似，数组+链表/红黑二叉树。Java 8在链表长度超过一定阈值（8）时将链表（寻址时间复杂度为O(N)）转换为红黑树（寻址时间复杂度为O(long(N))）
synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。
@@ -245,11 +243,12 @@ synchronized只锁定当前链表或红黑二叉树的首节点，这样只要ha
## 集合框架底层数据结构总结
### Collection
-
+
#### 1. List
- **Arraylist：** Object数组
- **Vector：** Object数组
- - **LinkedList：** 双向循环链表
+ - **LinkedList：** 双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环)
+ 详细可阅读[JDK1.7-LinkedList循环链表优化](https://www.cnblogs.com/xingele0917/p/3696593.html)
#### 2. Set
- **HashSet（无序，唯一）:** 基于 HashMap 实现的，底层采用 HashMap 来保存元素
@@ -257,11 +256,11 @@ synchronized只锁定当前链表或红黑二叉树的首节点，这样只要ha
- **TreeSet（有序，唯一）：** 红黑树(自平衡的排序二叉树。)
### Map
- - **HashMap：** JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间
- - **LinkedHashMap:** LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。详细可以查看：[《LinkedHashMap 源码详细分析（JDK1.8）》](https://www.imooc.com/article/22931)
- - **HashTable:** 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
- - **TreeMap:** 红黑树（自平衡的排序二叉树）
-
+ - **HashMap：** JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间
+ - **LinkedHashMap：** LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。详细可以查看：[《LinkedHashMap 源码详细分析（JDK1.8）》](https://www.imooc.com/article/22931)
+ - **Hashtable：** 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
+ - **TreeMap：** 红黑树（自平衡的排序二叉树）
+
diff --git "a/docs/network/HTTPS\344\270\255\347\232\204TLS.md" "b/docs/network/HTTPS\344\270\255\347\232\204TLS.md"
new file mode 100644
index 00000000000..4132144608c
--- /dev/null
+++ "b/docs/network/HTTPS\344\270\255\347\232\204TLS.md"
@@ -0,0 +1,137 @@
+
+
+- [1. SSL 与 TLS](#1-ssl-%E4%B8%8E-tls)
+- [2. 从网络协议的角度理解 HTTPS](#2-%E4%BB%8E%E7%BD%91%E7%BB%9C%E5%8D%8F%E8%AE%AE%E7%9A%84%E8%A7%92%E5%BA%A6%E7%90%86%E8%A7%A3-https)
+- [3. 从密码学的角度理解 HTTPS](#3-%E4%BB%8E%E5%AF%86%E7%A0%81%E5%AD%A6%E7%9A%84%E8%A7%92%E5%BA%A6%E7%90%86%E8%A7%A3-https)
+ - [3.1. TLS 工作流程](#31-tls-%E5%B7%A5%E4%BD%9C%E6%B5%81%E7%A8%8B)
+ - [3.2. 密码基础](#32-%E5%AF%86%E7%A0%81%E5%9F%BA%E7%A1%80)
+ - [3.2.1. 伪随机数生成器](#321-%E4%BC%AA%E9%9A%8F%E6%9C%BA%E6%95%B0%E7%94%9F%E6%88%90%E5%99%A8)
+ - [3.2.2. 消息认证码](#322-%E6%B6%88%E6%81%AF%E8%AE%A4%E8%AF%81%E7%A0%81)
+ - [3.2.3. 数字签名](#323-%E6%95%B0%E5%AD%97%E7%AD%BE%E5%90%8D)
+ - [3.2.4. 公钥密码](#324-%E5%85%AC%E9%92%A5%E5%AF%86%E7%A0%81)
+ - [3.2.5. 证书](#325-%E8%AF%81%E4%B9%A6)
+ - [3.2.6. 密码小结](#326-%E5%AF%86%E7%A0%81%E5%B0%8F%E7%BB%93)
+ - [3.3. TLS 使用的密码技术](#33-tls-%E4%BD%BF%E7%94%A8%E7%9A%84%E5%AF%86%E7%A0%81%E6%8A%80%E6%9C%AF)
+ - [3.4. TLS 总结](#34-tls-%E6%80%BB%E7%BB%93)
+- [4. RSA 简单示例](#4-rsa-%E7%AE%80%E5%8D%95%E7%A4%BA%E4%BE%8B)
+- [5. 参考](#5-%E5%8F%82%E8%80%83)
+
+
+
+# 1. SSL 与 TLS
+
+SSL：（Secure Socket Layer） 安全套接层，于 1994 年由网景公司设计，并于 1995 年发布了 3.0 版本
+TLS：（Transport Layer Security）传输层安全性协议，是 IETF 在 SSL3.0 的基础上设计的协议
+以下全部使用 TLS 来表示
+
+# 2. 从网络协议的角度理解 HTTPS
+
+![此图并不准确][1]
+HTTP：HyperText Transfer Protocol 超文本传输协议
+HTTPS：Hypertext Transfer Protocol Secure 超文本传输安全协议
+TLS：位于 HTTP 和 TCP 之间的协议，其内部有 TLS握手协议、TLS记录协议
+HTTPS 经由 HTTP 进行通信，但利用 TLS 来保证安全，即 HTTPS = HTTP + TLS
+
+# 3. 从密码学的角度理解 HTTPS
+
+HTTPS 使用 TLS 保证安全，这里的“安全”分两部分，一是传输内容加密、二是服务端的身份认证
+
+## 3.1. TLS 工作流程
+
+![此图并不准确][2]
+此为服务端单向认证，还有客户端/服务端双向认证，流程类似，只不过客户端也有自己的证书，并发送给服务器进行验证
+
+## 3.2. 密码基础
+
+### 3.2.1. 伪随机数生成器
+
+为什么叫伪随机数，因为没有真正意义上的随机数，具体可以参考 Random/TheadLocalRandom
+它的主要作用在于生成对称密码的秘钥、用于公钥密码生成秘钥对
+
+### 3.2.2. 消息认证码
+
+消息认证码主要用于验证消息的完整性与消息的认证，其中消息的认证指“消息来自正确的发送者”
+
+>消息认证码用于验证和认证，而不是加密
+
+![消息认证码过程][3]
+
+1. 发送者与接收者事先共享秘钥
+2. 发送者根据发送消息计算 MAC 值
+3. 发送者发送消息和 MAC 值
+4. 接收者根据接收到的消息计算 MAC 值
+5. 接收者根据自己计算的 MAC 值与收到的 MAC 对比
+6. 如果对比成功，说明消息完整，并来自与正确的发送者
+
+### 3.2.3. 数字签名
+
+消息认证码的缺点在于**无法防止否认**，因为共享秘钥被 client、server 两端拥有，server 可以伪造 client 发送给自己的消息（自己给自己发送消息），为了解决这个问题，我们需要它们有各自的秘钥不被第二个知晓（这样也解决了共享秘钥的配送问题）
+
+![数字签名过程][4]
+
+>数字签名和消息认证码都**不是为了加密**
+>可以将单向散列函数获取散列值的过程理解为使用 md5 摘要算法获取摘要的过程
+
+使用自己的私钥对自己所认可的消息生成一个该消息专属的签名，这就是数字签名，表明我承认该消息来自自己
+注意：**私钥用于加签，公钥用于解签，每个人都可以解签，查看消息的归属人**
+
+### 3.2.4. 公钥密码
+
+公钥密码也叫非对称密码，由公钥和私钥组成，它是最开始是为了解决秘钥的配送传输安全问题，即，我们不配送私钥，只配送公钥，私钥由本人保管
+它与数字签名相反，公钥密码的私钥用于解密、公钥用于加密，每个人都可以用别人的公钥加密，但只有对应的私钥才能解开密文
+client：明文 + 公钥 = 密文
+server：密文 + 私钥 = 明文
+注意：**公钥用于加密，私钥用于解密，只有私钥的归属者，才能查看消息的真正内容**
+
+### 3.2.5. 证书
+
+证书：全称公钥证书（Public-Key Certificate, PKC）,里面保存着归属者的基本信息，以及证书过期时间、归属者的公钥，并由认证机构（Certification Authority, **CA**）施加数字签名，表明，某个认证机构认定该公钥的确属于此人
+
+>想象这个场景：你想在支付宝页面交易，你需要支付宝的公钥进行加密通信，于是你从百度上搜索关键字“支付宝公钥”，你获得了支什宝的公钥，这个时候，支什宝通过中间人攻击，让你访问到了他们支什宝的页面，最后你在这个支什宝页面完美的使用了支什宝的公钥完成了与支什宝的交易
+>![证书过程][5]
+
+在上面的场景中，你可以理解支付宝证书就是由支付宝的公钥、和给支付宝颁发证书的企业的数字签名组成
+任何人都可以给自己或别人的公钥添加自己的数字签名，表明：我拿我的尊严担保，我的公钥/别人的公钥是真的，至于信不信那是另一回事了
+
+### 3.2.6. 密码小结
+
+| 密码 | 作用 | 组成 |
+| :-- | :-- | :-- |
+| 消息认证码 | 确认消息的完整、并对消息的来源认证 | 共享秘钥+消息的散列值 |
+| 数字签名 | 对消息的散列值签名 | 公钥+私钥+消息的散列值 |
+| 公钥密码 | 解决秘钥的配送问题 | 公钥+私钥+消息 |
+| 证书 | 解决公钥的归属问题 | 公钥密码中的公钥+数字签名 |
+
+## 3.3. TLS 使用的密码技术
+
+1. 伪随机数生成器：秘钥生成随机性，更难被猜测
+2. 对称密码：对称密码使用的秘钥就是由伪随机数生成，相较于非对称密码，效率更高
+3. 消息认证码：保证消息信息的完整性、以及验证消息信息的来源
+4. 公钥密码：证书技术使用的就是公钥密码
+5. 数字签名：验证证书的签名，确定由真实的某个 CA 颁发
+6. 证书：解决公钥的真实归属问题，降低中间人攻击概率
+
+## 3.4. TLS 总结
+
+TLS 是一系列密码工具的框架，作为框架，它也是非常的灵活，体现在每个工具套件它都可以替换，即：客户端与服务端之间协商密码套件，从而更难的被攻破，例如使用不同方式的对称密码，或者公钥密码、数字签名生成方式、单向散列函数技术的替换等
+
+# 4. RSA 简单示例
+
+RSA 是一种公钥密码算法，我们简单的走一遍它的加密解密过程
+加密算法：密文 = (明文^E) mod N，其中公钥为{E,N}，即”求明文的E次方的对 N 的余数“
+解密算法：明文 = (密文^D) mod N，其中秘钥为{D,N}，即”求密文的D次方的对 N 的余数“
+例：我们已知公钥为{5,323}，私钥为{29,323}，明文为300，请写出加密和解密的过程：
+>加密：密文 = 123 ^ 5 mod 323 = 225
+>解密：明文 = 225 ^ 29 mod 323 = [[(225 ^ 5) mod 323] * [(225 ^ 5) mod 323] * [(225 ^ 5) mod 323] * [(225 ^ 5) mod 323] * [(225 ^ 5) mod 323] * [(225 ^ 4) mod 323]] mod 323 = (4 * 4 * 4 * 4 * 4 * 290) mod 323 = 123
+
+# 5. 参考
+
+1. SSL加密发生在哪里：
+2. TLS工作流程：
+3. 《图解密码技术》： 豆瓣评分 9.5
+
+[1]: https://leran2deeplearnjavawebtech.oss-cn-beijing.aliyuncs.com/somephoto/%E4%B8%83%E5%B1%82.png
+[2]: https://leran2deeplearnjavawebtech.oss-cn-beijing.aliyuncs.com/somephoto/tls%E6%B5%81%E7%A8%8B.png
+[3]: https://leran2deeplearnjavawebtech.oss-cn-beijing.aliyuncs.com/somephoto/%E6%B6%88%E6%81%AF%E8%AE%A4%E8%AF%81%E7%A0%81%E8%BF%87%E7%A8%8B.png
+[4]: https://leran2deeplearnjavawebtech.oss-cn-beijing.aliyuncs.com/somephoto/%E6%95%B0%E5%AD%97%E7%AD%BE%E5%90%8D%E8%BF%87%E7%A8%8B.png
+[5]: https://leran2deeplearnjavawebtech.oss-cn-beijing.aliyuncs.com/somephoto/dns%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB.png
\ No newline at end of file
diff --git "a/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\345\271\262\350\264\247\357\274\232\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\347\237\245\350\257\206\346\200\273\347\273\223.md" "b/docs/network/\345\271\262\350\264\247\357\274\232\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\347\237\245\350\257\206\346\200\273\347\273\223.md"
similarity index 99%
rename from "\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\345\271\262\350\264\247\357\274\232\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\347\237\245\350\257\206\346\200\273\347\273\223.md"
rename to "docs/network/\345\271\262\350\264\247\357\274\232\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\347\237\245\350\257\206\346\200\273\347\273\223.md"
index a5a50f10cea..8e994dd7b14 100644
--- "a/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\345\271\262\350\264\247\357\274\232\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\347\237\245\350\257\206\346\200\273\347\273\223.md"
+++ "b/docs/network/\345\271\262\350\264\247\357\274\232\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\347\237\245\350\257\206\346\200\273\347\273\223.md"
@@ -280,7 +280,7 @@
3，运输层的两个重要协议是用户数据报协议UDP和传输控制协议TCP。按照OSI的术语，两个对等运输实体在通信时传送的数据单位叫做运输协议数据单元TPDU（Transport Protocol Data Unit）。但在TCP/IP体系中，则根据所使用的协议是TCP或UDP，分别称之为TCP报文段或UDP用户数据报。
-4，UDP在传送数据之前不需要先建立连接，远地主机在收到UDP报文后，不需要给出任何确认。虽然UDP不提供可靠交付，但在某些情况下UDP确是一种最有效的工作方式。 TCP提供面向连接的服务。在传送数据之前必须先建立连接，数据传送结束后要释放连接。TCP不提供广播或多播服务。由于TCP要提供可靠的，面向连接的运输服务，这一难以避免增加了许多开销，如确认，流量控制，计时器以及连接管理等。这不仅使协议数据单元的首部增大很多，还要占用许多处理机资源。
+4，UDP在传送数据之前不需要先建立连接，远地主机在收到UDP报文后，不需要给出任何确认。虽然UDP不提供可靠交付，但在某些情况下UDP确是一种最有效的工作方式。 TCP提供面向连接的服务。在传送数据之前必须先建立连接，数据传送结束后要释放连接。TCP不提供广播或多播服务。由于TCP要提供可靠的，面向连接的传输服务，这一难以避免增加了许多开销，如确认，流量控制，计时器以及连接管理等。这不仅使协议数据单元的首部增大很多，还要占用许多处理机资源。
5，硬件端口是不同硬件设备进行交互的接口，而软件端口是应用层各种协议进程与运输实体进行层间交互的一种地址。UDP和TCP的首部格式中都有源端口和目的端口这两个重要字段。当运输层收到IP层交上来的运输层报文时，就能够 根据其首部中的目的端口号把数据交付应用层的目的应用层。（两个进程之间进行通信不光要知道对方IP地址而且要知道对方的端口号(为了找到对方计算机中的应用进程)）
diff --git "a/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md" "b/docs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
similarity index 97%
rename from "\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
rename to "docs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
index ba5fb91ecc9..d8c74ef5bf4 100644
--- "a/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
+++ "b/docs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
@@ -69,7 +69,7 @@
#### 运输层主要使用以下两种协议
-1. **传输控制协议 TCP**（Transmisson Control Protocol）--提供**面向连接**的，**可靠的**数据传输服务。
+1. **传输控制协议 TCP**（Transmission Control Protocol）--提供**面向连接**的，**可靠的**数据传输服务。
2. **用户数据协议 UDP**（User Datagram Protocol）--提供**无连接**的，尽最大努力的数据传输服务（**不保证数据传输的可靠性**）。
#### UDP 的主要特点
@@ -97,7 +97,7 @@
这里强调指出，网络层中的“网络”二字已经不是我们通常谈到的具体网络，而是指计算机网络体系结构模型中第三层的名称.
-互联网是由大量的异构（heterogeneous）网络通过路由器（router）相互连接起来的。互联网使用的网络层协议是无连接的网际协议（Intert Prococol）和许多路由选择协议，因此互联网的网络层也叫做**网际层**或**IP层**。
+互联网是由大量的异构（heterogeneous）网络通过路由器（router）相互连接起来的。互联网使用的网络层协议是无连接的网际协议（Intert Protocol）和许多路由选择协议，因此互联网的网络层也叫做**网际层**或**IP层**。
### 4 数据链路层
**数据链路层(data link layer)通常简称为链路层。两台主机之间的数据传输，总是在一段一段的链路上传送的，这就需要使用专门的链路层的协议。** 在两个相邻节点之间传送数据时，**数据链路层将网络层交下来的 IP 数据报组装程帧**，在两个相邻节点间的链路上传送帧。每一帧包括数据和必要的控制信息（如同步信息，地址信息，差错控制等）。
@@ -140,7 +140,7 @@
第二次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己接收正常，对方发送正常
-第三次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己发送、接收正常，对方发送接收正常
+第三次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己发送、接收正常，对方发送、接收正常
所以三次握手就能确认双发收发功能都正常，缺一不可。
@@ -177,7 +177,7 @@
UDP 在传送数据之前不需要先建立连接，远地主机在收到 UDP 报文后，不需要给出任何确认。虽然 UDP 不提供可靠交付，但在某些情况下 UDP 确是一种最有效的工作方式（一般用于即时通信），比如： QQ 语音、 QQ 视频 、直播等等
-TCP 提供面向连接的服务。在传送数据之前必须先建立连接，数据传送结束后要释放连接。 TCP 不提供广播或多播服务。由于 TCP 要提供可靠的，面向连接的运输服务（TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源），这一难以避免增加了许多开销，如确认，流量控制，计时器以及连接管理等。这不仅使协议数据单元的首部增大很多，还要占用许多处理机资源。TCP 一般用于文件传输、发送和接收邮件、远程登录等场景。
+TCP 提供面向连接的服务。在传送数据之前必须先建立连接，数据传送结束后要释放连接。 TCP 不提供广播或多播服务。由于 TCP 要提供可靠的，面向连接的传输服务（TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源），这一难以避免增加了许多开销，如确认，流量控制，计时器以及连接管理等。这不仅使协议数据单元的首部增大很多，还要占用许多处理机资源。TCP 一般用于文件传输、发送和接收邮件、远程登录等场景。
## 四 TCP 协议如何保证可靠传输
@@ -187,7 +187,8 @@ TCP 提供面向连接的服务。在传送数据之前必须先建立连接，
4. TCP 的接收端会丢弃重复的数据。
5. **流量控制：** TCP 连接的每一方都有固定大小的缓冲空间，TCP的接收端只允许发送端发送接收端缓冲区能接纳的数据。当接收方来不及处理发送方的数据，能提示发送方降低发送的速率，防止包丢失。TCP 使用的流量控制协议是可变大小的滑动窗口协议。 （TCP 利用滑动窗口实现流量控制）
6. **拥塞控制：** 当网络拥塞时，减少数据的发送。
-7. **停止等待协议** 也是为了实现可靠传输的，它的基本原理就是每发完一个分组就停止发送，等待对方确认。在收到确认后再发下一个分组。 **超时重传：** 当 TCP 发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。
+7. **停止等待协议** 也是为了实现可靠传输的，它的基本原理就是每发完一个分组就停止发送，等待对方确认。在收到确认后再发下一个分组。
+8. **超时重传：** 当 TCP 发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。
@@ -221,7 +222,7 @@ TCP 提供面向连接的服务。在传送数据之前必须先建立连接，
2. B收到重复的M1后，也直接丢弃重复的M1。
### 自动重传请求 ARQ 协议
-停止等待协议中超时重传是指只要超过一段时间仍然没有收到确认，就重传前面发送过的分组（认为刚才发送过的分组丢失了）。因此每发送完一个分组需要设置一个超时计时器，其重转时间应比数据在分组传输的平均往返时间更长一些。这种自动重传方式常称为自动重传请求ARQ。
+停止等待协议中超时重传是指只要超过一段时间仍然没有收到确认，就重传前面发送过的分组（认为刚才发送过的分组丢失了）。因此每发送完一个分组需要设置一个超时计时器，其重传时间应比数据在分组传输的平均往返时间更长一些。这种自动重传方式常称为自动重传请求ARQ。
**优点：** 简单
diff --git a/docs/operating-system/Shell.md b/docs/operating-system/Shell.md
new file mode 100644
index 00000000000..9f3ae871ee4
--- /dev/null
+++ b/docs/operating-system/Shell.md
@@ -0,0 +1,557 @@
+
+
+
+- [Shell 编程入门](#shell-编程入门)
+ - [走进 Shell 编程的大门](#走进-shell-编程的大门)
+ - [为什么要学Shell？](#为什么要学shell)
+ - [什么是 Shell？](#什么是-shell)
+ - [Shell 编程的 Hello World](#shell-编程的-hello-world)
+ - [Shell 变量](#shell-变量)
+ - [Shell 编程中的变量介绍](#shell-编程中的变量介绍)
+ - [Shell 字符串入门](#shell-字符串入门)
+ - [Shell 字符串常见操作](#shell-字符串常见操作)
+ - [Shell 数组](#shell-数组)
+ - [Shell 基本运算符](#shell-基本运算符)
+ - [算数运算符](#算数运算符)
+ - [关系运算符](#关系运算符)
+ - [逻辑运算符](#逻辑运算符)
+ - [布尔运算符](#布尔运算符)
+ - [字符串运算符](#字符串运算符)
+ - [文件相关运算符](#文件相关运算符)
+ - [shell流程控制](#shell流程控制)
+ - [if 条件语句](#if-条件语句)
+ - [for 循环语句](#for-循环语句)
+ - [while 语句](#while-语句)
+ - [shell 函数](#shell-函数)
+ - [不带参数没有返回值的函数](#不带参数没有返回值的函数)
+ - [有返回值的函数](#有返回值的函数)
+ - [带参数的函数](#带参数的函数)
+
+
+
+# Shell 编程入门
+
+## 走进 Shell 编程的大门
+
+### 为什么要学Shell？
+
+学一个东西，我们大部分情况都是往实用性方向着想。从工作角度来讲，学习 Shell 是为了提高我们自己工作效率，提高产出，让我们在更少的时间完成更多的事情。
+
+很多人会说 Shell 编程属于运维方面的知识了，应该是运维人员来做，我们做后端开发的没必要学。我觉得这种说法大错特错，相比于专门做Linux运维的人员来说，我们对 Shell 编程掌握程度的要求要比他们低，但是shell编程也是我们必须要掌握的！
+
+目前Linux系统下最流行的运维自动化语言就是Shell和Python了。
+
+两者之间，Shell几乎是IT企业必须使用的运维自动化编程语言，特别是在运维工作中的服务监控、业务快速部署、服务启动停止、数据备份及处理、日志分析等环节里，shell是不可缺的。Python 更适合处理复杂的业务逻辑，以及开发复杂的运维软件工具，实现通过web访问等。Shell是一个命令解释器，解释执行用户所输入的命令和程序。一输入命令，就立即回应的交互的对话方式。
+
+另外，了解 shell 编程也是大部分互联网公司招聘后端开发人员的要求。下图是我截取的一些知名互联网公司对于 Shell 编程的要求。
+
+
+
+### 什么是 Shell？
+
+简单来说“Shell编程就是对一堆Linux命令的逻辑化处理”。
+
+
+W3Cschool 上的一篇文章是这样介绍 Shell的，如下图所示。
+
+
+
+### Shell 编程的 Hello World
+
+学习任何一门编程语言第一件事就是输出HelloWord了！下面我会从新建文件到shell代码编写来说下Shell 编程如何输出Hello World。
+
+
+(1)新建一个文件 helloworld.sh :`touch helloworld.sh`，扩展名为 sh（sh代表Shell）（扩展名并不影响脚本执行，见名知意就好，如果你用 php 写 shell 脚本，扩展名就用 php 好了）
+
+(2) 使脚本具有执行权限：`chmod +x helloworld.sh`
+
+(3) 使用 vim 命令修改helloworld.sh文件：`vim helloworld.sh`(vim 文件------>进入文件----->命令模式------>按i进入编辑模式----->编辑文件 ------->按Esc进入底行模式----->输入:wq/q! （输入wq代表写入内容并退出，即保存；输入q!代表强制退出不保存。）)
+
+helloworld.sh 内容如下：
+
+```shell
+#!/bin/bash
+#第一个shell小程序,echo 是linux中的输出命令。
+echo "helloworld!"
+```
+
+shell中 # 符号表示注释。**shell 的第一行比较特殊，一般都会以#!开始来指定使用的 shell 类型。在linux中，除了bash shell以外，还有很多版本的shell， 例如zsh、dash等等...不过bash shell还是我们使用最多的。**
+
+
+(4) 运行脚本:`./helloworld.sh` 。（注意，一定要写成 `./helloworld.sh` ，而不是 `helloworld.sh` ，运行其它二进制的程序也一样，直接写 `helloworld.sh` ，linux 系统会去 PATH 里寻找有没有叫 test.sh 的，而只有 /bin, /sbin, /usr/bin，/usr/sbin 等在 PATH 里，你的当前目录通常不在 PATH 里，所以写成 `helloworld.sh` 是会找不到命令的，要用`./helloworld.sh` 告诉系统说，就在当前目录找。）
+
+
+
+
+## Shell 变量
+
+### Shell 编程中的变量介绍
+
+
+**Shell编程中一般分为三种变量：**
+
+1. **我们自己定义的变量（自定义变量）:** 仅在当前 Shell 实例中有效，其他 Shell 启动的程序不能访问局部变量。
+2. **Linux已定义的环境变量**（环境变量， 例如：$PATH, $HOME 等..., 这类变量我们可以直接使用），使用 `env` 命令可以查看所有的环境变量，而set命令既可以查看环境变量也可以查看自定义变量。
+3. **Shell变量** ：Shell变量是由 Shell 程序设置的特殊变量。Shell 变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了 Shell 的正常运行
+
+**常用的环境变量:**
+> PATH 决定了shell将到哪些目录中寻找命令或程序
+HOME 当前用户主目录
+HISTSIZE 历史记录数
+LOGNAME 当前用户的登录名
+HOSTNAME 指主机的名称
+SHELL 当前用户Shell类型
+LANGUGE 语言相关的环境变量，多语言可以修改此环境变量
+MAIL 当前用户的邮件存放目录
+PS1 基本提示符，对于root用户是#，对于普通用户是$
+
+**使用 Linux 已定义的环境变量：**
+
+比如我们要看当前用户目录可以使用：`echo $HOME`命令；如果我们要看当前用户Shell类型 可以使用`echo $SHELL`命令。可以看出，使用方法非常简单。
+
+**使用自己定义的变量：**
+
+```shell
+#!/bin/bash
+#自定义变量hello
+hello="hello world"
+echo $hello
+echo "helloworld!"
+```
+
+
+
+**Shell 编程中的变量名的命名的注意事项：**
+
+
+- 命名只能使用英文字母，数字和下划线，首个字符不能以数字开头，但是可以使用下划线（_）开头。
+- 中间不能有空格，可以使用下划线（_）。
+- 不能使用标点符号。
+- 不能使用bash里的关键字（可用help命令查看保留关键字）。
+
+
+### Shell 字符串入门
+
+字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号。这点和Java中有所不同。
+
+**单引号字符串：**
+
+```shell
+#!/bin/bash
+name='SnailClimb'
+hello='Hello, I am '$name'!'
+echo $hello
+```
+输出内容：
+
+```
+Hello, I am SnailClimb!
+```
+
+**双引号字符串：**
+
+```shell
+#!/bin/bash
+name='SnailClimb'
+hello="Hello, I am "$name"!"
+echo $hello
+```
+
+输出内容：
+
+```
+Hello, I am SnailClimb!
+```
+
+
+### Shell 字符串常见操作
+
+**拼接字符串：**
+
+```shell
+#!/bin/bash
+name="SnailClimb"
+# 使用双引号拼接
+greeting="hello, "$name" !"
+greeting_1="hello, ${name} !"
+echo $greeting $greeting_1
+# 使用单引号拼接
+greeting_2='hello, '$name' !'
+greeting_3='hello, ${name} !'
+echo $greeting_2 $greeting_3
+```
+
+输出结果：
+
+
+
+
+**获取字符串长度：**
+
+```shell
+#!/bin/bash
+#获取字符串长度
+name="SnailClimb"
+# 第一种方式
+echo ${#name} #输出 10
+# 第二种方式
+expr length "$name";
+```
+
+输出结果:
+```
+10
+10
+```
+
+使用 expr 命令时，表达式中的运算符左右必须包含空格，如果不包含空格，将会输出表达式本身:
+
+```shell
+expr 5+6 // 直接输出 5+6
+expr 5 + 6 // 输出 11
+```
+对于某些运算符，还需要我们使用符号`\`进行转义，否则就会提示语法错误。
+
+```shell
+expr 5 * 6 // 输出错误
+expr 5 \* 6 // 输出30
+```
+
+**截取子字符串:**
+
+简单的字符串截取：
+
+
+```shell
+#从字符串第 1 个字符开始往后截取 10 个字符
+str="SnailClimb is a great man"
+echo ${str:0:10} #输出:SnailClimb
+```
+
+根据表达式截取：
+
+```shell
+#!bin/bash
+#author:amau
+
+var="http://www.runoob.com/linux/linux-shell-variable.html"
+
+s1=${var%%t*}#h
+s2=${var%t*}#http://www.runoob.com/linux/linux-shell-variable.h
+s3=${var%%.*}#http://www
+s4=${var#*/}#/www.runoob.com/linux/linux-shell-variable.html
+s5=${var##*/}#linux-shell-variable.html
+```
+
+### Shell 数组
+
+bash支持一维数组（不支持多维数组），并且没有限定数组的大小。我下面给了大家一个关于数组操作的 Shell 代码示例，通过该示例大家可以知道如何创建数组、获取数组长度、获取/删除特定位置的数组元素、删除整个数组以及遍历数组。
+
+
+```shell
+#!/bin/bash
+array=(1 2 3 4 5);
+# 获取数组长度
+length=${#array[@]}
+# 或者
+length2=${#array[*]}
+#输出数组长度
+echo $length #输出：5
+echo $length2 #输出：5
+# 输出数组第三个元素
+echo ${array[2]} #输出：3
+unset array[1]# 删除下表为1的元素也就是删除第二个元素
+for i in ${array[@]};do echo $i ;done # 遍历数组，输出： 1 3 4 5
+unset arr_number; # 删除数组中的所有元素
+for i in ${array[@]};do echo $i ;done # 遍历数组，数组元素为空，没有任何输出内容
+```
+
+
+## Shell 基本运算符
+
+> 说明：图片来自《菜鸟教程》
+
+ Shell 编程支持下面几种运算符
+
+- 算数运算符
+- 关系运算符
+- 布尔运算符
+- 字符串运算符
+- 文件测试运算符
+
+### 算数运算符
+
+
+
+我以加法运算符做一个简单的示例：
+
+```shell
+#!/bin/bash
+a=3;b=3;
+val=`expr $a + $b`
+#输出：Total value : 6
+echo "Total value : $val
+```
+
+
+### 关系运算符
+
+关系运算符只支持数字，不支持字符串，除非字符串的值是数字。
+
+
+
+通过一个简单的示例演示关系运算符的使用，下面shell程序的作用是当score=100的时候输出A否则输出B。
+
+```shell
+#!/bin/bash
+score=90;
+maxscore=100;
+if [ $score -eq $maxscore ]
+then
+ echo "A"
+else
+ echo "B"
+fi
+```
+
+输出结果：
+
+```
+B
+```
+
+### 逻辑运算符
+
+
+
+示例：
+
+```shell
+#!/bin/bash
+a=$(( 1 && 0))
+# 输出：0；逻辑与运算只有相与的两边都是1，与的结果才是1；否则与的结果是0
+echo $a;
+```
+
+### 布尔运算符
+
+
+
+
+这里就不做演示了，应该挺简单的。
+
+### 字符串运算符
+
+
+
+简单示例：
+
+```shell
+
+#!/bin/bash
+a="abc";
+b="efg";
+if [ $a = $b ]
+then
+ echo "a 等于 b"
+else
+ echo "a 不等于 b"
+fi
+```
+输出：
+
+```
+a 不等于 b
+```
+
+### 文件相关运算符
+
+
+
+使用方式很简单，比如我们定义好了一个文件路径`file="/usr/learnshell/test.sh"` 如果我们想判断这个文件是否可读，可以这样`if [ -r $file ]` 如果想判断这个文件是否可写，可以这样`-w $file`，是不是很简单。
+
+## shell流程控制
+
+### if 条件语句
+
+简单的 if else-if else 的条件语句示例
+
+```shell
+#!/bin/bash
+a=3;
+b=9;
+if [ $a = $b ]
+then
+ echo "a 等于 b"
+elif [ $a > $b ]
+then
+ echo "a 大于 b"
+else
+ echo "a 小于 b"
+fi
+```
+
+输出结果：
+
+```
+a 大于 b
+```
+
+相信大家通过上面的示例就已经掌握了 shell 编程中的 if 条件语句。不过，还要提到的一点是，不同于我们常见的 Java 以及 PHP 中的 if 条件语句，shell if 条件语句中不能包含空语句也就是什么都不做的语句。
+
+### for 循环语句
+
+通过下面三个简单的示例认识 for 循环语句最基本的使用，实际上 for 循环语句的功能比下面你看到的示例展现的要大得多。
+
+**输出当前列表中的数据：**
+
+```shell
+for loop in 1 2 3 4 5
+do
+ echo "The value is: $loop"
+done
+```
+
+**产生 10 个随机数：**
+
+```shell
+#!/bin/bash
+for i in {0..9};
+do
+ echo $RANDOM;
+done
+```
+
+**输出1到5:**
+
+通常情况下 shell 变量调用需要加 $,但是 for 的 (()) 中不需要,下面来看一个例子：
+
+```shell
+#!/bin/bash
+for((i=1;i<=5;i++));do
+ echo $i;
+done;
+```
+
+
+### while 语句
+
+**基本的 while 循环语句：**
+
+```shell
+#!/bin/bash
+int=1
+while(( $int<=5 ))
+do
+ echo $int
+ let "int++"
+done
+```
+
+**while循环可用于读取键盘信息：**
+
+```shell
+echo '按下 退出'
+echo -n '输入你最喜欢的电影: '
+while read FILM
+do
+ echo "是的！$FILM 是一个好电影"
+done
+```
+
+输出内容:
+
+```
+按下 退出
+输入你最喜欢的电影: 变形金刚
+是的！变形金刚 是一个好电影
+```
+
+**无线循环：**
+
+```shell
+while true
+do
+ command
+done
+```
+
+## shell 函数
+
+### 不带参数没有返回值的函数
+
+```shell
+#!/bin/bash
+function(){
+ echo "这是我的第一个 shell 函数!"
+}
+function
+```
+
+输出结果：
+
+```
+这是我的第一个 shell 函数!
+```
+
+
+### 有返回值的函数
+
+**输入两个数字之后相加并返回结果：**
+
+```shell
+#!/bin/bash
+funWithReturn(){
+ echo "输入第一个数字: "
+ read aNum
+ echo "输入第二个数字: "
+ read anotherNum
+ echo "两个数字分别为 $aNum 和 $anotherNum !"
+ return $(($aNum+$anotherNum))
+}
+funWithReturn
+echo "输入的两个数字之和为 $?"
+```
+
+输出结果：
+
+```
+输入第一个数字:
+1
+输入第二个数字:
+2
+两个数字分别为 1 和 2 !
+输入的两个数字之和为 3
+```
+
+### 带参数的函数
+
+
+
+```shell
+#!/bin/bash
+funWithParam(){
+ echo "第一个参数为 $1 !"
+ echo "第二个参数为 $2 !"
+ echo "第十个参数为 $10 !"
+ echo "第十个参数为 ${10} !"
+ echo "第十一个参数为 ${11} !"
+ echo "参数总数有 $# 个!"
+ echo "作为一个字符串输出所有参数 $* !"
+}
+funWithParam 1 2 3 4 5 6 7 8 9 34 73
+
+```
+
+输出结果：
+
+```
+第一个参数为 1 !
+第二个参数为 2 !
+第十个参数为 10 !
+第十个参数为 34 !
+第十一个参数为 73 !
+参数总数有 11 个!
+作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !
+
+```
diff --git "a/\346\223\215\344\275\234\347\263\273\347\273\237/\345\220\216\347\253\257\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\347\232\204Linux\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/operating-system/\345\220\216\347\253\257\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\347\232\204Linux\345\237\272\347\241\200\347\237\245\350\257\206.md"
similarity index 74%
rename from "\346\223\215\344\275\234\347\263\273\347\273\237/\345\220\216\347\253\257\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\347\232\204Linux\345\237\272\347\241\200\347\237\245\350\257\206.md"
rename to "docs/operating-system/\345\220\216\347\253\257\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\347\232\204Linux\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 35edec3742e..d67900ae60f 100644
--- "a/\346\223\215\344\275\234\347\263\273\347\273\237/\345\220\216\347\253\257\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\347\232\204Linux\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/docs/operating-system/\345\220\216\347\253\257\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\347\232\204Linux\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -1,8 +1,31 @@
+
+
+- [一 从认识操作系统开始](#一-从认识操作系统开始)
+ - [1.1 操作系统简介](#11-操作系统简介)
+ - [1.2 操作系统简单分类](#12-操作系统简单分类)
+- [二 初探Linux](#二-初探linux)
+ - [2.1 Linux简介](#21-linux简介)
+ - [2.2 Linux诞生简介](#22-linux诞生简介)
+ - [2.3 Linux的分类](#23-linux的分类)
+- [三 Linux文件系统概览](#三-linux文件系统概览)
+ - [3.1 Linux文件系统简介](#31-linux文件系统简介)
+ - [3.2 文件类型与目录结构](#32-文件类型与目录结构)
+- [四 Linux基本命令](#四-linux基本命令)
+ - [4.1 目录切换命令](#41-目录切换命令)
+ - [4.2 目录的操作命令（增删改查）](#42-目录的操作命令增删改查)
+ - [4.3 文件的操作命令（增删改查）](#43-文件的操作命令增删改查)
+ - [4.4 压缩文件的操作命令](#44-压缩文件的操作命令)
+ - [4.5 Linux的权限命令](#45-linux的权限命令)
+ - [4.6 Linux 用户管理](#46-linux-用户管理)
+ - [4.7 Linux系统用户组的管理](#47-linux系统用户组的管理)
+ - [4.8 其他常用命令](#48-其他常用命令)
+
+
> 学习Linux之前，我们先来简单的认识一下操作系统。
## 一 从认识操作系统开始
-### 1.1 操作系统简介
+### 1.1 操作系统简介
我通过以下四点介绍什么操作系统：
@@ -12,7 +35,7 @@
- **操作系统分内核与外壳（我们可以把外壳理解成围绕着内核的应用程序，而内核就是能操作硬件的程序）。**
-### 1.2 操作系统简单分类
+### 1.2 操作系统简单分类
1. **Windows:** 目前最流行的个人桌面操作系统 ，不做多的介绍，大家都清楚。
2. **Unix：** 最早的多用户、多任务操作系统 .按照操作系统的分类，属于分时操作系统。Unix 大多被用在服务器、工作站，现在也有用在个人计算机上。它在创建互联网、计算机网络或客户端/服务器模型方面发挥着非常重要的作用。
@@ -22,7 +45,7 @@
-## 二 初探Linux
+## 二 初探Linux
### 2.1 Linux简介
@@ -33,7 +56,7 @@
-### 2.2 Linux诞生简介
+### 2.2 Linux诞生简介
- 1991年，芬兰的业余计算机爱好者Linus Torvalds编写了一款类似Minix的系统（基于微内核架构的类Unix操作系统）被ftp管理员命名为Linux 加入到自由软件基金的GNU计划中;
- Linux以一只可爱的企鹅作为标志，象征着敢作敢为、热爱生活。
@@ -48,7 +71,7 @@
-## 三 Linux文件系统概览
+## 三 Linux文件系统概览
### 3.1 Linux文件系统简介
@@ -69,40 +92,40 @@ Linux文件系统的结构层次鲜明，就像一棵倒立的树，最顶层是
**常见目录说明：**
-- **/bin：** 存放二进制可执行文件(ls,cat,mkdir等)，常用命令一般都在这里；
+- **/bin：** 存放二进制可执行文件(ls、cat、mkdir等)，常用命令一般都在这里；
- **/etc：** 存放系统管理和配置文件；
- **/home：** 存放所有用户文件的根目录，是用户主目录的基点，比如用户user的主目录就是/home/user，可以用~user表示；
- **/usr ：** 用于存放系统应用程序；
- **/opt：** 额外安装的可选应用程序包所放置的位置。一般情况下，我们可以把tomcat等都安装到这里；
- **/proc：** 虚拟文件系统目录，是系统内存的映射。可直接访问这个目录来获取系统信息；
-- **/root：** 超级用户（系统管理员）的主目录（特权阶级^o^）；
-- **/sbin:** 存放二进制可执行文件，只有root才能访问。这里存放的是系统管理员使用的系统级别的管理命令和程序。如ifconfig等；
-- **/dev：** 用于存放设备文件；
-- **/mnt：** 系统管理员安装临时文件系统的安装点，系统提供这个目录是让用户临时挂载其他的文件系统；
-- **/boot：** 存放用于系统引导时使用的各种文件；
+- **/root：** 超级用户（系统管理员）的主目录（特权阶级^o^）；
+- **/sbin:** 存放二进制可执行文件，只有root才能访问。这里存放的是系统管理员使用的系统级别的管理命令和程序。如ifconfig等；
+- **/dev：** 用于存放设备文件；
+- **/mnt：** 系统管理员安装临时文件系统的安装点，系统提供这个目录是让用户临时挂载其他的文件系统；
+- **/boot：** 存放用于系统引导时使用的各种文件；
- **/lib ：** 存放着和系统运行相关的库文件 ；
-- **/tmp：** 用于存放各种临时文件，是公用的临时文件存储点；
-- **/var：** 用于存放运行时需要改变数据的文件，也是某些大文件的溢出区，比方说各种服务的日志文件（系统启动日志等。）等；
-- **/lost+found：** 这个目录平时是空的，系统非正常关机而留下“无家可归”的文件（windows下叫什么.chk）就在这里。
+- **/tmp：** 用于存放各种临时文件，是公用的临时文件存储点；
+- **/var：** 用于存放运行时需要改变数据的文件，也是某些大文件的溢出区，比方说各种服务的日志文件（系统启动日志等。）等；
+- **/lost+found：** 这个目录平时是空的，系统非正常关机而留下“无家可归”的文件（windows下叫什么.chk）就在这里。
-## 四 Linux基本命令
+## 四 Linux基本命令
下面只是给出了一些比较常用的命令。推荐一个Linux命令快查网站，非常不错，大家如果遗忘某些命令或者对某些命令不理解都可以在这里得到解决。
Linux命令大全：[http://man.linuxde.net/](http://man.linuxde.net/)
### 4.1 目录切换命令
-- **`cd usr`：** 切换到该目录下usr目录
-- **`cd ..（或cd../）`：** 切换到上一层目录
-- **`cd /`：** 切换到系统根目录
-- **`cd ~`：** 切换到用户主目录
-- **`cd -`：** 切换到上一个所在目录
+- **`cd usr`：** 切换到该目录下usr目录
+- **`cd ..（或cd../）`：** 切换到上一层目录
+- **`cd /`：** 切换到系统根目录
+- **`cd ~`：** 切换到用户主目录
+- **`cd -`：** 切换到上一个操作所在目录
-### 4.2 目录的操作命令（增删改查）
+### 4.2 目录的操作命令(增删改查)
1. **`mkdir 目录名称`：** 增加目录
-2. **`ls或者ll`**（ll是ls -l的缩写，ll命令以看到该目录下的所有目录和文件的详细信息）：查看目录信息
+2. **`ls或者ll`**（ll是ls -l的别名，ll命令可以看到该目录下的所有目录和文件的详细信息）：查看目录信息
3. **`find 目录 参数`：** 寻找目录（查）
示例：
@@ -114,35 +137,35 @@ Linux命令大全：[http://man.linuxde.net/](http://man.linuxde.net/)
4. **`mv 目录名称 新目录名称`：** 修改目录的名称（改）
- 注意：mv的语法不仅可以对目录进行重命名而且也可以对各种文件，压缩包等进行 重命名的操作。mv命令用来对文件或目录重新命名，或者将文件从一个目录移到另一个目录中。后面会介绍到mv命令的另一个用法。
+ 注意：mv的语法不仅可以对目录进行重命名而且也可以对各种文件，压缩包等进行 重命名的操作。mv命令用来对文件或目录重新命名，或者将文件从一个目录移到另一个目录中。后面会介绍到mv命令的另一个用法。
5. **`mv 目录名称 目录的新位置`：** 移动目录的位置---剪切（改）
注意：mv语法不仅可以对目录进行剪切操作，对文件和压缩包等都可执行剪切操作。另外mv与cp的结果不同，mv好像文件“搬家”，文件个数并未增加。而cp对文件进行复制，文件个数增加了。
6. **`cp -r 目录名称 目录拷贝的目标位置`：** 拷贝目录（改），-r代表递归拷贝
- 注意：cp命令不仅可以拷贝目录还可以拷贝文件，压缩包等，拷贝文件和压缩包时不 用写-r递归
+ 注意：cp命令不仅可以拷贝目录还可以拷贝文件，压缩包等，拷贝文件和压缩包时不 用写-r递归
7. **`rm [-rf] 目录`:** 删除目录（删）
- 注意：rm不仅可以删除目录，也可以删除其他文件或压缩包，为了增强大家的记忆， 无论删除任何目录或文件，都直接使用`rm -rf` 目录/文件/压缩包
+ 注意：rm不仅可以删除目录，也可以删除其他文件或压缩包，为了增强大家的记忆， 无论删除任何目录或文件，都直接使用`rm -rf` 目录/文件/压缩包
-### 4.3 文件的操作命令（增删改查）
+### 4.3 文件的操作命令(增删改查)
1. **`touch 文件名称`:** 文件的创建（增）
2. **`cat/more/less/tail 文件名称`** 文件的查看（查）
- - **`cat`：** 只能显示最后一屏内容
- - **`more`：** 可以显示百分比，回车可以向下一行， 空格可以向下一页，q可以退出查看
- - **`less`：** 可以使用键盘上的PgUp和PgDn向上 和向下翻页，q结束查看
+ - **`cat`：** 查看显示文件内容
+ - **`more`：** 可以显示百分比，回车可以向下一行， 空格可以向下一页，q可以退出查看
+ - **`less`：** 可以使用键盘上的PgUp和PgDn向上 和向下翻页，q结束查看
- **`tail-10` ：** 查看文件的后10行，Ctrl+C结束
- 注意：命令 tail -f 文件 可以对某个文件进行动态监控，例如tomcat的日志文件， 会随着程序的运行，日志会变化，可以使用tail -f catalina-2016-11-11.log 监控 文 件的变化
+ 注意：命令 tail -f 文件 可以对某个文件进行动态监控，例如tomcat的日志文件， 会随着程序的运行，日志会变化，可以使用tail -f catalina-2016-11-11.log 监控 文 件的变化
3. **`vim 文件`：** 修改文件的内容（改）
vim编辑器是Linux中的强大组件，是vi编辑器的加强版，vim编辑器的命令和快捷方式有很多，但此处不一一阐述，大家也无需研究的很透彻，使用vim编辑修改文件的方式基本会使用就可以了。
**在实际开发中，使用vim编辑器主要作用就是修改配置文件，下面是一般步骤：**
- vim 文件------>进入文件----->命令模式------>按i进入编辑模式----->编辑文件 ------->按Esc进入底行模式----->输入:wq/q! （输入wq代表写入内容并退出，即保存；输入q!代表强制退出不保存。）
+ vim 文件------>进入文件----->命令模式------>按i进入编辑模式----->编辑文件 ------->按Esc进入底行模式----->输入：wq/q! （输入wq代表写入内容并退出，即保存；输入q!代表强制退出不保存。）
4. **`rm -rf 文件`：** 删除文件（删）
同目录删除：熟记 `rm -rf` 文件 即可
@@ -165,7 +188,7 @@ Linux中的打包文件一般是以.tar结尾的，压缩的命令一般是以.g
f：指定文件名
-比如：加入test目录下有三个文件分别是 :aaa.txt bbb.txt ccc.txt,如果我们要打包test目录并指定压缩后的压缩包名称为test.tar.gz可以使用命令：**`tar -zcvf test.tar.gz aaa.txt bbb.txt ccc.txt`或：`tar -zcvf test.tar.gz /test/`**
+比如：加入test目录下有三个文件分别是：aaa.txt bbb.txt ccc.txt，如果我们要打包test目录并指定压缩后的压缩包名称为test.tar.gz可以使用命令：**`tar -zcvf test.tar.gz aaa.txt bbb.txt ccc.txt`或：`tar -zcvf test.tar.gz /test/`**
**2）解压压缩包：**
@@ -183,7 +206,7 @@ Linux中的打包文件一般是以.tar结尾的，压缩的命令一般是以.g
### 4.5 Linux的权限命令
- 操作系统中每个文件都拥有特定的权限、所属用户和所属组。权限是操作系统用来限制资源访问的机制，在Linux中权限一般分为读(readable)、写(writable)和执行(excutable)，分为三组。分别对应文件的属主(owner)，属组(group)和其他用户(other)，通过这样的机制来限制哪些用户、哪些组可以对特定的文件进行什么样的操作。通过 **`ls -l`** 命令我们可以 查看某个目录下的文件或目录的权限
+ 操作系统中每个文件都拥有特定的权限、所属用户和所属组。权限是操作系统用来限制资源访问的机制，在Linux中权限一般分为读(readable)、写(writable)和执行(excutable)，分为三组。分别对应文件的属主(owner)，属组(group)和其他用户(other)，通过这样的机制来限制哪些用户、哪些组可以对特定的文件进行什么样的操作。通过 **`ls -l`** 命令我们可以 查看某个目录下的文件或目录的权限
示例：在随意某个目录下`ls -l`
@@ -200,7 +223,7 @@ Linux中的打包文件一般是以.tar结尾的，压缩的命令一般是以.g
- d： 代表目录
- -： 代表文件
-- l： 代表链接（可以认为是window中的快捷方式）
+- l： 代表软链接（可以认为是window中的快捷方式）
**Linux中权限分为以下几种：**
@@ -230,7 +253,7 @@ Linux中的打包文件一般是以.tar结尾的，压缩的命令一般是以.g
| x | 可以使用cd进入目录 |
-
+**需要注意的是超级用户可以无视普通用户的权限，即使文件目录权限是000，依旧可以访问。**
**在linux中的每个用户必须属于一个组，不能独立于组外。在linux中每个文件有所有者、所在组、其它组的概念。**
- **所有者**
@@ -304,7 +327,7 @@ passwd命令用于设置用户的认证信息，包括用户密码、密码过
- **`pwd`：** 显示当前所在位置
- **`grep 要搜索的字符串 要搜索的文件 --color`：** 搜索命令，--color代表高亮显示
-- **`ps -ef`/`ps aux`：** 这两个命令都是查看当前系统正在运行进程，两者的区别是展示格式不同。如果想要查看特定的进程可以使用这样的格式：**`ps aux|grep redis`** （查看包括redis字符串的进程）
+- **`ps -ef`/`ps -aux`：** 这两个命令都是查看当前系统正在运行进程，两者的区别是展示格式不同。如果想要查看特定的进程可以使用这样的格式：**`ps aux|grep redis`** （查看包括redis字符串的进程），也可使用 `pgrep redis -a`。
注意：如果直接用ps（（Process Status））命令，会显示所有进程的状态，通常结合grep命令查看某进程的状态。
- **`kill -9 进程的pid`：** 杀死进程（-9 表示强制终止。）
@@ -314,7 +337,9 @@ passwd命令用于设置用户的认证信息，包括用户密码、密码过
- 查看当前系统的网卡信息：ifconfig
- 查看与某台机器的连接情况：ping
- 查看当前系统的端口使用：netstat -an
-- **`shutdown`：** `shutdown -h now`： 指定现在立即关机；`shutdown +5 "System will shutdown after 5 minutes"`:指定5分钟后关机，同时送出警告信息给登入用户。
+- **net-tools 和 iproute2 ：**
+ `net-tools`起源于BSD的TCP/IP工具箱，后来成为老版本Linux内核中配置网络功能的工具。但自2001年起，Linux社区已经对其停止维护。同时，一些Linux发行版比如Arch Linux和CentOS/RHEL 7则已经完全抛弃了net-tools，只支持`iproute2`。linux ip命令类似于ifconfig，但功能更强大，旨在替代它。更多详情请阅读[如何在Linux中使用IP命令和示例](https://linoxide.com/linux-command/use-ip-command-linux)
+- **`shutdown`：** `shutdown -h now`： 指定现在立即关机；`shutdown +5 "System will shutdown after 5 minutes"`：指定5分钟后关机，同时送出警告信息给登入用户。
- **`reboot`：** **`reboot`：** 重开机。**`reboot -w`：** 做个重开机的模拟（只有纪录并不会真的重开机）。
diff --git a/docs/system-design/data-communication/dubbo.md b/docs/system-design/data-communication/dubbo.md
new file mode 100644
index 00000000000..17a08d8853a
--- /dev/null
+++ b/docs/system-design/data-communication/dubbo.md
@@ -0,0 +1,282 @@
+本文是作者根据官方文档以及自己平时的使用情况，对 Dubbo 所做的一个总结。如果不懂 Dubbo 的使用的话，可以参考我的这篇文章[《超详细，新手都能看懂 ！使用SpringBoot+Dubbo 搭建一个简单的分布式服务》](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484706&idx=1&sn=d413fc17023482f67ca17cb6756b9ff8&chksm=fd985343caefda555969568fdf4734536e0a1745f9de337d434a7dbd04e893bd2d75f3641aab&token=1902169190&lang=zh_CN#rd)
+
+Dubbo 官网：http://dubbo.apache.org/zh-cn/index.html
+
+Dubbo 中文文档： http://dubbo.apache.org/zh-cn/index.html
+
+
+
+- [一 重要的概念](#一-重要的概念)
+ - [1.1 什么是 Dubbo?](#11-什么是-dubbo)
+ - [1.2 什么是 RPC?RPC原理是什么?](#12-什么是-rpcrpc原理是什么)
+ - [1.3 为什么要用 Dubbo?](#13-为什么要用-dubbo)
+ - [1.4 什么是分布式?](#14-什么是分布式)
+ - [1.5 为什么要分布式?](#15-为什么要分布式)
+- [二 Dubbo 的架构](#二-dubbo-的架构)
+ - [2.1 Dubbo 的架构图解](#21-dubbo-的架构图解)
+ - [2.2 Dubbo 工作原理](#22-dubbo-工作原理)
+- [三 Dubbo 的负载均衡策略](#三-dubbo-的负载均衡策略)
+ - [3.1 先来解释一下什么是负载均衡](#31-先来解释一下什么是负载均衡)
+ - [3.2 再来看看 Dubbo 提供的负载均衡策略](#32-再来看看-dubbo-提供的负载均衡策略)
+ - [3.2.1 Random LoadBalance\(默认，基于权重的随机负载均衡机制\)](#321-random-loadbalance默认基于权重的随机负载均衡机制)
+ - [3.2.2 RoundRobin LoadBalance\(不推荐，基于权重的轮询负载均衡机制\)](#322-roundrobin-loadbalance不推荐基于权重的轮询负载均衡机制)
+ - [3.2.3 LeastActive LoadBalance](#323-leastactive-loadbalance)
+ - [3.2.4 ConsistentHash LoadBalance](#324-consistenthash-loadbalance)
+ - [3.3 配置方式](#33-配置方式)
+- [四 zookeeper宕机与dubbo直连的情况](#四-zookeeper宕机与dubbo直连的情况)
+
+
+
+
+## 一 重要的概念
+
+### 1.1 什么是 Dubbo?
+
+Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC 框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。简单来说 Dubbo 是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。
+
+Dubbo 目前已经有接近 23k 的 Star ，Dubbo的Github 地址：[https://github.com/apache/incubator-dubbo](https://github.com/apache/incubator-dubbo) 。 另外，在开源中国举行的2018年度最受欢迎中国开源软件这个活动的评选中，Dubbo 更是凭借其超高人气仅次于 vue.js 和 ECharts 获得第三名的好成绩。
+
+Dubbo 是由阿里开源，后来加入了 Apache 。正式由于 Dubbo 的出现，才使得越来越多的公司开始使用以及接受分布式架构。
+
+**我们上面说了 Dubbo 实际上是 RPC 框架，那么什么是 RPC呢？**
+
+### 1.2 什么是 RPC?RPC原理是什么?
+
+**什么是 RPC？**
+
+RPC（Remote Procedure Call）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。比如两个不同的服务 A、B 部署在两台不同的机器上，那么服务 A 如果想要调用服务 B 中的某个方法该怎么办呢？使用 HTTP请求 当然可以，但是可能会比较慢而且一些优化做的并不好。 RPC 的出现就是为了解决这个问题。
+
+**RPC原理是什么？**
+
+我这里这是简单的提一下。详细内容可以查看下面这篇文章：
+
+[http://www.importnew.com/22003.html](http://www.importnew.com/22003.html)
+
+
+
+
+1. 服务消费方（client）调用以本地调用方式调用服务；
+2. client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
+3. client stub找到服务地址，并将消息发送到服务端；
+4. server stub收到消息后进行解码；
+5. server stub根据解码结果调用本地的服务；
+6. 本地服务执行并将结果返回给server stub；
+7. server stub将返回结果打包成消息并发送至消费方；
+8. client stub接收到消息，并进行解码；
+9. 服务消费方得到最终结果。
+
+下面再贴一个网上的时序图：
+
+
+
+**说了这么多，我们为什么要用 Dubbo 呢？**
+
+### 1.3 为什么要用 Dubbo?
+
+Dubbo 的诞生和 SOA 分布式架构的流行有着莫大的关系。SOA 面向服务的架构（Service Oriented Architecture），也就是把工程按照业务逻辑拆分成服务层、表现层两个工程。服务层中包含业务逻辑，只需要对外提供服务即可。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。SOA架构中有两个主要角色：服务提供者（Provider）和服务使用者（Consumer）。
+
+
+
+**如果你要开发分布式程序，你也可以直接基于 HTTP 接口进行通信，但是为什么要用 Dubbo呢？**
+
+我觉得主要可以从 Dubbo 提供的下面四点特性来说为什么要用 Dubbo：
+
+1. **负载均衡**——同一个服务部署在不同的机器时该调用那一台机器上的服务。
+2. **服务调用链路生成**——随着系统的发展，服务越来越多，服务间依赖关系变得错踪复杂，甚至分不清哪个应用要在哪个应用之前启动，架构师都不能完整的描述应用的架构关系。Dubbo 可以为我们解决服务之间互相是如何调用的。
+3. **服务访问压力以及时长统计、资源调度和治理**——基于访问压力实时管理集群容量，提高集群利用率。
+4. **服务降级**——某个服务挂掉之后调用备用服务。
+
+另外，Dubbo 除了能够应用在分布式系统中，也可以应用在现在比较火的微服务系统中。不过，由于 Spring Cloud 在微服务中应用更加广泛，所以，我觉得一般我们提 Dubbo 的话，大部分是分布式系统的情况。
+
+**我们刚刚提到了分布式这个概念，下面再给大家介绍一下什么是分布式？为什么要分布式？**
+
+### 1.4 什么是分布式?
+
+分布式或者说 SOA 分布式重要的就是面向服务，说简单的分布式就是我们把整个系统拆分成不同的服务然后将这些服务放在不同的服务器上减轻单体服务的压力提高并发量和性能。比如电商系统可以简单地拆分成订单系统、商品系统、登录系统等等，拆分之后的每个服务可以部署在不同的机器上，如果某一个服务的访问量比较大的话也可以将这个服务同时部署在多台机器上。
+
+### 1.5 为什么要分布式?
+
+从开发角度来讲单体应用的代码都集中在一起，而分布式系统的代码根据业务被拆分。所以，每个团队可以负责一个服务的开发，这样提升了开发效率。另外，代码根据业务拆分之后更加便于维护和扩展。
+
+另外，我觉得将系统拆分成分布式之后不光便于系统扩展和维护，更能提高整个系统的性能。你想一想嘛？把整个系统拆分成不同的服务/系统，然后每个服务/系统 单独部署在一台服务器上，是不是很大程度上提高了系统性能呢？
+
+## 二 Dubbo 的架构
+
+### 2.1 Dubbo 的架构图解
+
+
+
+**上述节点简单说明：**
+
+- **Provider：** 暴露服务的服务提供方
+- **Consumer：** 调用远程服务的服务消费方
+- **Registry：** 服务注册与发现的注册中心
+- **Monitor：** 统计服务的调用次数和调用时间的监控中心
+- **Container：** 服务运行容器
+
+**调用关系说明：**
+
+1. 服务容器负责启动，加载，运行服务提供者。
+2. 服务提供者在启动时，向注册中心注册自己提供的服务。
+3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
+4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
+5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
+6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。
+
+**重要知识点总结：**
+
+- **注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小**
+- **监控中心负责统计各服务调用次数，调用时间等，统计先在内存汇总后每分钟一次发送到监控中心服务器，并以报表展示**
+- **注册中心，服务提供者，服务消费者三者之间均为长连接，监控中心除外**
+- **注册中心通过长连接感知服务提供者的存在，服务提供者宕机，注册中心将立即推送事件通知消费者**
+- **注册中心和监控中心全部宕机，不影响已运行的提供者和消费者，消费者在本地缓存了提供者列表**
+- **注册中心和监控中心都是可选的，服务消费者可以直连服务提供者**
+- **服务提供者无状态，任意一台宕掉后，不影响使用**
+- **服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复**
+
+
+
+
+
+### 2.2 Dubbo 工作原理
+
+
+
+
+图中从下至上分为十层，各层均为单向依赖，右边的黑色箭头代表层之间的依赖关系，每一层都可以剥离上层被复用，其中，Service 和 Config 层为 API，其它各层均为 SPI。
+
+**各层说明**：
+
+- 第一层：**service层**，接口层，给服务提供者和消费者来实现的
+- 第二层：**config层**，配置层，主要是对dubbo进行各种配置的
+- 第三层：**proxy层**，服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton
+- 第四层：**registry层**，服务注册层，负责服务的注册与发现
+- 第五层：**cluster层**，集群层，封装多个服务提供者的路由以及负载均衡，将多个实例组合成一个服务
+- 第六层：**monitor层**，监控层，对rpc接口的调用次数和调用时间进行监控
+- 第七层：**protocol层**，远程调用层，封装rpc调用
+- 第八层：**exchange层**，信息交换层，封装请求响应模式，同步转异步
+- 第九层：**transport层**，网络传输层，抽象mina和netty为统一接口
+- 第十层：**serialize层**，数据序列化层，网络传输需要
+
+
+## 三 Dubbo 的负载均衡策略
+
+### 3.1 先来解释一下什么是负载均衡
+
+**先来个官方的解释。**
+
+> 维基百科对负载均衡的定义：负载均衡改善了跨多个计算资源（例如计算机，计算机集群，网络链接，中央处理单元或磁盘驱动的的工作负载分布。负载平衡旨在优化资源使用，最大化吞吐量，最小化响应时间，并避免任何单个资源的过载。使用具有负载平衡而不是单个组件的多个组件可以通过冗余提高可靠性和可用性。负载平衡通常涉及专用软件或硬件。
+
+**上面讲的大家可能不太好理解，再用通俗的话给大家说一下。**
+
+比如我们的系统中的某个服务的访问量特别大，我们将这个服务部署在了多台服务器上，当客户端发起请求的时候，多台服务器都可以处理这个请求。那么，如何正确选择处理该请求的服务器就很关键。假如，你就要一台服务器来处理该服务的请求，那该服务部署在多台服务器的意义就不复存在了。负载均衡就是为了避免单个服务器响应同一请求，容易造成服务器宕机、崩溃等问题，我们从负载均衡的这四个字就能明显感受到它的意义。
+
+### 3.2 再来看看 Dubbo 提供的负载均衡策略
+
+在集群负载均衡时，Dubbo 提供了多种均衡策略，默认为 `random` 随机调用。可以自行扩展负载均衡策略，参见：[负载均衡扩展](https://dubbo.gitbooks.io/dubbo-dev-book/content/impls/load-balance.html)。
+
+备注:下面的图片来自于：尚硅谷2018Dubbo 视频。
+
+
+#### 3.2.1 Random LoadBalance(默认，基于权重的随机负载均衡机制)
+
+- **随机，按权重设置随机概率。**
+- 在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。
+
+
+
+
+
+#### 3.2.2 RoundRobin LoadBalance(不推荐，基于权重的轮询负载均衡机制)
+
+- 轮循，按公约后的权重设置轮循比率。
+- 存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。
+
+
+
+#### 3.2.3 LeastActive LoadBalance
+
+- 最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
+- 使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
+
+#### 3.2.4 ConsistentHash LoadBalance
+
+- **一致性 Hash，相同参数的请求总是发到同一提供者。(如果你需要的不是随机负载均衡，是要一类请求都到一个节点，那就走这个一致性hash策略。)**
+- 当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。
+- 算法参见：http://en.wikipedia.org/wiki/Consistent_hashing
+- 缺省只对第一个参数 Hash，如果要修改，请配置 ``
+- 缺省用 160 份虚拟节点，如果要修改，请配置 ``
+
+### 3.3 配置方式
+
+**xml 配置方式**
+
+服务端服务级别
+
+```java
+
+```
+客户端服务级别
+
+```java
+
+```
+
+服务端方法级别
+
+```java
+
+
+
+```
+
+客户端方法级别
+
+```java
+
+
+
+```
+
+**注解配置方式：**
+
+消费方基于基于注解的服务级别配置方式：
+
+```java
+@Reference(loadbalance = "roundrobin")
+HelloService helloService;
+```
+
+## 四 zookeeper宕机与dubbo直连的情况
+
+zookeeper宕机与dubbo直连的情况在面试中可能会被经常问到，所以要引起重视。
+
+在实际生产中，假如zookeeper注册中心宕掉，一段时间内服务消费方还是能够调用提供方的服务的，实际上它使用的本地缓存进行通讯，这只是dubbo健壮性的一种提现。
+
+**dubbo的健壮性表现：**
+
+1. 监控中心宕掉不影响使用，只是丢失部分采样数据
+2. 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
+3. 注册中心对等集群，任意一台宕掉后，将自动切换到另一台
+4. 注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
+5. 服务提供者无状态，任意一台宕掉后，不影响使用
+5. 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复
+
+我们前面提到过：注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小。所以，我们可以完全可以绕过注册中心——采用 **dubbo 直连** ，即在服务消费方配置服务提供方的位置信息。
+
+
+**xml配置方式：**
+
+```xml
+
+```
+
+**注解方式：**
+
+```java
+ @Reference(url = "127.0.0.1:20880")
+ HelloService helloService;
+```
+
+
+
diff --git a/docs/system-design/data-communication/message-queue.md b/docs/system-design/data-communication/message-queue.md
new file mode 100644
index 00000000000..2d9bed8bdaa
--- /dev/null
+++ b/docs/system-design/data-communication/message-queue.md
@@ -0,0 +1,156 @@
+
+
+- [消息队列其实很简单](#消息队列其实很简单)
+ - [一 什么是消息队列](#一-什么是消息队列)
+ - [二 为什么要用消息队列](#二-为什么要用消息队列)
+ - [\(1\) 通过异步处理提高系统性能（削峰、减少响应所需时间）](#1-通过异步处理提高系统性能削峰减少响应所需时间)
+ - [\(2\) 降低系统耦合性](#2-降低系统耦合性)
+ - [三 使用消息队列带来的一些问题](#三-使用消息队列带来的一些问题)
+ - [四 JMS VS AMQP](#四-jms-vs-amqp)
+ - [4.1 JMS](#41-jms)
+ - [4.1.1 JMS 简介](#411-jms-简介)
+ - [4.1.2 JMS两种消息模型](#412-jms两种消息模型)
+ - [4.1.3 JMS 五种不同的消息正文格式](#413-jms-五种不同的消息正文格式)
+ - [4.2 AMQP](#42-amqp)
+ - [4.3 JMS vs AMQP](#43-jms-vs-amqp)
+ - [五 常见的消息队列对比](#五-常见的消息队列对比)
+
+
+
+
+# 消息队列其实很简单
+
+ “RabbitMQ？”“Kafka？”“RocketMQ？”...在日常学习与开发过程中，我们常常听到消息队列这个关键词。我也在我的多篇文章中提到了这个概念。可能你是熟练使用消息队列的老手，又或者你是不懂消息队列的新手，不论你了不了解消息队列，本文都将带你搞懂消息队列的一些基本理论。如果你是老手，你可能从本文学到你之前不曾注意的一些关于消息队列的重要概念，如果你是新手，相信本文将是你打开消息队列大门的一板砖。
+
+## 一 什么是消息队列
+
+ 我们可以把消息队列比作是一个存放消息的容器，当我们需要使用消息的时候可以取出消息供自己使用。消息队列是分布式系统中重要的组件，使用消息队列主要是为了通过异步处理提高系统性能和削峰、降低系统耦合性。目前使用较多的消息队列有ActiveMQ，RabbitMQ，Kafka，RocketMQ，我们后面会一一对比这些消息队列。
+
+ 另外，我们知道队列 Queue 是一种先进先出的数据结构，所以消费消息时也是按照顺序来消费的。比如生产者发送消息1,2,3...对于消费者就会按照1,2,3...的顺序来消费。但是偶尔也会出现消息被消费的顺序不对的情况，比如某个消息消费失败又或者一个 queue 多个consumer 也会导致消息被消费的顺序不对，我们一定要保证消息被消费的顺序正确。
+
+ 除了上面说的消息消费顺序的问题，使用消息队列，我们还要考虑如何保证消息不被重复消费？如何保证消息的可靠性传输（如何处理消息丢失的问题）？......等等问题。所以说使用消息队列也不是十全十美的，使用它也会让系统可用性降低、复杂度提高，另外需要我们保障一致性等问题。
+
+## 二 为什么要用消息队列
+
+ 我觉得使用消息队列主要有两点好处：1.通过异步处理提高系统性能（削峰、减少响应所需时间）;2.降低系统耦合性。如果在面试的时候你被面试官问到这个问题的话，一般情况是你在你的简历上涉及到消息队列这方面的内容，这个时候推荐你结合你自己的项目来回答。
+
+
+ 《大型网站技术架构》第四章和第七章均有提到消息队列对应用性能及扩展性的提升。
+
+### (1) 通过异步处理提高系统性能（削峰、减少响应所需时间）
+
+
+ 如上图，**在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即 返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。**
+
+ 通过以上分析我们可以得出**消息队列具有很好的削峰作用的功能**——即**通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。** 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：
+
+
+ 因为**用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败**。因此使用消息队列进行异步处理之后，需要**适当修改业务流程进行配合**，比如**用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功**，以免交易纠纷。这就类似我们平时手机订火车票和电影票。
+
+### (2) 降低系统耦合性
+
+ 我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。
+
+ 我们最常见的**事件驱动架构**类似生产者消费者模式，在大型网站中通常用利用消息队列实现事件驱动结构。如下图所示：
+
+
+
+ **消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。** 从上图可以看到**消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合**，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。**对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计**。
+
+ 消息接受者对消息进行过滤、处理、包装后，构造成一个新的消息类型，将消息继续发送出去，等待其他消息接受者订阅该消息。因此基于事件（消息对象）驱动的业务架构可以是一系列流程。
+
+ **另外为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。**
+
+**备注：** 不要认为消息队列只能利用发布-订阅模式工作，只不过在解耦这个特定业务环境下是使用发布-订阅模式的。**除了发布-订阅模式，还有点对点订阅模式（一个消息只有一个消费者），我们比较常用的是发布-订阅模式。** 另外，这两种消息模型是 JMS 提供的，AMQP 协议还提供了 5 种消息模型。
+
+## 三 使用消息队列带来的一些问题
+
+- **系统可用性降低：** 系统可用性在某种程度上降低，为什么这样说呢？在加入MQ之前，你不用考虑消息丢失或者说MQ挂掉等等的情况，但是，引入MQ之后你就需要去考虑了！
+- **系统复杂性提高：** 加入MQ之后，你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题！
+- **一致性问题：** 我上面讲了消息队列可以实现异步，消息队列带来的异步确实可以提高系统响应速度。但是，万一消息的真正消费者并没有正确消费消息怎么办？这样就会导致数据不一致的情况了!
+
+## 四 JMS VS AMQP
+
+### 4.1 JMS
+
+#### 4.1.1 JMS 简介
+
+ JMS（JAVA Message Service,java消息服务）是java的消息服务，JMS的客户端之间可以通过JMS服务进行异步的消息传输。**JMS（JAVA Message Service，Java消息服务）API是一个消息服务的标准或者说是规范**，允许应用程序组件基于JavaEE平台创建、发送、接收和读取消息。它使分布式通信耦合度更低，消息服务更加可靠以及异步性。
+
+**ActiveMQ 就是基于 JMS 规范实现的。**
+
+#### 4.1.2 JMS两种消息模型
+
+①点到点（P2P）模型
+
+
+
+
+使用**队列（Queue）**作为消息通信载体；满足**生产者与消费者模式**，一条消息只能被一个消费者使用，未被消费的消息在队列中保留直到被消费或超时。比如：我们生产者发送100条消息的话，两个消费者来消费一般情况下两个消费者会按照消息发送的顺序各自消费一半（也就是你一个我一个的消费。）
+
+② 发布/订阅（Pub/Sub）模型
+
+ 
+
+
+发布订阅模型（Pub/Sub） 使用**主题（Topic）**作为消息通信载体，类似于**广播模式**；发布者发布一条消息，该消息通过主题传递给所有的订阅者，**在一条消息广播之后才订阅的用户则是收不到该条消息的**。
+
+#### 4.1.3 JMS 五种不同的消息正文格式
+
+ JMS定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。
+
+- StreamMessage -- Java原始值的数据流
+- MapMessage--一套名称-值对
+- TextMessage--一个字符串对象
+- ObjectMessage--一个序列化的 Java对象
+- BytesMessage--一个字节的数据流
+
+
+### 4.2 AMQP
+
+ AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准 **高级消息队列协议**（二进制应用层协议），是应用层协议的一个开放标准,为面向消息的中间件设计，兼容 JMS。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件同产品，不同的开发语言等条件的限制。
+
+**RabbitMQ 就是基于 AMQP 协议实现的。**
+
+
+
+### 4.3 JMS vs AMQP
+
+
+|对比方向| JMS | AMQP |
+| :-------- | --------:| :--: |
+| 定义| Java API | 协议 |
+| 跨语言 | 否 | 是 |
+| 跨平台 | 否 | 是 |
+| 支持消息类型 | 提供两种消息模型：①Peer-2-Peer;②Pub/sub| 提供了五种消息模型：①direct exchange；②fanout exchange；③topic change；④headers exchange；⑤system exchange。本质来讲，后四种和JMS的pub/sub模型没有太大差别，仅是在路由机制上做了更详细的划分；|
+|支持消息类型| 支持多种消息类型 ，我们在上面提到过| byte[]（二进制）|
+
+**总结：**
+
+- AMQP 为消息定义了线路层（wire-level protocol）的协议，而JMS所定义的是API规范。在 Java 体系中，多个client均可以通过JMS进行交互，不需要应用修改代码，但是其对跨平台的支持较差。而AMQP天然具有跨平台、跨语言特性。
+- JMS 支持TextMessage、MapMessage 等复杂的消息类型；而 AMQP 仅支持 byte[] 消息类型（复杂的类型可序列化后发送）。
+- 由于Exchange 提供的路由算法，AMQP可以提供多样化的路由方式来传递消息到消息队列，而 JMS 仅支持 队列 和 主题/订阅 方式两种。
+
+
+## 五 常见的消息队列对比
+
+
+
+对比方向 |概要
+-------- | ---
+ 吞吐量| 万级的 ActiveMQ 和 RabbitMQ 的吞吐量（ActiveMQ 的性能最差）要比 十万级甚至是百万级的 RocketMQ 和 Kafka 低一个数量级。
+可用性| 都可以实现高可用。ActiveMQ 和 RabbitMQ 都是基于主从架构实现高可用性。RocketMQ 基于分布式架构。 kafka 也是分布式的，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用
+时效性| RabbitMQ 基于erlang开发，所以并发能力很强，性能极其好，延时很低，达到微秒级。其他三个都是 ms 级。
+功能支持| 除了 Kafka，其他三个功能都较为完备。 Kafka 功能较为简单，主要支持简单的MQ功能，在大数据领域的实时计算以及日志采集被大规模使用，是事实上的标准
+消息丢失| ActiveMQ 和 RabbitMQ 丢失的可能性非常低， RocketMQ 和 Kafka 理论上不会丢失。
+
+
+**总结：**
+
+- ActiveMQ 的社区算是比较成熟，但是较目前来说，ActiveMQ 的性能比较差，而且版本迭代很慢，不推荐使用。
+- RabbitMQ 在吞吐量方面虽然稍逊于 Kafka 和 RocketMQ ，但是由于它基于 erlang 开发，所以并发能力很强，性能极其好，延时很低，达到微秒级。但是也因为 RabbitMQ 基于 erlang 开发，所以国内很少有公司有实力做erlang源码级别的研究和定制。如果业务场景对并发量要求不是太高（十万级、百万级），那这四种消息队列中，RabbitMQ 一定是你的首选。如果是大数据领域的实时计算、日志采集等场景，用 Kafka 是业内标准的，绝对没问题，社区活跃度很高，绝对不会黄，何况几乎是全世界这个领域的事实性规范。
+- RocketMQ 阿里出品，Java 系开源项目，源代码我们可以直接阅读，然后可以定制自己公司的MQ，并且 RocketMQ 有阿里巴巴的实际业务场景的实战考验。RocketMQ 社区活跃度相对较为一般，不过也还可以，文档相对来说简单一些，然后接口这块不是按照标准 JMS 规范走的有些系统要迁移需要修改大量代码。还有就是阿里出台的技术，你得做好这个技术万一被抛弃，社区黄掉的风险，那如果你们公司有技术实力我觉得用RocketMQ 挺好的
+- kafka 的特点其实很明显，就是仅仅提供较少的核心功能，但是提供超高的吞吐量，ms 级的延迟，极高的可用性以及可靠性，而且分布式可以任意扩展。同时 kafka 最好是支撑较少的 topic 数量即可，保证其超高吞吐量。kafka 唯一的一点劣势是有可能消息重复消费，那么对数据准确性会造成极其轻微的影响，在大数据领域中以及日志采集中，这点轻微影响可以忽略这个特性天然适合大数据实时计算以及日志收集。
+
+
+参考：《Java工程师面试突击第1季-中华石杉老师》
diff --git a/docs/system-design/data-communication/rabbitmq.md b/docs/system-design/data-communication/rabbitmq.md
new file mode 100644
index 00000000000..825f71239c6
--- /dev/null
+++ b/docs/system-design/data-communication/rabbitmq.md
@@ -0,0 +1,324 @@
+
+
+- [一文搞懂 RabbitMQ 的重要概念以及安装](#一文搞懂-rabbitmq-的重要概念以及安装)
+ - [一 RabbitMQ 介绍](#一-rabbitmq-介绍)
+ - [1.1 RabbitMQ 简介](#11-rabbitmq-简介)
+ - [1.2 RabbitMQ 核心概念](#12-rabbitmq-核心概念)
+ - [1.2.1 Producer(生产者) 和 Consumer(消费者)](#121-producer生产者-和-consumer消费者)
+ - [1.2.2 Exchange(交换器)](#122-exchange交换器)
+ - [1.2.3 Queue(消息队列)](#123-queue消息队列)
+ - [1.2.4 Broker（消息中间件的服务节点）](#124-broker消息中间件的服务节点)
+ - [1.2.5 Exchange Types(交换器类型)](#125-exchange-types交换器类型)
+ - [① fanout](#①-fanout)
+ - [② direct](#②-direct)
+ - [③ topic](#③-topic)
+ - [④ headers(不推荐)](#④-headers不推荐)
+ - [二 安装 RabbitMq](#二-安装-rabbitmq)
+ - [2.1 安装 erlang](#21-安装-erlang)
+ - [2.2 安装 RabbitMQ](#22-安装-rabbitmq)
+
+
+
+# 一文搞懂 RabbitMQ 的重要概念以及安装
+
+## 一 RabbitMQ 介绍
+
+这部分参考了 《RabbitMQ实战指南》这本书的第 1 章和第 2 章。
+
+### 1.1 RabbitMQ 简介
+
+RabbitMQ 是采用 Erlang 语言实现 AMQP(Advanced Message Queuing Protocol，高级消息队列协议）的消息中间件，它最初起源于金融系统，用于在分布式系统中存储转发消息。
+
+RabbitMQ 发展到今天，被越来越多的人认可，这和它在易用性、扩展性、可靠性和高可用性等方面的卓著表现是分不开的。RabbitMQ 的具体特点可以概括为以下几点：
+
+- **可靠性：** RabbitMQ使用一些机制来保证消息的可靠性，如持久化、传输确认及发布确认等。
+- **灵活的路由：** 在消息进入队列之前，通过交换器来路由消息。对于典型的路由功能，RabbitMQ 己经提供了一些内置的交换器来实现。针对更复杂的路由功能，可以将多个交换器绑定在一起，也可以通过插件机制来实现自己的交换器。这个后面会在我们将 RabbitMQ 核心概念的时候详细介绍到。
+- **扩展性：** 多个RabbitMQ节点可以组成一个集群，也可以根据实际业务情况动态地扩展集群中节点。
+- **高可用性：** 队列可以在集群中的机器上设置镜像，使得在部分节点出现问题的情况下队列仍然可用。
+- **支持多种协议：** RabbitMQ 除了原生支持 AMQP 协议，还支持 STOMP、MQTT 等多种消息中间件协议。
+- **多语言客户端：** RabbitMQ几乎支持所有常用语言，比如 Java、Python、Ruby、PHP、C#、JavaScript等。
+- **易用的管理界面：** RabbitMQ提供了一个易用的用户界面，使得用户可以监控和管理消息、集群中的节点等。在安装 RabbitMQ 的时候会介绍到，安装好 RabbitMQ 就自带管理界面。
+- **插件机制：** RabbitMQ 提供了许多插件，以实现从多方面进行扩展，当然也可以编写自己的插件。感觉这个有点类似 Dubbo 的 SPI机制。
+
+### 1.2 RabbitMQ 核心概念
+
+RabbitMQ 整体上是一个生产者与消费者模型，主要负责接收、存储和转发消息。可以把消息传递的过程想象成：当你将一个包裹送到邮局，邮局会暂存并最终将邮件通过邮递员送到收件人的手上，RabbitMQ就好比由邮局、邮箱和邮递员组成的一个系统。从计算机术语层面来说，RabbitMQ 模型更像是一种交换机模型。
+
+下面再来看看图1—— RabbitMQ 的整体模型架构。
+
+
+
+下面我会一一介绍上图中的一些概念。
+
+#### 1.2.1 Producer(生产者) 和 Consumer(消费者)
+
+- **Producer(生产者)** :生产消息的一方（邮件投递者）
+- **Consumer(消费者)** :消费消息的一方（邮件收件人）
+
+消息一般由 2 部分组成：**消息头**（或者说是标签 Label）和 **消息体**。消息体也可以称为 payLoad ,消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括 routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。生产者把消息交由 RabbitMQ 后，RabbitMQ 会根据消息头把消息发送给感兴趣的 Consumer(消费者)。
+
+#### 1.2.2 Exchange(交换器)
+
+在 RabbitMQ 中，消息并不是直接被投递到 **Queue(消息队列)** 中的，中间还必须经过 **Exchange(交换器)** 这一层，**Exchange(交换器)** 会把我们的消息分配到对应的 **Queue(消息队列)** 中。
+
+**Exchange(交换器)** 用来接收生产者发送的消息并将这些消息路由给服务器中的队列中，如果路由不到，或许会返回给 **Producer(生产者)** ，或许会被直接丢弃掉 。这里可以将RabbitMQ中的交换器看作一个简单的实体。
+
+**RabbitMQ 的 Exchange(交换器) 有4种类型，不同的类型对应着不同的路由策略**：**direct(默认)**，**fanout**, **topic**, 和 **headers**，不同类型的Exchange转发消息的策略有所区别。这个会在介绍 **Exchange Types(交换器类型)** 的时候介绍到。
+
+Exchange(交换器) 示意图如下：
+
+
+
+生产者将消息发给交换器的时候，一般会指定一个 **RoutingKey(路由键)**，用来指定这个消息的路由规则，而这个 **RoutingKey 需要与交换器类型和绑定键(BindingKey)联合使用才能最终生效**。
+
+RabbitMQ 中通过 **Binding(绑定)** 将 **Exchange(交换器)** 与 **Queue(消息队列)** 关联起来，在绑定的时候一般会指定一个 **BindingKey(绑定建)** ,这样 RabbitMQ 就知道如何正确将消息路由到队列了,如下图所示。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。Exchange 和 Queue 的绑定可以是多对多的关系。
+
+Binding(绑定) 示意图：
+
+
+
+生产者将消息发送给交换器时，需要一个RoutingKey,当 BindingKey 和 RoutingKey 相匹配时，消息会被路由到对应的队列中。在绑定多个队列到同一个交换器的时候，这些绑定允许使用相同的 BindingKey。BindingKey 并不是在所有的情况下都生效，它依赖于交换器类型，比如fanout类型的交换器就会无视，而是将消息路由到所有绑定到该交换器的队列中。
+
+#### 1.2.3 Queue(消息队列)
+
+**Queue(消息队列)** 用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
+
+**RabbitMQ** 中消息只能存储在 **队列** 中，这一点和 **Kafka** 这种消息中间件相反。Kafka 将消息存储在 **topic（主题）** 这个逻辑层面，而相对应的队列逻辑只是topic实际存储文件中的位移标识。 RabbitMQ 的生产者生产消息并最终投递到队列中，消费者可以从队列中获取消息并消费。
+
+**多个消费者可以订阅同一个队列**，这时队列中的消息会被平均分摊（Round-Robin，即轮询）给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理，这样避免的消息被重复消费。
+
+**RabbitMQ** 不支持队列层面的广播消费,如果有广播消费的需求，需要在其上进行二次开发,这样会很麻烦，不建议这样做。
+
+#### 1.2.4 Broker（消息中间件的服务节点）
+
+对于 RabbitMQ 来说，一个 RabbitMQ Broker 可以简单地看作一个 RabbitMQ 服务节点，或者RabbitMQ服务实例。大多数情况下也可以将一个 RabbitMQ Broker 看作一台 RabbitMQ 服务器。
+
+下图展示了生产者将消息存入 RabbitMQ Broker,以及消费者从Broker中消费数据的整个流程。
+
+
+
+这样图1中的一些关于 RabbitMQ 的基本概念我们就介绍完毕了，下面再来介绍一下 **Exchange Types(交换器类型)** 。
+
+#### 1.2.5 Exchange Types(交换器类型)
+
+RabbitMQ 常用的 Exchange Type 有 **fanout**、**direct**、**topic**、**headers** 这四种（AMQP规范里还提到两种 Exchange Type，分别为 system 与 自定义，这里不予以描述）。
+
+##### ① fanout
+
+fanout 类型的Exchange路由规则非常简单，它会把所有发送到该Exchange的消息路由到所有与它绑定的Queue中，不需要做任何判断操作，所以 fanout 类型是所有的交换机类型里面速度最快的。fanout 类型常用来广播消息。
+
+##### ② direct
+
+direct 类型的Exchange路由规则也很简单，它会把消息路由到那些 Bindingkey 与 RoutingKey 完全匹配的 Queue 中。
+
+
+
+以上图为例，如果发送消息的时候设置路由键为“warning”,那么消息会路由到 Queue1 和 Queue2。如果在发送消息的时候设置路由键为"Info”或者"debug”，消息只会路由到Queue2。如果以其他的路由键发送消息，则消息不会路由到这两个队列中。
+
+direct 类型常用在处理有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以指派更多的资源去处理高优先级的队列。
+
+##### ③ topic
+
+前面讲到direct类型的交换器路由规则是完全匹配 BindingKey 和 RoutingKey ，但是这种严格的匹配方式在很多情况下不能满足实际业务的需求。topic类型的交换器在匹配规则上进行了扩展，它与 direct 类型的交换器相似，也是将消息路由到 BindingKey 和 RoutingKey 相匹配的队列中，但这里的匹配规则有些不同，它约定：
+
+- RoutingKey 为一个点号“．”分隔的字符串（被点号“．”分隔开的每一段独立的字符串称为一个单词），如 “com.rabbitmq.client”、“java.util.concurrent”、“com.hidden.client”;
+- BindingKey 和 RoutingKey 一样也是点号“．”分隔的字符串；
+- BindingKey 中可以存在两种特殊字符串“*”和“#”，用于做模糊匹配，其中“.”用于匹配一个单词，“#”用于匹配多个单词(可以是零个)。
+
+
+
+以上图为例：
+
+- 路由键为 “com.rabbitmq.client” 的消息会同时路由到 Queuel 和 Queue2;
+- 路由键为 “com.hidden.client” 的消息只会路由到 Queue2 中；
+- 路由键为 “com.hidden.demo” 的消息只会路由到 Queue2 中；
+- 路由键为 “java.rabbitmq.demo” 的消息只会路由到Queuel中；
+- 路由键为 “java.util.concurrent” 的消息将会被丢弃或者返回给生产者（需要设置 mandatory 参数），因为它没有匹配任何路由键。
+
+##### ④ headers(不推荐)
+
+headers 类型的交换器不依赖于路由键的匹配规则来路由消息，而是根据发送的消息内容中的 headers 属性进行匹配。在绑定队列和交换器时制定一组键值对，当发送消息到交换器时，RabbitMQ会获取到该消息的 headers（也是一个键值对的形式)'对比其中的键值对是否完全匹配队列和交换器绑定时指定的键值对，如果完全匹配则消息会路由到该队列，否则不会路由到该队列。headers 类型的交换器性能会很差，而且也不实用，基本上不会看到它的存在。
+
+## 二 安装 RabbitMq
+
+通过 Docker 安装非常方便，只需要几条命令就好了，我这里是只说一下常规安装方法。
+
+前面提到了 RabbitMQ 是由 Erlang语言编写的，也正因如此，在安装RabbitMQ 之前需要安装 Erlang。
+
+注意：在安装 RabbitMQ 的时候需要注意 RabbitMQ 和 Erlang 的版本关系，如果不注意的话会导致出错，两者对应关系如下:
+
+
+
+### 2.1 安装 erlang
+
+**1 下载 erlang 安装包**
+
+在官网下载然后上传到 Linux 上或者直接使用下面的命令下载对应的版本。
+
+```shell
+[root@SnailClimb local]#wget http://erlang.org/download/otp_src_19.3.tar.gz
+```
+
+erlang 官网下载：[http://www.erlang.org/downloads](http://www.erlang.org/downloads)
+
+ **2 解压 erlang 安装包**
+
+```shell
+[root@SnailClimb local]#tar -xvzf otp_src_19.3.tar.gz
+```
+
+**3 删除 erlang 安装包**
+
+```shell
+[root@SnailClimb local]#rm -rf otp_src_19.3.tar.gz
+```
+
+**4 安装 erlang 的依赖工具**
+
+```shell
+[root@SnailClimb local]#yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel unixODBC-devel
+```
+
+**5 进入erlang 安装包解压文件对 erlang 进行安装环境的配置**
+
+新建一个文件夹
+
+```shell
+[root@SnailClimb local]# mkdir erlang
+```
+
+对 erlang 进行安装环境的配置
+
+```shell
+[root@SnailClimb otp_src_19.3]#
+./configure --prefix=/usr/local/erlang --without-javac
+```
+
+**6 编译安装**
+
+```shell
+[root@SnailClimb otp_src_19.3]#
+make && make install
+```
+
+**7 验证一下 erlang 是否安装成功了**
+
+```shell
+[root@SnailClimb otp_src_19.3]# ./bin/erl
+```
+运行下面的语句输出“hello world”
+
+```erlang
+ io:format("hello world~n", []).
+```
+
+
+大功告成，我们的 erlang 已经安装完成。
+
+**8 配置 erlang 环境变量**
+
+```shell
+[root@SnailClimb etc]# vim profile
+```
+
+追加下列环境变量到文件末尾
+
+```shell
+#erlang
+ERL_HOME=/usr/local/erlang
+PATH=$ERL_HOME/bin:$PATH
+export ERL_HOME PATH
+```
+
+运行下列命令使配置文件`profile`生效
+
+```shell
+[root@SnailClimb etc]# source /etc/profile
+```
+
+输入 erl 查看 erlang 环境变量是否配置正确
+
+```shell
+[root@SnailClimb etc]# erl
+```
+
+
+
+### 2.2 安装 RabbitMQ
+
+**1. 下载rpm**
+
+```shell
+wget https://www.rabbitmq.com/releases/rabbitmq-server/v3.6.8/rabbitmq-server-3.6.8-1.el7.noarch.rpm
+```
+或者直接在官网下载
+
+https://www.rabbitmq.com/install-rpm.html[enter link description here](https://www.rabbitmq.com/install-rpm.html)
+
+**2. 安装rpm**
+
+```shell
+rpm --import https://www.rabbitmq.com/rabbitmq-release-signing-key.asc
+```
+紧接着执行：
+
+```shell
+yum install rabbitmq-server-3.6.8-1.el7.noarch.rpm
+```
+中途需要你输入"y"才能继续安装。
+
+**3 开启 web 管理插件**
+
+```shell
+rabbitmq-plugins enable rabbitmq_management
+```
+
+**4 设置开机启动**
+
+```shell
+chkconfig rabbitmq-server on
+```
+
+**4. 启动服务**
+
+```shell
+service rabbitmq-server start
+```
+
+**5. 查看服务状态**
+
+```shell
+service rabbitmq-server status
+```
+
+**6. 访问 RabbitMQ 控制台**
+
+浏览器访问：http://你的ip地址:15672/
+
+默认用户名和密码： guest/guest;但是需要注意的是：guestuest用户只是被容许从localhost访问。官网文档描述如下：
+
+```shell
+“guest” user can only connect via localhost
+```
+
+**解决远程访问 RabbitMQ 远程访问密码错误**
+
+新建用户并授权
+
+```shell
+[root@SnailClimb rabbitmq]# rabbitmqctl add_user root root
+Creating user "root" ...
+[root@SnailClimb rabbitmq]# rabbitmqctl set_user_tags root administrator
+
+Setting tags for user "root" to [administrator] ...
+[root@SnailClimb rabbitmq]#
+[root@SnailClimb rabbitmq]# rabbitmqctl set_permissions -p / root ".*" ".*" ".*"
+Setting permissions for user "root" in vhost "/" ...
+
+```
+
+再次访问:http://你的ip地址:15672/ ,输入用户名和密码：root root
+
+
+
+
diff --git "a/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\346\225\260\346\215\256\351\200\232\344\277\241(RESTful\343\200\201RPC\343\200\201\346\266\210\346\201\257\351\230\237\345\210\227).md" "b/docs/system-design/data-communication/\346\225\260\346\215\256\351\200\232\344\277\241(RESTful\343\200\201RPC\343\200\201\346\266\210\346\201\257\351\230\237\345\210\227).md"
similarity index 95%
rename from "\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\346\225\260\346\215\256\351\200\232\344\277\241(RESTful\343\200\201RPC\343\200\201\346\266\210\346\201\257\351\230\237\345\210\227).md"
rename to "docs/system-design/data-communication/\346\225\260\346\215\256\351\200\232\344\277\241(RESTful\343\200\201RPC\343\200\201\346\266\210\346\201\257\351\230\237\345\210\227).md"
index 2df02d0312c..7840d844d73 100644
--- "a/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\344\270\216\346\225\260\346\215\256\351\200\232\344\277\241/\346\225\260\346\215\256\351\200\232\344\277\241(RESTful\343\200\201RPC\343\200\201\346\266\210\346\201\257\351\230\237\345\210\227).md"
+++ "b/docs/system-design/data-communication/\346\225\260\346\215\256\351\200\232\344\277\241(RESTful\343\200\201RPC\343\200\201\346\266\210\346\201\257\351\230\237\345\210\227).md"
@@ -55,7 +55,7 @@
[《消息队列深入解析》](https://blog.csdn.net/qq_34337272/article/details/80029918)
-当前使用较多的消息队列有ActiveMQ（性能差，不推荐使用）、RabbitMQ、RocketMQ、Kafka等等，我们之前提高的redis数据库也可以实现消息队列，不过不推荐，redis本身设计就不是用来做消息队列的。
+当前使用较多的消息队列有ActiveMQ（性能差，不推荐使用）、RabbitMQ、RocketMQ、Kafka等等，我们之前提到的redis数据库也可以实现消息队列，不过不推荐，redis本身设计就不是用来做消息队列的。
- **ActiveMQ：** ActiveMQ是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ是一个完全支持JMS1.1和J2EE 1.4规范的JMSProvider实现,尽管JMS规范出台已经是很久的事情了,但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。
@@ -80,7 +80,7 @@
[《十分钟入门RocketMQ》](http://jm.taobao.org/2017/01/12/rocketmq-quick-start-in-10-minutes/) （阿里中间件团队博客）
-- **Kafka**：Kafka是一个分布式的、可分区的、可复制的、基于发布/订阅的消息系统,Kafka主要用于大数据领域,当然在分布式系统中也有应用。目前市面上流行的消息队列RocketMQ就是阿里借鉴Kafka的原理、用Java开发而得。
+- **Kafka**：Kafka是一个分布式的、可分区的、可复制的、基于发布/订阅的消息系统（现在官方的描述是“一个分布式流平台”）,Kafka主要用于大数据领域,当然在分布式系统中也有应用。目前市面上流行的消息队列RocketMQ就是阿里借鉴Kafka的原理、用Java开发而得。
具体可以参考：
diff --git "a/\344\270\273\346\265\201\346\241\206\346\236\266/SpringBean.md" b/docs/system-design/framework/SpringBean.md
similarity index 98%
rename from "\344\270\273\346\265\201\346\241\206\346\236\266/SpringBean.md"
rename to docs/system-design/framework/SpringBean.md
index 09e3b5d261b..4e8279e7d7d 100644
--- "a/\344\270\273\346\265\201\346\241\206\346\236\266/SpringBean.md"
+++ b/docs/system-design/framework/SpringBean.md
@@ -23,6 +23,8 @@
**Spring中的bean默认都是单例的，这些单例Bean在多线程程序下如何保证线程安全呢？** 例如对于Web应用来说，Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求，引入Spring框架之后，每个Action都是单例的，那么对于Spring托管的单例Service Bean，如何保证其安全呢？ **Spring的单例是基于BeanFactory也就是Spring容器的，单例Bean在此容器内只有一个，Java的单例是基于 JVM，每个 JVM 内只有一个实例。**
+在大多数情况下。单例 bean 是很理想的方案。不过，有时候你可能会发现你所使用的类是易变的，它们会保持一些状态，因此重用是不安全的。在这种情况下，将 class 声明为单例的就不是那么明智了。因为对象会被污染，稍后重用的时候会出现意想不到的问题。所以 Spring 定义了多种作用域的bean。
+
# 一 bean的作用域
创建一个bean定义，其实质是用该bean定义对应的类来创建真正实例的“配方”。把bean定义看成一个配方很有意义，它与class很类似，只根据一张“处方”就可以创建多个实例。不仅可以控制注入到对象中的各种依赖和配置值，还可以控制该对象的作用域。这样可以灵活选择所建对象的作用域，而不必在Java Class级定义作用域。Spring Framework支持五种作用域，分别阐述如下表。
@@ -65,7 +67,7 @@ public class ServiceImpl{
### 3. request——每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效
-**request只适用于Web程序，每一次 HTTP 请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，当请求结束后，该对象的生命周期即告结束。** 在 XML 中将 bean 定义成 prototype ，可以这样配置：
+**request只适用于Web程序，每一次 HTTP 请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，当请求结束后，该对象的生命周期即告结束。** 在 XML 中将 bean 定义成 request ，可以这样配置：
```java
diff --git "a/\344\270\273\346\265\201\346\241\206\346\236\266/SpringMVC \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md" "b/docs/system-design/framework/SpringMVC \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
similarity index 100%
rename from "\344\270\273\346\265\201\346\241\206\346\236\266/SpringMVC \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
rename to "docs/system-design/framework/SpringMVC \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
diff --git "a/docs/system-design/framework/Spring\345\255\246\344\271\240\344\270\216\351\235\242\350\257\225.md" "b/docs/system-design/framework/Spring\345\255\246\344\271\240\344\270\216\351\235\242\350\257\225.md"
new file mode 100644
index 00000000000..4933ce71bac
--- /dev/null
+++ "b/docs/system-design/framework/Spring\345\255\246\344\271\240\344\270\216\351\235\242\350\257\225.md"
@@ -0,0 +1,83 @@
+
+
+## Spring相关教程/资料
+
+### 官网相关
+
+- [Spring官网](https://spring.io/)
+- [Spring系列主要项目](https://spring.io/projects)
+- [Spring官网指南](https://spring.io/guides)
+- [Spring Framework 4.3.17.RELEASE API](https://docs.spring.io/spring/docs/4.3.17.RELEASE/javadoc-api/)
+
+## 系统学习教程
+
+### 文档
+
+- [极客学院Spring Wiki](http://wiki.jikexueyuan.com/project/spring/transaction-management.html)
+- [Spring W3Cschool教程 ](https://www.w3cschool.cn/wkspring/f6pk1ic8.html)
+
+### 视频
+
+- [网易云课堂——58集精通java教程Spring框架开发](http://study.163.com/course/courseMain.htm?courseId=1004475015#/courseDetail?tab=1&35)
+- [慕课网相关视频](https://www.imooc.com/)
+
+- **黑马视频和尚硅谷视频（非常推荐）：** 微信公众号：“**JavaGuie**”后台回复关键字 “**1**” 免费领取。
+
+
+## 面试必备知识点
+
+### SpringAOP,IOC实现原理
+
+AOP实现原理、动态代理和静态代理、Spring IOC的初始化过程、IOC原理、自己实现怎么实现一个IOC容器？这些东西都是经常会被问到的。
+
+推荐阅读：
+
+- [自己动手实现的 Spring IOC 和 AOP - 上篇](http://www.coolblog.xyz/2018/01/18/自己动手实现的-Spring-IOC-和-AOP-上篇/)
+
+- [自己动手实现的 Spring IOC 和 AOP - 下篇](http://www.coolblog.xyz/2018/01/18/自己动手实现的-Spring-IOC-和-AOP-下篇/)
+
+### AOP
+
+AOP思想的实现一般都是基于 **代理模式** ，在JAVA中一般采用JDK动态代理模式，但是我们都知道，**JDK动态代理模式只能代理接口而不能代理类**。因此，Spring AOP 会这样子来进行切换，因为Spring AOP 同时支持 CGLIB、ASPECTJ、JDK动态代理。
+
+- 如果目标对象的实现类实现了接口，Spring AOP 将会采用 JDK 动态代理来生成 AOP 代理类；
+- 如果目标对象的实现类没有实现接口，Spring AOP 将会采用 CGLIB 来生成 AOP 代理类——不过这个选择过程对开发者完全透明、开发者也无需关心。
+
+推荐阅读：
+
+- [静态代理、JDK动态代理、CGLIB动态代理讲解](http://www.cnblogs.com/puyangsky/p/6218925.html) ：我们知道AOP思想的实现一般都是基于 **代理模式** ，所以在看下面的文章之前建议先了解一下静态代理以及JDK动态代理、CGLIB动态代理的实现方式。
+- [Spring AOP 入门](https://juejin.im/post/5aa7818af265da23844040c6) ：带你入门的一篇文章。这篇文章主要介绍了AOP中的基本概念：5种类型的通知（Before，After，After-returning，After-throwing，Around）；Spring中对AOP的支持：AOP思想的实现一般都是基于代理模式，在Java中一般采用JDK动态代理模式，Spring AOP 同时支持 CGLIB、ASPECTJ、JDK动态代理，
+- [Spring AOP 基于AspectJ注解如何实现AOP](https://juejin.im/post/5a55af9e518825734d14813f) ： **AspectJ是一个AOP框架，它能够对java代码进行AOP编译（一般在编译期进行），让java代码具有AspectJ的AOP功能（当然需要特殊的编译器）**，可以这样说AspectJ是目前实现AOP框架中最成熟，功能最丰富的语言，更幸运的是，AspectJ与java程序完全兼容，几乎是无缝关联，因此对于有java编程基础的工程师，上手和使用都非常容易。Spring注意到AspectJ在AOP的实现方式上依赖于特殊编译器(ajc编译器)，因此Spring很机智回避了这点，转向采用动态代理技术的实现原理来构建Spring AOP的内部机制（动态织入），这是与AspectJ（静态织入）最根本的区别。**Spring 只是使用了与 AspectJ 5 一样的注解，但仍然没有使用 AspectJ 的编译器，底层依是动态代理技术的实现，因此并不依赖于 AspectJ 的编译器**。 Spring AOP虽然是使用了那一套注解，其实实现AOP的底层是使用了动态代理(JDK或者CGLib)来动态植入。至于AspectJ的静态植入，不是本文重点，所以只提一提。
+- [探秘Spring AOP（慕课网视频，很不错）](https://www.imooc.com/learn/869):慕课网视频，讲解的很不错，详细且深入
+- [spring源码剖析（六）AOP实现原理剖析](https://blog.csdn.net/fighterandknight/article/details/51209822) :通过源码分析Spring AOP的原理
+
+### IOC
+
+Spring IOC的初始化过程：
+
+
+- [[Spring框架]Spring IOC的原理及详解。](https://www.cnblogs.com/wang-meng/p/5597490.html)
+
+- [Spring IOC核心源码学习](https://yikun.github.io/2015/05/29/Spring-IOC核心源码学习/) :比较简短，推荐阅读。
+- [Spring IOC 容器源码分析](https://javadoop.com/post/spring-ioc) :强烈推荐，内容详尽，而且便于阅读。
+
+## Spring事务管理
+
+- [可能是最漂亮的Spring事务管理详解](https://juejin.im/post/5b00c52ef265da0b95276091)
+- [Spring编程式和声明式事务实例讲解](https://juejin.im/post/5b010f27518825426539ba38)
+
+### Spring单例与线程安全
+
+- [Spring框架中的单例模式（源码解读）](http://www.cnblogs.com/chengxuyuanzhilu/p/6404991.html):单例模式是一种常用的软件设计模式。通过单例模式可以保证系统中一个类只有一个实例。spring依赖注入时，使用了 多重判断加锁 的单例模式。
+
+### Spring源码阅读
+
+阅读源码不仅可以加深我们对Spring设计思想的理解，提高自己的编码水品，还可以让自己在面试中如鱼得水。下面的是Github上的一个开源的Spring源码阅读，大家有时间可以看一下，当然你如果有时间也可以自己慢慢研究源码。
+
+ - [spring-core](https://github.com/seaswalker/Spring/blob/master/note/Spring.md)
+- [spring-aop](https://github.com/seaswalker/Spring/blob/master/note/spring-aop.md)
+- [spring-context](https://github.com/seaswalker/Spring/blob/master/note/spring-context.md)
+- [spring-task](https://github.com/seaswalker/Spring/blob/master/note/spring-task.md)
+- [spring-transaction](https://github.com/seaswalker/Spring/blob/master/note/spring-transaction.md)
+- [spring-mvc](https://github.com/seaswalker/Spring/blob/master/note/spring-mvc.md)
+- [guava-cache](https://github.com/seaswalker/Spring/blob/master/note/guava-cache.md)
diff --git "a/\344\270\273\346\265\201\346\241\206\346\236\266/ZooKeeper.md" b/docs/system-design/framework/ZooKeeper.md
similarity index 94%
rename from "\344\270\273\346\265\201\346\241\206\346\236\266/ZooKeeper.md"
rename to docs/system-design/framework/ZooKeeper.md
index 0fc0abe3895..aa97a456e77 100644
--- "a/\344\270\273\346\265\201\346\241\206\346\236\266/ZooKeeper.md"
+++ b/docs/system-design/framework/ZooKeeper.md
@@ -28,7 +28,7 @@ ZooKeeper 是一个开源的分布式协调服务，ZooKeeper框架最初是在
**ZooKeeper 是一个典型的分布式数据一致性解决方案，分布式应用程序可以基于 ZooKeeper 实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列等功能。**
-**Zookeeper 一个最常用的使用场景就是用于担任服务生产者和服务消费者的注册中心。** 服务生产者将自己提供的服务注册到Zookeeper中心，服务的消费者在进行服务调用的时候先到Zookeeper中查找服务，获取到服务生产者的详细信息之后，再去调用服务生产者的内容与数据。如下图所示，在 Dubbo架构中 Zookeeper 就担任了注册中心这一角色。
+**Zookeeper 一个最常用的使用场景就是用于担任服务生产者和服务消费者的注册中心(提供发布订阅服务)。** 服务生产者将自己提供的服务注册到Zookeeper中心，服务的消费者在进行服务调用的时候先到Zookeeper中查找服务，获取到服务生产者的详细信息之后，再去调用服务生产者的内容与数据。如下图所示，在 Dubbo架构中 Zookeeper 就担任了注册中心这一角色。
@@ -58,7 +58,7 @@ ZooKeeper 是一个开源的分布式协调服务，ZooKeeper框架最初是在
- **ZooKeeper 将数据保存在内存中，这也就保证了 高吞吐量和低延迟**（但是内存限制了能够存储的容量不太大，此限制也是保持znode中存储的数据量较小的进一步原因）。
- **ZooKeeper 是高性能的。 在“读”多于“写”的应用程序中尤其地高性能，因为“写”会导致所有的服务器间同步状态。**（“读”多于“写”是协调服务的典型场景。）
- **ZooKeeper有临时节点的概念。 当创建临时节点的客户端会话一直保持活动，瞬时节点就一直存在。而当会话终结时，瞬时节点被删除。持久节点是指一旦这个ZNode被创建了，除非主动进行ZNode的移除操作，否则这个ZNode将一直保存在Zookeeper上。**
-- ZooKeeper 底层其实只提供了两个功能：①管理（存储、读取）用户程序提交的数据；②为用户程序提交数据节点监听服务。
+- ZooKeeper 底层其实只提供了两个功能：①管理（存储、读取）用户程序提交的数据；②为用户程序提供数据节点监听服务。
**下面关于会话（Session）、 Znode、版本、Watcher、ACL概念的总结都在《从Paxos到Zookeeper 》第四章第一节以及第七章第八节有提到，感兴趣的可以看看！**
@@ -74,11 +74,11 @@ Session 指的是 ZooKeeper 服务器与客户端会话。**在 ZooKeeper 中
Zookeeper将所有数据存储在内存中，数据模型是一棵树（Znode Tree)，由斜杠（/）的进行分割的路径，就是一个Znode，例如/foo/path1。每个上都会保存自己的数据内容，同时还会保存一系列属性信息。
-**在Zookeeper中，node可以分为持久节点和临时节点两类。所谓持久节点是指一旦这个ZNode被创建了，除非主动进行ZNode的移除操作，否则这个ZNode将一直保存在Zookeeper上。而临时节点就不一样了，它的生命周期和客户端会话绑定，一旦客户端会话失效，那么这个客户端创建的所有临时节点都会被移除。**另外，ZooKeeper还允许用户为每个节点添加一个特殊的属性：**SEQUENTIAL**.一旦节点被标记上这个属性，那么在这个节点被创建的时候，Zookeeper会自动在其节点名后面追加上一个整型数字，这个整型数字是一个由父节点维护的自增数字。
+**在Zookeeper中，node可以分为持久节点和临时节点两类。所谓持久节点是指一旦这个ZNode被创建了，除非主动进行ZNode的移除操作，否则这个ZNode将一直保存在Zookeeper上。而临时节点就不一样了，它的生命周期和客户端会话绑定，一旦客户端会话失效，那么这个客户端创建的所有临时节点都会被移除。** 另外，ZooKeeper还允许用户为每个节点添加一个特殊的属性：**SEQUENTIAL**.一旦节点被标记上这个属性，那么在这个节点被创建的时候，Zookeeper会自动在其节点名后面追加上一个整型数字，这个整型数字是一个由父节点维护的自增数字。
### 2.4 版本
-在前面我们已经提到，Zookeeper 的每个 ZNode 上都会存储数据，对应于每个ZNode，Zookeeper 都会为其维护一个叫作 **Stat** 的数据结构，Stat中记录了这个 ZNode 的三个数据版本，分别是version（当前ZNode的版本）、cversion（当前ZNode子节点的版本）和 cversion（当前ZNode的ACL版本）。
+在前面我们已经提到，Zookeeper 的每个 ZNode 上都会存储数据，对应于每个ZNode，Zookeeper 都会为其维护一个叫作 **Stat** 的数据结构，Stat 中记录了这个 ZNode 的三个数据版本，分别是version（当前ZNode的版本）、cversion（当前ZNode子节点的版本）和 aversion（当前ZNode的ACL版本）。
### 2.5 Watcher
@@ -165,8 +165,8 @@ ZAB协议包括两种基本的模式，分别是 **崩溃恢复和消息广播**
关于 **ZAB 协议&Paxos算法** 需要讲和理解的东西太多了，说实话，笔主到现在不太清楚这俩兄弟的具体原理和实现过程。推荐阅读下面两篇文章：
-- [图解 Paxos 一致性协议](http://blog.xiaohansong.com/2016/09/30/Paxos/)
-- [Zookeeper ZAB 协议分析](http://blog.xiaohansong.com/2016/08/25/zab/)
+- [图解 Paxos 一致性协议](http://codemacro.com/2014/10/15/explain-poxos/)
+- [Zookeeper ZAB 协议分析](https://dbaplus.cn/news-141-1875-1.html)
关于如何使用 zookeeper 实现分布式锁，可以查看下面这篇文章：
diff --git "a/docs/system-design/framework/ZooKeeper\346\225\260\346\215\256\346\250\241\345\236\213\345\222\214\345\270\270\350\247\201\345\221\275\344\273\244.md" "b/docs/system-design/framework/ZooKeeper\346\225\260\346\215\256\346\250\241\345\236\213\345\222\214\345\270\270\350\247\201\345\221\275\344\273\244.md"
new file mode 100644
index 00000000000..401c752f049
--- /dev/null
+++ "b/docs/system-design/framework/ZooKeeper\346\225\260\346\215\256\346\250\241\345\236\213\345\222\214\345\270\270\350\247\201\345\221\275\344\273\244.md"
@@ -0,0 +1,202 @@
+
+
+- [ZooKeeper 数据模型](#zookeeper-数据模型)
+- [ZNode\(数据节点\)的结构](#znode数据节点的结构)
+- [测试 ZooKeeper 中的常见操作](#测试-zookeeper-中的常见操作)
+ - [连接 ZooKeeper 服务](#连接-zookeeper-服务)
+ - [查看常用命令\(help 命令\)](#查看常用命令help-命令)
+ - [创建节点\(create 命令\)](#创建节点create-命令)
+ - [更新节点数据内容\(set 命令\)](#更新节点数据内容set-命令)
+ - [获取节点的数据\(get 命令\)](#获取节点的数据get-命令)
+ - [查看某个目录下的子节点\(ls 命令\)](#查看某个目录下的子节点ls-命令)
+ - [查看节点状态\(stat 命令\)](#查看节点状态stat-命令)
+ - [查看节点信息和状态\(ls2 命令\)](#查看节点信息和状态ls2-命令)
+ - [删除节点\(delete 命令\)](#删除节点delete-命令)
+- [参考](#参考)
+
+
+
+> 看本文之前如果你没有安装 ZooKeeper 的话，可以参考这篇文章：[《使用 SpringBoot+Dubbo 搭建一个简单分布式服务》](https://github.com/Snailclimb/springboot-integration-examples/blob/master/md/springboot-dubbo.md) 的 “开始实战 1 ：zookeeper 环境安装搭建” 这部分进行安装（Centos7.4 环境下）。如果你想对 ZooKeeper 有一个整体了解的话，可以参考这篇文章：[《可能是把 ZooKeeper 概念讲的最清楚的一篇文章》](https://github.com/Snailclimb/JavaGuide/blob/master/%E4%B8%BB%E6%B5%81%E6%A1%86%E6%9E%B6/ZooKeeper.md)
+
+### ZooKeeper 数据模型
+
+ZNode（数据节点）是 ZooKeeper 中数据的最小单元，每个ZNode上都可以保存数据，同时还是可以有子节点（这就像树结构一样，如下图所示）。可以看出，节点路径标识方式和Unix文件
+系统路径非常相似，都是由一系列使用斜杠"/"进行分割的路径表示，开发人员可以向这个节点中写人数据，也可以在节点下面创建子节点。这些操作我们后面都会介绍到。
+
+
+提到 ZooKeeper 数据模型，还有一个不得不得提的东西就是 **事务 ID** 。事务的ACID（Atomic：原子性；Consistency:一致性；Isolation：隔离性；Durability：持久性）四大特性我在这里就不多说了，相信大家也已经挺腻了。
+
+在Zookeeper中，事务是指能够改变 ZooKeeper 服务器状态的操作，我们也称之为事务操作或更新操作，一般包括数据节点创建与删除、数据节点内容更新和客户端会话创建与失效等操作。对于每一个事务请求，**ZooKeeper 都会为其分配一个全局唯一的事务ID,用 ZXID 来表示**，通常是一个64位的数字。每一个ZXID对应一次更新操作，**从这些 ZXID 中可以间接地识别出Zookeeper处理这些更新操作请求的全局顺序**。
+
+
+
+### ZNode(数据节点)的结构
+
+每个 ZNode 由2部分组成:
+
+- stat：状态信息
+- data：数据内容
+
+如下所示，我通过 get 命令来获取 根目录下的 dubbo 节点的内容。（get 命令在下面会介绍到）
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 6] get /dubbo
+# 该数据节点关联的数据内容为空
+null
+# 下面是该数据节点的一些状态信息，其实就是 Stat 对象的格式化输出
+cZxid = 0x2
+ctime = Tue Nov 27 11:05:34 CST 2018
+mZxid = 0x2
+mtime = Tue Nov 27 11:05:34 CST 2018
+pZxid = 0x3
+cversion = 1
+dataVersion = 0
+aclVersion = 0
+ephemeralOwner = 0x0
+dataLength = 0
+numChildren = 1
+
+```
+这些状态信息其实就是 Stat 对象的格式化输出。Stat 类中包含了一个数据节点的所有状态信息的字段，包括事务ID、版本信息和子节点个数等，如下图所示（图源：《从Paxos到Zookeeper 分布式一致性原理与实践》，下面会介绍通过 stat 命令查看数据节点的状态）。
+
+**Stat 类：**
+
+
+
+关于数据节点的状态信息说明（也就是对Stat 类中的各字段进行说明），可以参考下图（图源：《从Paxos到Zookeeper 分布式一致性原理与实践》）。
+
+
+
+### 测试 ZooKeeper 中的常见操作
+
+
+#### 连接 ZooKeeper 服务
+
+进入安装 ZooKeeper文件夹的 bin 目录下执行下面的命令连接 ZooKeeper 服务（Linux环境下）（连接之前首选要确定你的 ZooKeeper 服务已经启动成功）。
+
+```shell
+./zkCli.sh -server 127.0.0.1:2181
+```
+
+
+从上图可以看出控制台打印出了很多信息，包括我们的主机名称、JDK 版本、操作系统等等。如果你成功看到这些信息，说明你成功连接到 ZooKeeper 服务。
+
+#### 查看常用命令(help 命令)
+
+help 命令查看 zookeeper 常用命令
+
+
+
+#### 创建节点(create 命令)
+
+通过 create 命令在根目录创建了node1节点，与它关联的字符串是"node1"
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 34] create /node1 “node1”
+```
+通过 create 命令在根目录创建了node1节点，与它关联的内容是数字 123
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 1] create /node1/node1.1 123
+Created /node1/node1.1
+```
+
+#### 更新节点数据内容(set 命令)
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 11] set /node1 "set node1"
+```
+
+#### 获取节点的数据(get 命令)
+
+get 命令可以获取指定节点的数据内容和节点的状态,可以看出我们通过set 命令已经将节点数据内容改为 "set node1"。
+
+```shell
+set node1
+cZxid = 0x47
+ctime = Sun Jan 20 10:22:59 CST 2019
+mZxid = 0x4b
+mtime = Sun Jan 20 10:41:10 CST 2019
+pZxid = 0x4a
+cversion = 1
+dataVersion = 1
+aclVersion = 0
+ephemeralOwner = 0x0
+dataLength = 9
+numChildren = 1
+
+```
+
+#### 查看某个目录下的子节点(ls 命令)
+
+通过 ls 命令查看根目录下的节点
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 37] ls /
+[dubbo, zookeeper, node1]
+```
+通过 ls 命令查看 node1 目录下的节点
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 5] ls /node1
+[node1.1]
+```
+zookeeper 中的 ls 命令和 linux 命令中的 ls 类似， 这个命令将列出绝对路径path下的所有子节点信息（列出1级，并不递归）
+
+#### 查看节点状态(stat 命令)
+
+通过 stat 命令查看节点状态
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 10] stat /node1
+cZxid = 0x47
+ctime = Sun Jan 20 10:22:59 CST 2019
+mZxid = 0x47
+mtime = Sun Jan 20 10:22:59 CST 2019
+pZxid = 0x4a
+cversion = 1
+dataVersion = 0
+aclVersion = 0
+ephemeralOwner = 0x0
+dataLength = 11
+numChildren = 1
+```
+上面显示的一些信息比如cversion、aclVersion、numChildren等等，我在上面 “ZNode(数据节点)的结构” 这部分已经介绍到。
+
+#### 查看节点信息和状态(ls2 命令)
+
+
+ls2 命令更像是 ls 命令和 stat 命令的结合。ls2 命令返回的信息包括2部分：子节点列表 + 当前节点的stat信息。
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 7] ls2 /node1
+[node1.1]
+cZxid = 0x47
+ctime = Sun Jan 20 10:22:59 CST 2019
+mZxid = 0x47
+mtime = Sun Jan 20 10:22:59 CST 2019
+pZxid = 0x4a
+cversion = 1
+dataVersion = 0
+aclVersion = 0
+ephemeralOwner = 0x0
+dataLength = 11
+numChildren = 1
+
+```
+
+#### 删除节点(delete 命令)
+
+这个命令很简单，但是需要注意的一点是如果你要删除某一个节点，那么这个节点必须无子节点才行。
+
+```shell
+[zk: 127.0.0.1:2181(CONNECTED) 3] delete /node1/node1.1
+```
+
+在后面我会介绍到 Java 客户端 API的使用以及开源 Zookeeper 客户端 ZkClient 和 Curator 的使用。
+
+
+### 参考
+
+- 《从Paxos到Zookeeper 分布式一致性原理与实践》
+
diff --git "a/docs/system-design/website-architecture/8 \345\274\240\345\233\276\350\257\273\346\207\202\345\244\247\345\236\213\347\275\221\347\253\231\346\212\200\346\234\257\346\236\266\346\236\204.md" "b/docs/system-design/website-architecture/8 \345\274\240\345\233\276\350\257\273\346\207\202\345\244\247\345\236\213\347\275\221\347\253\231\346\212\200\346\234\257\346\236\266\346\236\204.md"
new file mode 100644
index 00000000000..f975930f7ee
--- /dev/null
+++ "b/docs/system-design/website-architecture/8 \345\274\240\345\233\276\350\257\273\346\207\202\345\244\247\345\236\213\347\275\221\347\253\231\346\212\200\346\234\257\346\236\266\346\236\204.md"
@@ -0,0 +1,47 @@
+> 本文是作者读 《大型网站技术架构》所做的思维导图，在这里分享给各位，公众号(JavaGuide)后台回复：“架构”。即可获得下面图片的源文件以及思维导图源文件！
+
+
+
+- [1. 大型网站架构演化](#1-大型网站架构演化)
+- [2. 大型架构模式](#2-大型架构模式)
+- [3. 大型网站核心架构要素](#3-大型网站核心架构要素)
+- [4. 瞬时响应:网站的高性能架构](#4-瞬时响应网站的高性能架构)
+- [5. 万无一失:网站的高可用架构](#5-万无一失网站的高可用架构)
+- [6. 永无止境:网站的伸缩性架构](#6-永无止境网站的伸缩性架构)
+- [7. 随机应变:网站的可扩展性架构](#7-随机应变网站的可扩展性架构)
+- [8. 固若金汤:网站的安全机构](#8-固若金汤网站的安全机构)
+
+
+
+
+### 1. 大型网站架构演化
+
+
+
+### 2. 大型架构模式
+
+
+
+### 3. 大型网站核心架构要素
+
+
+
+### 4. 瞬时响应:网站的高性能架构
+
+
+
+### 5. 万无一失:网站的高可用架构
+
+
+
+### 6. 永无止境:网站的伸缩性架构
+
+
+
+### 7. 随机应变:网站的可扩展性架构
+
+
+
+### 8. 固若金汤:网站的安全机构
+
+
diff --git "a/docs/system-design/website-architecture/\343\200\220\351\235\242\350\257\225\347\262\276\351\200\211\343\200\221\345\205\263\344\272\216\345\244\247\345\236\213\347\275\221\347\253\231\347\263\273\347\273\237\346\236\266\346\236\204\344\275\240\344\270\215\345\276\227\344\270\215\346\207\202\347\232\20410\344\270\252\351\227\256\351\242\230.md" "b/docs/system-design/website-architecture/\343\200\220\351\235\242\350\257\225\347\262\276\351\200\211\343\200\221\345\205\263\344\272\216\345\244\247\345\236\213\347\275\221\347\253\231\347\263\273\347\273\237\346\236\266\346\236\204\344\275\240\344\270\215\345\276\227\344\270\215\346\207\202\347\232\20410\344\270\252\351\227\256\351\242\230.md"
new file mode 100644
index 00000000000..c5d585c7275
--- /dev/null
+++ "b/docs/system-design/website-architecture/\343\200\220\351\235\242\350\257\225\347\262\276\351\200\211\343\200\221\345\205\263\344\272\216\345\244\247\345\236\213\347\275\221\347\253\231\347\263\273\347\273\237\346\236\266\346\236\204\344\275\240\344\270\215\345\276\227\344\270\215\346\207\202\347\232\20410\344\270\252\351\227\256\351\242\230.md"
@@ -0,0 +1,190 @@
+下面这些问题都是一线大厂的真实面试问题，不论是对你面试还是说拓宽知识面都很有帮助。之前发过一篇[8 张图读懂大型网站技术架构](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484416&idx=1&sn=6ced00d65491ef8fd33151bdfa8895c9&chksm=fd985261caefdb779412974a6a7207c93d0c2da5b28489afb74acd2fee28505daebbadb018ff&token=177958022&lang=zh_CN#rd) 可以作为不太了解大型网站系统技术架构朋友的入门文章。
+
+
+
+- [1. 你使用过哪些组件或者方法来提升网站性能,可用性以及并发量](#1-你使用过哪些组件或者方法来提升网站性能可用性以及并发量)
+- [2. 设计高可用系统的常用手段](#2-设计高可用系统的常用手段)
+- [3. 现代互联网应用系统通常具有哪些特点?](#3-现代互联网应用系统通常具有哪些特点)
+- [4. 谈谈你对微服务领域的了解和认识](#4-谈谈你对微服务领域的了解和认识)
+- [5. 谈谈你对 Dubbo 和 Spring Cloud 的认识\(两者关系\)](#5-谈谈你对-dubbo-和-spring-cloud-的认识两者关系)
+- [6. 性能测试了解吗?说说你知道的性能测试工具?](#6-性能测试了解吗说说你知道的性能测试工具)
+- [7. 对于一个单体应用系统,随着产品使用的用户越来越多,网站的流量会增加,最终单台服务器无法处理那么大的流量怎么办?](#7-对于一个单体应用系统随着产品使用的用户越来越多网站的流量会增加最终单台服务器无法处理那么大的流量怎么办)
+- [8. 大表优化的常见手段](#8-大表优化的常见手段)
+- [9. 在系统中使用消息队列能带来什么好处?](#9-在系统中使用消息队列能带来什么好处)
+ - [1) 通过异步处理提高系统性能](#1-通过异步处理提高系统性能)
+- [2) 降低系统耦合性](#2-降低系统耦合性)
+- [10. 说说自己对 CAP 定理,BASE 理论的了解](#10-说说自己对-cap-定理base-理论的了解)
+ - [CAP 定理](#cap-定理)
+ - [BASE 理论](#base-理论)
+- [参考](#参考)
+
+
+
+
+### 1. 你使用过哪些组件或者方法来提升网站性能,可用性以及并发量
+
+1. **提高硬件能力、增加系统服务器**。（当服务器增加到某个程度的时候系统所能提供的并发访问量几乎不变，所以不能根本解决问题）
+2. **使用缓存**（本地缓存：本地可以使用JDK自带的 Map、Guava Cache.分布式缓存：Redis、Memcache.本地缓存不适用于提高系统并发量，一般是用处用在程序中。比如Spring是如何实现单例的呢？大家如果看过源码的话，应该知道，S把已经初始过的变量放在一个Map中，下次再要使用这个变量的时候，先判断Map中有没有，这也就是系统中常见的单例模式的实现。）
+3. **消息队列** （解耦+削峰+异步）
+4. **采用分布式开发** （不同的服务部署在不同的机器节点上，并且一个服务也可以部署在多台机器上，然后利用 Nginx 负载均衡访问。这样就解决了单点部署(All In)的缺点，大大提高的系统并发量）
+5. **数据库分库（读写分离）、分表（水平分表、垂直分表）**
+6. **采用集群** （多台机器提供相同的服务）
+7. **CDN 加速** (将一些静态资源比如图片、视频等等缓存到离用户最近的网络节点)
+8. **浏览器缓存**
+9. **使用合适的连接池**（数据库连接池、线程池等等）
+10. **适当使用多线程进行开发。**
+
+
+### 2. 设计高可用系统的常用手段
+
+1. **降级：** 服务降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行。降级往往会指定不同的级别，面临不同的异常等级执行不同的处理。根据服务方式：可以拒接服务，可以延迟服务，也有时候可以随机服务。根据服务范围：可以砍掉某个功能，也可以砍掉某些模块。总之服务降级需要根据不同的业务需求采用不同的降级策略。主要的目的就是服务虽然有损但是总比没有好；
+2. **限流：** 防止恶意请求流量、恶意攻击，或者防止流量超出系统峰值；
+3. **缓存：** 避免大量请求直接落到数据库，将数据库击垮；
+4. **超时和重试机制：** 避免请求堆积造成雪崩；
+5. **回滚机制：** 快速修复错误版本。
+
+
+### 3. 现代互联网应用系统通常具有哪些特点?
+
+1. 高并发，大流量；
+2. 高可用：系统7×24小时不间断服务；
+3. 海量数据：需要存储、管理海量数据，需要使用大量服务器；
+4. 用户分布广泛，网络情况复杂：许多大型互联网都是为全球用户提供服务的，用户分布范围广，各地网络情况千差万别；
+5. 安全环境恶劣：由于互联网的开放性，使得互联网更容易受到攻击，大型网站几乎每天都会被黑客攻击；
+6. 需求快速变更，发布频繁：和传统软件的版本发布频率不同，互联网产品为快速适应市场，满足用户需求，其产品发布频率是极高的；
+7. 渐进式发展：与传统软件产品或企业应用系统一开始就规划好全部的功能和非功能需求不同，几乎所有的大型互联网网站都是从一个小网站开始，渐进地发展起来。
+
+### 4. 谈谈你对微服务领域的了解和认识
+
+现在大公司都在用并且未来的趋势都是 Spring Cloud，而阿里开源的 Spring Cloud Alibaba 也是 Spring Cloud 规范的实现 。
+
+我们通常把 Spring Cloud 理解为一系列开源组件的集合，但是 Spring Cloud并不是等同于 Spring Cloud Netflix 的 Ribbon、Feign、Eureka（停止更新）、Hystrix 这一套组件，而是抽象了一套通用的开发模式。它的目的是通过抽象出这套通用的模式，让开发者更快更好地开发业务。但是这套开发模式运行时的实际载体，还是依赖于 RPC、网关、服务发现、配置管理、限流熔断、分布式链路跟踪等组件的具体实现。
+
+Spring Cloud Alibaba 是官方认证的新一套 Spring Cloud 规范的实现,Spring Cloud Alibaba 是一套国产开源产品集合，后续还会有中文 reference 和一些原理分析文章，所以，这对于国内的开发者是非常棒的一件事。阿里的这一举动势必会推动国内微服务技术的发展，因为在没有 Spring Cloud Alibaba 之前，我们的第一选择是 Spring Cloud Netflix，但是它们的文档都是英文的，出问题后排查也比较困难， 在国内并不是有特别多的人精通。Spring Cloud Alibaba 由阿里开源组件和阿里云产品组件两部分组成，其致力于提供微服务一站式解决方案，方便开发者通过 Spring Cloud 编程模型轻松开发微服务应用。
+
+另外，Apache Dubbo Ecosystem 是围绕 Apache Dubbo 打造的微服务生态，是经过生产验证的微服务的最佳实践组合。在阿里巴巴的微服务解决方案中，Dubbo、Nacos 和 Sentinel，以及后续将开源的微服务组件，都是 Dubbo EcoSystem 的一部分。阿里后续也会将 Dubbo EcoSystem 集成到 Spring Cloud 的生态中。
+
+### 5. 谈谈你对 Dubbo 和 Spring Cloud 的认识(两者关系)
+
+具体可以看公众号-阿里巴巴中间件的这篇文章:[独家解读：Dubbo Ecosystem - 从微服务框架到微服务生态](https://mp.weixin.qq.com/s/iNVctXw7tUGHhnF0hV84ww)
+
+Dubbo 与 Spring Cloud 并不是竞争关系，Dubbo 作为成熟的 RPC 框架，其易用性、扩展性和健壮性已得到业界的认可。未来 Dubbo 将会作为 Spring Cloud Alibaba 的 RPC 组件，并与 Spring Cloud 原生的 Feign 以及 RestTemplate 进行无缝整合，实现“零”成本迁移。
+
+在阿里巴巴的微服务解决方案中，Dubbo、Nacos 和 Sentinel，以及后续将开源的微服务组件，都是 Dubbo EcoSystem 的一部分。我们后续也会将 Dubbo EcoSystem 集成到 Spring Cloud 的生态中。
+
+### 6. 性能测试了解吗?说说你知道的性能测试工具?
+
+性能测试指通过自动化的测试工具模拟多种正常、峰值以及异常负载条件来对系统的各项性能指标进行测试。性能测试是总称，通常细分为：
+
+1. **基准测试：** 在给系统施加较低压力时，查看系统的运行状况并记录相关数做为基础参考
+2. **负载测试：** 是指对系统不断地增加压力或增加一定压力下的持续时间，直到系统的某项或多项性能指标达到安全临界值，例如某种资源已经达到饱和状态等 。此时继续加压，系统处理能力会下降。
+3. **压力测试：** 超过安全负载情况下，不断施加压力（增加并发请求），直到系统崩溃或无法处理任何请求，依此获得系统最大压力承受能力。
+4. **稳定性测试：** 被测试系统在特定硬件、软件、网络环境下，加载一定业务压力（模拟生产环境不同时间点、不均匀请求，呈波浪特性）运行一段较长时间，以此检测系统是否稳定。
+
+后端程序员或者测试平常比较常用的测试工具是 JMeter（官网：[https://jmeter.apache.org/](https://jmeter.apache.org/)）。Apache JMeter 是一款基于Java的压力测试工具(100％纯Java应用程序)，旨在加载测试功能行为和测量性能。它最初被设计用于 Web 应用测试但后来扩展到其他测试领域。
+
+### 7. 对于一个单体应用系统,随着产品使用的用户越来越多,网站的流量会增加,最终单台服务器无法处理那么大的流量怎么办?
+
+这个时候就要考虑扩容了。《亿级流量网站架构核心技术》这本书上面介绍到我们可以考虑下面几步来解决这个问题：
+
+- 第一步，可以考虑简单的扩容来解决问题。比如增加系统的服务器，提高硬件能力等等。
+- 第二步，如果简单扩容搞不定，就需要水平拆分和垂直拆分数据／应用来提升系统的伸缩性，即通过扩容提升系统负载能力。
+- 第三步，如果通过水平拆分／垂直拆分还是搞不定，那就需要根据现有系统特性，架构层面进行重构甚至是重新设计，即推倒重来。
+
+对于系统设计，理想的情况下应支持线性扩容和弹性扩容，即在系统瓶颈时，只需要增加机器就可以解决系统瓶颈，如降低延迟提升吞吐量，从而实现扩容需求。
+
+如果你想扩容，则支持水平/垂直伸缩是前提。在进行拆分时，一定要清楚知道自己的目的是什么，拆分后带来的问题如何解决，拆分后如果没有得到任何收益就不要为了
+拆而拆，即不要过度拆分，要适合自己的业务。
+
+### 8. 大表优化的常见手段
+
+ 当MySQL单表记录数过大时，数据库的CRUD性能会明显下降，一些常见的优化措施如下：
+
+1. **限定数据的范围：** 务必禁止不带任何限制数据范围条件的查询语句。比如：我们当用户在查询订单历史的时候，我们可以控制在一个月的范围内；
+2. **读/写分离：** 经典的数据库拆分方案，主库负责写，从库负责读；
+3. **垂直分区：** **根据数据库里面数据表的相关性进行拆分。** 例如，用户表中既有用户的登录信息又有用户的基本信息，可以将用户表拆分成两个单独的表，甚至放到单独的库做分库。**简单来说垂直拆分是指数据表列的拆分，把一张列比较多的表拆分为多张表。** 如下图所示，这样来说大家应该就更容易理解了。**垂直拆分的优点：** 可以使得行数据变小，在查询时减少读取的Block数，减少I/O次数。此外，垂直分区可以简化表的结构，易于维护。**垂直拆分的缺点：** 主键会出现冗余，需要管理冗余列，并会引起Join操作，可以通过在应用层进行Join来解决。此外，垂直分区会让事务变得更加复杂；
+4. **水平分区：** **保持数据表结构不变，通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中，达到了分布式的目的。 水平拆分可以支撑非常大的数据量。** 水平拆分是指数据表行的拆分，表的行数超过200万行时，就会变慢，这时可以把一张的表的数据拆成多张表来存放。举个例子：我们可以将用户信息表拆分成多个用户信息表，这样就可以避免单一表数据量过大对性能造成影响。水平拆分可以支持非常大的数据量。需要注意的一点是:分表仅仅是解决了单一表数据过大的问题，但由于表的数据还是在同一台机器上，其实对于提升MySQL并发能力没有什么意义，所以 **水平拆分最好分库** 。水平拆分能够 **支持非常大的数据量存储，应用端改造也少**，但 **分片事务难以解决** ，跨界点Join性能较差，逻辑复杂。《Java工程师修炼之道》的作者推荐 **尽量不要对数据进行分片，因为拆分会带来逻辑、部署、运维的各种复杂度** ，一般的数据表在优化得当的情况下支撑千万以下的数据量是没有太大问题的。如果实在要分片，尽量选择客户端分片架构，这样可以减少一次和中间件的网络I/O。
+
+**下面补充一下数据库分片的两种常见方案：**
+
+- **客户端代理：** **分片逻辑在应用端，封装在jar包中，通过修改或者封装JDBC层来实现。** 当当网的 **Sharding-JDBC** 、阿里的TDDL是两种比较常用的实现。
+- **中间件代理：** **在应用和数据中间加了一个代理层。分片逻辑统一维护在中间件服务中。** 我们现在谈的 **Mycat** 、360的Atlas、网易的DDB等等都是这种架构的实现。
+
+### 9. 在系统中使用消息队列能带来什么好处?
+
+**《大型网站技术架构》第四章和第七章均有提到消息队列对应用性能及扩展性的提升。**
+
+#### 1) 通过异步处理提高系统性能
+
+如上图，**在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即 返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。**
+
+通过以上分析我们可以得出**消息队列具有很好的削峰作用的功能**——即**通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。** 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：
+
+因为**用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败**。因此使用消息队列进行异步处理之后，需要**适当修改业务流程进行配合**，比如**用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功**，以免交易纠纷。这就类似我们平时手机订火车票和电影票。
+
+### 2) 降低系统耦合性
+我们知道模块分布式部署以后聚合方式通常有两种：1.**分布式消息队列**和2.**分布式服务**。
+
+> **先来简单说一下分布式服务：**
+
+目前使用比较多的用来构建**SOA（Service Oriented Architecture面向服务体系结构）**的**分布式服务框架**是阿里巴巴开源的**Dubbo**.如果想深入了解Dubbo的可以看我写的关于Dubbo的这一篇文章：**《高性能优秀的服务框架-dubbo介绍》**：[https://juejin.im/post/5acadeb1f265da2375072f9c](https://juejin.im/post/5acadeb1f265da2375072f9c)
+
+> **再来谈我们的分布式消息队列：**
+
+我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。
+
+我们最常见的**事件驱动架构**类似生产者消费者模式，在大型网站中通常用利用消息队列实现事件驱动结构。如下图所示：
+
+**消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。** 从上图可以看到**消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合**，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。**对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计**。
+
+消息接受者对消息进行过滤、处理、包装后，构造成一个新的消息类型，将消息继续发送出去，等待其他消息接受者订阅该消息。因此基于事件（消息对象）驱动的业务架构可以是一系列流程。
+
+**另外为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。**
+
+**备注：** 不要认为消息队列只能利用发布-订阅模式工作，只不过在解耦这个特定业务环境下是使用发布-订阅模式的，**比如在我们的ActiveMQ消息队列中还有点对点工作模式**，具体的会在后面的文章给大家详细介绍，这一篇文章主要还是让大家对消息队列有一个更透彻的了解。
+
+> 这个问题一般会在上一个问题问完之后，紧接着被问到。“使用消息队列会带来什么问题？”这个问题要引起重视，一般我们都会考虑使用消息队列会带来的好处而忽略它带来的问题！
+
+### 10. 说说自己对 CAP 定理,BASE 理论的了解
+
+#### CAP 定理
+
+
+在理论计算机科学中，CAP定理（CAP theorem），又被称作布鲁尔定理（Brewer's theorem），它指出对于一个分布式计算系统来说，不可能同时满足以下三点：
+
+- **一致性（Consistence）** :所有节点访问同一份最新的数据副本
+- **可用性（Availability）**:每次请求都能获取到非错的响应——但是不保证获取的数据为最新数据
+- **分区容错性（Partition tolerance）** : 分布式系统在遇到某节点或网络分区故障的时候，仍然能够对外提供满足一致性和可用性的服务。
+
+CAP仅适用于原子读写的NOSQL场景中，并不适合数据库系统。现在的分布式系统具有更多特性比如扩展性、可用性等等，在进行系统设计和开发时，我们不应该仅仅局限在CAP问题上。
+
+**注意：不是所谓的3选2（不要被网上大多数文章误导了）:**
+
+大部分人解释这一定律时，常常简单的表述为：“一致性、可用性、分区容忍性三者你只能同时达到其中两个，不可能同时达到”。实际上这是一个非常具有误导性质的说法，而且在CAP理论诞生12年之后，CAP之父也在2012年重写了之前的论文。
+
+**当发生网络分区的时候，如果我们要继续服务，那么强一致性和可用性只能2选1。也就是说当网络分区之后P是前提，决定了P之后才有C和A的选择。也就是说分区容错性（Partition tolerance）我们是必须要实现的。**
+
+我在网上找了很多文章想看一下有没有文章提到这个不是所谓的3选2，用百度半天没找到了一篇，用谷歌搜索找到一篇比较不错的，如果想深入学习一下CAP就看这篇文章把，我这里就不多BB了：**《分布式系统之CAP理论》 ：** [http://www.cnblogs.com/hxsyl/p/4381980.html](http://www.cnblogs.com/hxsyl/p/4381980.html)
+
+
+#### BASE 理论
+
+**BASE** 是 **Basically Available（基本可用）** 、**Soft-state（软状态）** 和 **Eventually Consistent（最终一致性）** 三个短语的缩写。BASE理论是对CAP中一致性和可用性权衡的结果，其来源于对大规模互联网系统分布式实践的总结，是基于CAP定理逐步演化而来的，它大大降低了我们对系统的要求。
+
+**BASE理论的核心思想：** 即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。也就是牺牲数据的一致性来满足系统的高可用性，系统中一部分数据不可用或者不一致时，仍需要保持系统整体“主要可用”。
+
+
+**BASE理论三要素：**
+
+
+
+1. **基本可用：** 基本可用是指分布式系统在出现不可预知故障的时候，允许损失部分可用性。但是，这绝不等价于系统不可用。 比如： **①响应时间上的损失**:正常情况下，一个在线搜索引擎需要在0.5秒之内返回给用户相应的查询结果，但由于出现故障，查询结果的响应时间增加了1~2秒；**②系统功能上的损失**：正常情况下，在一个电子商务网站上进行购物的时候，消费者几乎能够顺利完成每一笔订单，但是在一些节日大促购物高峰的时候，由于消费者的购物行为激增，为了保护购物系统的稳定性，部分消费者可能会被引导到一个降级页面；
+2. **软状态：** 软状态指允许系统中的数据存在中间状态，并认为该中间状态的存在不会影响系统的整体可用性，即允许系统在不同节点的数据副本之间进行数据同步的过程存在延时；
+3. **最终一致性：** 最终一致性强调的是系统中所有的数据副本，在经过一段时间的同步后，最终能够达到一个一致的状态。因此，最终一致性的本质是需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性。
+
+### 参考
+
+- 《大型网站技术架构》
+- 《亿级流量网站架构核心技术》
+- 《Java工程师修炼之道》
+- https://www.cnblogs.com/puresoul/p/5456855.html
diff --git "a/\346\236\266\346\236\204/\345\210\206\345\270\203\345\274\217.md" "b/docs/system-design/website-architecture/\345\210\206\345\270\203\345\274\217.md"
similarity index 100%
rename from "\346\236\266\346\236\204/\345\210\206\345\270\203\345\274\217.md"
rename to "docs/system-design/website-architecture/\345\210\206\345\270\203\345\274\217.md"
diff --git "a/docs/system-design/\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/docs/system-design/\350\256\276\350\256\241\346\250\241\345\274\217.md"
new file mode 100644
index 00000000000..e3e95860529
--- /dev/null
+++ "b/docs/system-design/\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -0,0 +1,84 @@
+# Java 设计模式
+
+下面是自己学习设计模式的时候做的总结，有些是自己的原创文章，有些是网上写的比较好的文章，保存下来细细消化吧！
+
+**系列文章推荐：**
+
+## 创建型模式
+
+### 创建型模式概述
+
+- 创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。
+- 创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。
+
+
+
+### 常见创建型模式详解
+
+- **单例模式：** [深入理解单例模式——只有一个实例](https://blog.csdn.net/qq_34337272/article/details/80455972)
+- **工厂模式：** [深入理解工厂模式——由对象工厂生成对象](https://blog.csdn.net/qq_34337272/article/details/80472071)
+- **建造者模式：** [深入理解建造者模式 ——组装复杂的实例](http://blog.csdn.net/qq_34337272/article/details/80540059)
+- **原型模式：** [深入理解原型模式 ——通过复制生成实例](https://blog.csdn.net/qq_34337272/article/details/80706444)
+
+## 结构型模式
+
+### 结构型模式概述
+
+- **结构型模式(Structural Pattern)：** 描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构
+
+- **结构型模式可以分为类结构型模式和对象结构型模式：**
+ - 类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系。
+ - 对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法。根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式。
+
+
+
+### 常见结构型模式详解
+
+- **适配器模式：**
+ - [深入理解适配器模式——加个“适配器”以便于复用](https://segmentfault.com/a/1190000011856448)
+ - [适配器模式原理及实例介绍-IBM](https://www.ibm.com/developerworks/cn/java/j-lo-adapter-pattern/index.html)
+- **桥接模式：** [设计模式笔记16：桥接模式(Bridge Pattern)](https://blog.csdn.net/yangzl2008/article/details/7670996)
+- **组合模式：** [大话设计模式—组合模式](https://blog.csdn.net/lmb55/article/details/51039781)
+- **装饰模式：** [java模式—装饰者模式](https://www.cnblogs.com/chenxing818/p/4705919.html)、[Java设计模式-装饰者模式](https://blog.csdn.net/cauchyweierstrass/article/details/48240147)
+- **外观模式：** [java设计模式之外观模式（门面模式）](https://www.cnblogs.com/lthIU/p/5860607.html)
+- **享元模式：** [享元模式](http://www.jasongj.com/design_pattern/flyweight/)
+- **代理模式：**
+ - [代理模式原理及实例讲解 （IBM出品，很不错）](https://www.ibm.com/developerworks/cn/java/j-lo-proxy-pattern/index.html)
+ - [轻松学，Java 中的代理模式及动态代理](https://blog.csdn.net/briblue/article/details/73928350)
+ - [Java代理模式及其应用](https://blog.csdn.net/justloveyou_/article/details/74203025)
+
+
+## 行为型模式
+
+### 行为型模式概述
+
+- 行为型模式(Behavioral Pattern)是对在不同的对象之间划分责任和算法的抽象化。
+- 行为型模式不仅仅关注类和对象的结构，而且重点关注它们之间的相互作用。
+- 通过行为型模式，可以更加清晰地划分类与对象的职责，并研究系统在运行时实例对象之间的交互。在系统运行时，对象并不是孤立的，它们可以通过相互通信与协作完成某些复杂功能，一个对象在运行时也将影响到其他对象的运行。
+
+**行为型模式分为类行为型模式和对象行为型模式两种：**
+
+- **类行为型模式：** 类的行为型模式使用继承关系在几个类之间分配行为，类行为型模式主要通过多态等方式来分配父类与子类的职责。
+- **对象行为型模式：** 对象的行为型模式则使用对象的聚合关联关系来分配行为，对象行为型模式主要是通过对象关联等方式来分配两个或多个类的职责。根据“合成复用原则”，系统中要尽量使用关联关系来取代继承关系，因此大部分行为型设计模式都属于对象行为型设计模式。
+
+
+
+- **职责链模式：**
+- [Java设计模式之责任链模式、职责链模式](https://blog.csdn.net/jason0539/article/details/45091639)
+- [责任链模式实现的三种方式](https://www.cnblogs.com/lizo/p/7503862.html)
+- **命令模式：** 在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计，使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活。命令模式可以对发送者和接收者完全解耦，发送者与接收者之间没有直接引用关系，发送请求的对象只需要知道如何发送请求，而不必知道如何完成请求。这就是命令模式的模式动机。
+- **解释器模式：**
+- **迭代器模式：**
+- **中介者模式：**
+- **备忘录模式：**
+- **观察者模式：**
+- **状态模式：**
+- **策略模式：**
+
+策略模式作为设计原则中开闭原则最典型的体现，也是经常使用的。下面这篇博客介绍了策略模式一般的组成部分和概念，并用了一个小demo去说明了策略模式的应用。
+
+[java设计模式之策略模式](https://blog.csdn.net/zlj1217/article/details/81230077)
+
+- **模板方法模式：**
+- **访问者模式：**
+
diff --git a/docs/tools/Docker-Image.md b/docs/tools/Docker-Image.md
new file mode 100644
index 00000000000..c69931acb0b
--- /dev/null
+++ b/docs/tools/Docker-Image.md
@@ -0,0 +1,561 @@
+镜像作为 Docker 三大核心概念中，最重要的一个关键词，它有很多操作，是您想学习容器技术不得不掌握的。本文将带您一步一步，图文并重，上手操作来学习它。
+
+### 目录
+
+
+
+- [一 Docker 下载镜像](#一-docker-下载镜像)
+ - [1.1 下载镜像](#11-下载镜像)
+ - [1.2 验证](#12-验证)
+ - [1.3 下载镜像相关细节](#13-下载镜像相关细节)
+ - [1.4 PULL 子命令](#14-pull-子命令)
+- [二 Docker 查看镜像信息](#二-docker-查看镜像信息)
+ - [2.1 images 命令列出镜像](#21-images-命令列出镜像)
+ - [2.2 使用 tag 命令为镜像添加标签](#22-使用-tag-命令为镜像添加标签)
+ - [2.3 使用 inspect 命令查看镜像详细信息](#23-使用-inspect-命令查看镜像详细信息)
+ - [2.4 使用 history 命令查看镜像历史](#24-使用-history-命令查看镜像历史)
+- [三 Docker 搜索镜像](#三-docker-搜索镜像)
+ - [3.1 search 命令](#31-search-命令)
+ - [3.2 search 子命令](#32-search-子命令)
+- [四 Docker 删除镜像](#四-docker-删除镜像)
+ - [4.1 通过标签删除镜像](#41-通过标签删除镜像)
+ - [4.2 通过 ID 删除镜像](#42-通过-id-删除镜像)
+ - [4.3 删除镜像的限制](#43-删除镜像的限制)
+ - [4.4 清理镜像](#44-清理镜像)
+- [五 Docker 创建镜像](#五-docker-创建镜像)
+ - [5.1 基于已有的镜像创建](#51-基于已有的镜像创建)
+ - [5.2 基于 Dockerfile 创建](#52-基于-dockerfile-创建)
+- [六 Docker 导出&加载镜像](#六-docker-导出加载镜像)
+ - [6.1 导出镜像](#61-导出镜像)
+ - [6.2 加载镜像](#62-加载镜像)
+- [七 Docker 上传镜像](#七-docker-上传镜像)
+ - [7.1 获取 Docker ID](#71-获取-docker-id)
+ - [7.2 创建镜像仓库](#72-创建镜像仓库)
+ - [7.3 上传镜像](#73-上传镜像)
+- [八 总结](#八-总结)
+
+
+
+## 一 Docker 下载镜像
+
+如果我们想要在本地运行容器，就必须保证本地存在对应的镜像。所以，第一步，我们需要下载镜像。当我们尝试下载镜像时，Docker 会尝试先从默认的镜像仓库（默认使用 Docker Hub 公共仓库）去下载，当然了，用户也可以自定义配置想要下载的镜像仓库。
+
+### 1.1 下载镜像
+
+镜像是运行容器的前提，我们可以使用 `docker pull[IMAGE_NAME]:[TAG]`命令来下载镜像，其中 `IMAGE_NAME` 表示的是镜像的名称，而 `TAG` 是镜像的标签，也就是说我们需要通过 “**镜像 + 标签**” 的方式来下载镜像。
+
+**注意：** 您也可以不显式地指定 TAG, 它会默认下载 latest 标签，也就是下载仓库中最新版本的镜像。这里并不推荐您下载 latest 标签，因为该镜像的内容会跟踪镜像的最新版本，并随之变化，所以它是不稳定的。在生产环境中，可能会出现莫名其妙的 bug, 推荐您最好还是显示的指定具体的 TAG。
+
+举个例子，如我们想要下载一个 Mysql 5.7 镜像，可以通过命令来下载：
+
+```
+docker pull mysql:5.7
+```
+
+会看到控制台输出内容如下：
+
+
+
+**注意：** 由于官方 DockerHub 仓库服务器在国外，下载速度较慢，所以我将仓库的地址更改成了国内的 `docker.io` 的镜像仓库，所以在上图中，镜像前面会有 `docker.io` 出现。
+
+当有 **Downloaded** 字符串输出的时候，说明下载成功了！！
+
+### 1.2 验证
+
+让我们来验证一下，本地是否存在 Mysql5.7 的镜像，运行命令：
+
+```
+docker images
+```
+
+
+
+可以看到本地的确存在该镜像，确实是下载成功了！
+
+### 1.3 下载镜像相关细节
+
+再说说上面下载镜像的过程：
+
+
+
+通过下载过程，可以看到，一个镜像一般是由多个层（ `layer`） 组成，类似 `f7e2b70d04ae`这样的串表示层的唯一 ID（实际上完整的 ID 包括了 256 个 bit, 64 个十六进制字符组成）。
+
+**您可能会想，如果多个不同的镜像中，同时包含了同一个层（ layer）,这样重复下载，岂不是导致了存储空间的浪费么?**
+
+实际上，Docker 并不会这么傻会去下载重复的层（ `layer`）,Docker 在下载之前，会去检测本地是否会有同样 ID 的层，如果本地已经存在了，就直接使用本地的就好了。
+
+**另一个问题，不同仓库中，可能也会存在镜像重名的情况发生, 这种情况咋办？**
+
+严格意义上，我们在使用 `docker pull` 命令时，还需要在镜像前面指定仓库地址( `Registry`), 如果不指定，则 Docker 会使用您默认配置的仓库地址。例如上面，由于我配置的是国内 `docker.io` 的仓库地址，我在 `pull` 的时候，docker 会默认为我加上 `docker.io/library` 的前缀。
+
+如：当我执行 `docker pull mysql:5.7` 命令时，实际上相当于 `docker pull docker.io/mysql:5.7`，如果您未自定义配置仓库，则默认在下载的时候，会在镜像前面加上 DockerHub 的地址。
+
+Docker 通过前缀地址的不同，来保证不同仓库中，重名镜像的唯一性。
+
+### 1.4 PULL 子命令
+
+命令行中输入：
+
+```
+docker pull --help
+```
+
+会得到如下信息：
+
+```
+[root@iZbp1j8y1bab0djl9gdp33Z ~]# docker pull --help
+Usage: docker pull [OPTIONS] NAME[:TAG|@DIGEST]
+Pull an image or a repository from a registry
+Options: -a, --all-tags Download all tagged images in the repository --disable-content-trust Skip image verification (default true) --help Print usage
+```
+
+我们可以看到主要支持的子命令有：
+
+1. `-a,--all-tags=true|false`: 是否获取仓库中所有镜像，默认为否；
+2. `--disable-content-trust`: 跳过镜像内容的校验，默认为 true;
+
+## 二 Docker 查看镜像信息
+
+### 2.1 images 命令列出镜像
+
+通过使用如下两个命令，列出本机已有的镜像：
+
+```
+docker images
+```
+
+或：
+
+```
+docker image ls
+```
+
+如下图所示：
+
+
+
+对上述红色标注的字段做一下解释：
+
+- **REPOSITORY**: 来自于哪个仓库；
+- **TAG**: 镜像的标签信息，比如 5.7、latest 表示不同的版本信息；
+- **IMAGE ID**: 镜像的 ID, 如果您看到两个 ID 完全相同，那么实际上，它们指向的是同一个镜像，只是标签名称不同罢了；
+- **CREATED**: 镜像最后的更新时间；
+- **SIZE**: 镜像的大小，优秀的镜像一般体积都比较小，这也是我更倾向于使用轻量级的 alpine 版本的原因；
+
+> 注意：图中的镜像大小信息只是逻辑上的大小信息，因为一个镜像是由多个镜像层（ `layer`）组成的，而相同的镜像层本地只会存储一份，所以，真实情况下，占用的物理存储空间大小，可能会小于逻辑大小。
+
+### 2.2 使用 tag 命令为镜像添加标签
+
+通常情况下，为了方便在后续工作中，快速地找到某个镜像，我们可以使用 `docker tag` 命令，为本地镜像添加一个新的标签。如下图所示：
+
+
+
+为 `docker.io/mysql` 镜像，添加新的镜像标签 `allen_mysql:5.7`。然后使用 `docker images` 命令，查看本地镜像：
+
+
+
+可以看到，本地多了一个 `allen_mysql:5.7` 的镜像。细心的你一定还会发现， `allen_mysql:5.7` 和 `docker.io/mysql:5.7` 的镜像 ID 是一模一样的，说明它们是同一个镜像，只是别名不同而已。
+
+`docker tag` 命令功能更像是, 为指定镜像添加快捷方式一样。
+
+### 2.3 使用 inspect 命令查看镜像详细信息
+
+通过 `docker inspect` 命令，我们可以获取镜像的详细信息，其中，包括创建者，各层的数字摘要等。
+
+```
+docker inspect docker.io/mysql:5.7
+```
+
+
+
+`docker inspect` 返回的是 `JSON` 格式的信息，如果您想获取其中指定的一项内容，可以通过 `-f` 来指定，如获取镜像大小：
+
+```
+docker inspect -f {{".Size"}} docker.io/mysql:5.7
+```
+
+
+
+### 2.4 使用 history 命令查看镜像历史
+
+前面的小节中，我们知道了，一个镜像是由多个层（layer）组成的，那么，我们要如何知道各个层的具体内容呢？
+
+通过 `docker history` 命令，可以列出各个层（layer）的创建信息，如我们查看 `docker.io/mysql:5.7` 的各层信息：
+
+```
+docker history docker.io/mysql:5.7
+```
+
+
+
+可以看到，上面过长的信息，为了方便展示，后面都省略了，如果您想要看具体信息，可以通过添加 `--no-trunc` 选项，如下面命令：
+
+```
+docker history --no-trunc docker.io/mysql:5.7
+```
+
+## 三 Docker 搜索镜像
+
+### 3.1 search 命令
+
+您可以通过下面命令进行搜索：
+
+```
+docker search [option] keyword
+```
+
+比如，您想搜索仓库中 `mysql` 相关的镜像，可以输入如下命令：
+
+```
+docker search mysql
+```
+
+
+
+### 3.2 search 子命令
+
+命令行输入 `docker search--help`, 输出如下：
+
+```
+Usage: docker search [OPTIONS] TERM
+Search the Docker Hub for images
+Options: -f, --filter filter Filter output based on conditions provided --help Print usage --limit int Max number of search results (default 25) --no-index Don't truncate output --no-trunc Don't truncate output
+```
+
+可以看到 `search` 支持的子命令有：
+
+- `-f,--filter filter`: 过滤输出的内容；
+- `--limitint`：指定搜索内容展示个数;
+- `--no-index`: 不截断输出内容；
+- `--no-trunc`：不截断输出内容；
+
+举个列子，比如我们想搜索官方提供的 mysql 镜像，命令如下：
+
+```
+docker search --filter=is-offical=true mysql
+```
+
+
+
+再比如，我们想搜索 Stars 数超过 100 的 mysql 镜像：
+
+```
+docker search --filter=stars=100 mysql
+```
+
+
+
+## 四 Docker 删除镜像
+
+### 4.1 通过标签删除镜像
+
+通过如下两个都可以删除镜像：
+
+```
+docker rmi [image]
+```
+
+或者：
+
+```
+docker image rm [image]
+```
+
+支持的子命令如下：
+
+- `-f,-force`: 强制删除镜像，即便有容器引用该镜像；
+- `-no-prune`: 不要删除未带标签的父镜像；
+
+Docker 查看镜像信息
+
+例如，我们想删除上章节创建的 `allen_mysql:5.7` 镜像，命令如下：
+
+```shell
+docker rmi allen_mysql:5.7
+```
+
+
+
+从上面章节中，我们知道 `allen_mysql:5.7` 和 `docker.io/mysql:5.7` 实际上指向的是同一个镜像，那么，您可以能会有疑问，我删除了 `allen_mysql:5.7`, 会不会将 `docker.io/mysql:5.7` 镜像也给删除了？
+
+**实际上，当同一个镜像拥有多个标签时，执行 `docker rmi` 命令，只是会删除了该镜像众多标签中，您指定的标签而已，并不会影响原始的那个镜像文件。**
+
+不信的话，我们可以执行 `docker images` 命令，来看下 `docker.io/mysql:5.7` 镜像还在不在：
+
+
+
+可以看到， `docker.io/mysql:5.7` 镜像依然存在！
+
+那么，如果某个镜像不存在多个标签，当且仅当只有一个标签时，执行删除命令时，您就要小心了，这会彻底删除镜像。
+
+例如，这个时候，我们再执行 `docker rmi docker.io/mysql:5.7` 命令：
+
+
+
+从上图可以看到，我们已经删除了 `docker.io/mysql:5.7` 镜像的所有文件层。该镜像在本地已不复存在了！
+
+### 4.2 通过 ID 删除镜像
+
+除了通过标签名称来删除镜像，我们还可以通过制定镜像 ID, 来删除镜像，如：
+
+```
+docker rmi ee7cbd482336
+```
+
+一旦制定了通过 ID 来删除镜像，它会先尝试删除所有指向该镜像的标签，然后在删除镜像本身。
+
+### 4.3 删除镜像的限制
+
+删除镜像很简单，但也不是我们何时何地都能删除的，它存在一些限制条件。
+
+当通过该镜像创建的容器未被销毁时，镜像是无法被删除的。为了验证这一点，我们来做个试验。首先，我们通过 `docker pull alpine` 命令，拉取一个最新的 `alpine` 镜像, 然后启动镜像，让其输出 `hello,docker!`:
+
+
+
+接下来，我们来删除这个镜像试试：
+
+
+
+可以看到提示信息，无法删除该镜像，因为有容器正在引用他！同时，这段信息还告诉我们，除非通过添加 `-f` 子命令，也就是强制删除，才能移除掉该镜像！
+
+```
+docker rmi -f docker.io/alpine
+```
+
+但是，我们一般不推荐这样暴力的做法，正确的做法应该是：
+
+1. 先删除引用这个镜像的容器；
+2. 再删除这个镜像；
+
+也就是，根据上图中提示的，引用该镜像的容器 ID ( `9d59e2278553`), 执行删除命令：
+
+```
+docker rm 9d59e2278553
+```
+
+然后，再执行删除镜像的命令：
+
+```
+docker rmi 5cb3aa00f899
+```
+
+Docker 删除镜像
+
+这个时候，就能正常删除了！
+
+### 4.4 清理镜像
+
+我们在使用 Docker 一段时间后，系统一般都会残存一些临时的、没有被使用的镜像文件，可以通过以下命令进行清理：
+
+```
+docker image prune
+```
+
+它支持的子命令有：
+
+- `-a,--all`: 删除所有没有用的镜像，而不仅仅是临时文件；
+- `-f,--force`：强制删除镜像文件，无需弹出提示确认；
+
+## 五 Docker 创建镜像
+
+此小节中，您将学习 Docker 如何创建镜像？Docker 创建镜像主要有三种：
+
+1. 基于已有的镜像创建；
+2. 基于 Dockerfile 来创建；
+3. 基于本地模板来导入；
+
+我们将主要介绍常用的 1，2 两种。
+
+### 5.1 基于已有的镜像创建
+
+通过如下命令来创建：
+
+```
+docker container commit
+```
+
+支持的子命令如下：
+
+- `-a,--author`="": 作者信息；
+- `-c,--change`=[]: 可以在提交的时候执行 Dockerfile 指令，如 CMD、ENTRYPOINT、ENV、EXPOSE、LABEL、ONBUILD、USER、VOLUME、WORIR 等；
+- `-m,--message`="": 提交信息；
+- `-p,--pause`=true: 提交时，暂停容器运行。
+
+接下来，基于本地已有的 Ubuntu 镜像，创建一个新的镜像：
+
+
+
+首先，让我将它运行起来，并在其中创建一个 test.txt 文件：
+
+
+
+命令如下：
+
+```
+docker run -it docker.io/ubuntu:latest /bin/bashroot@a0a0c8cfec3a:/# touch test.txtroot@a0a0c8cfec3a:/# exit
+```
+
+创建完 test.txt 文件后，需要记住标注的容器 ID: `a0a0c8cfec3a`, 用它来提交一个新的镜像(**PS: 你也可以通过名称来提交镜像，这里只演示通过 ID 的方式**)。
+
+执行命令：
+
+```
+docker container commit -m "Added test.txt file" -a "Allen" a0a0c8cfec3a test:0.1
+```
+
+提交成功后，会返回新创建的镜像 ID 信息，如下图所示：
+
+
+
+再次查看本地镜像信息，可以看到新创建的 `test:0.1` 镜像了：
+
+
+
+### 5.2 基于 Dockerfile 创建
+
+通过 Dockerfile 的方式来创建镜像，是最常见的一种方式了，也是比较推荐的方式。Dockerfile 是一个文本指令文件，它描述了是如何基于一个父镜像，来创建一个新镜像的过程。
+
+下面让我们来编写一个简单的 Dockerfile 文件，它描述了基于 Ubuntu 父镜像，安装 Python3 环境的镜像：
+
+```
+FROM docker.io/ubuntu:latest
+LABEL version="1.0" maintainer="Allen "
+RUN apt-get update && \ apt-get install -y python3 && \ apt-get clean && \ rm -rf /var/lib/apt/lists/*
+```
+
+创建完成后，通过这个 Dockerfile 文件，来构建新的镜像，执行命令：
+
+```
+docker image build -t python:3 .
+```
+
+**注意：** 命令的最后有个点，如果不加的话，会构建不成功 ！
+
+
+
+编译成功后，再次查看本地镜像信息，就可以看到新构建的 python:3 镜像了。
+
+
+
+## 六 Docker 导出&加载镜像
+
+此小节中，您将学习 Docker 如何导出&加载镜像。
+
+通常我们会有下面这种需求，需要将镜像分享给别人，这个时候，我们可以将镜像导出成 tar 包，别人直接通过加载这个 tar 包，快速地将镜像引入到本地镜像库。
+
+要想使用这两个功能，主要是通过如下两个命令：
+
+1. `docker save`
+2. `docker load`
+
+### 6.1 导出镜像
+
+查看本地镜像如下：
+
+
+
+例如，我们想要将 python:3 镜像导出来，执行命令：
+
+```
+docker save -o python_3.tar python:3
+```
+
+执行成功后，查看当前目录：
+
+Docker 导出文件
+
+可以看到 `python_3.tar` 镜像文件已经生成。接下来，你可以将它通过复制的方式，分享给别人了！
+
+### 6.2 加载镜像
+
+别人拿到了这个 `tar` 包后，要如何导入到本地的镜像库呢？
+
+通过执行如下命令：
+
+```
+docker load -i python_3.tar
+```
+
+或者：
+
+```
+docker load < python_3.tar
+```
+
+导入成功后，查看本地镜像信息，你就可以获得别人分享的镜像了！怎么样，是不是很方便呢！
+
+## 七 Docker 上传镜像
+
+我们将以上传到 Docker Hub 上为示例，演示 Docker 如何上传镜像。
+
+### 7.1 获取 Docker ID
+
+想要上传镜像到 Docker Hub 上，首先，我们需要注册 Docker Hub 账号。打开 Docker Hub 网址 https://hub.docker.com，开始注册：
+
+
+
+填写您的 Docker ID (也就是账号)，以及密码，Email, 点击继续。
+
+接下来，Docker Hub 会发送验证邮件，到您填写的邮箱当中：
+
+
+
+点击验证即可，接下来，再次返回 Docker Hub 官网，用您刚刚注册的 Docker ID 和密码来登录账号！
+
+
+
+### 7.2 创建镜像仓库
+
+登录成功后，会出现如下页面：
+
+
+
+选择创建一个镜像仓库：
+
+
+
+填写**仓库名称**、**描述信息**、**是否公开后**，点击创建。
+
+仓库镜像展示页
+
+我们看到，仓库已经创建成功了，但是里面还没有任何镜像，接下来开始上传镜像，到此新创建的仓库中。
+
+### 7.3 上传镜像
+
+进入命令行，**用我们刚刚获取的 Docker ID 以及密码登录**，执行命令：
+
+```
+docker login
+```
+
+命令行登录 Docker ID
+
+登录成功后，我们开始准备上传本地的 `python:3` 镜像：
+
+
+
+首先，我们对其打一个新的标签，**前缀与我们新创建的 Docker ID 、仓库名保持一致**:
+
+```
+docker tag python:3 weiwosuoai1991/python:3
+```
+
+
+
+查看本地信息，可以看到，标签打成功了。接下开，开始上传！执行命令：
+
+```
+docker push weiwosuoai1991/python:3
+```
+
+
+
+上传成功！去 Docker Hub 官网，新创建的仓库的信息页面验证一下，是否真的成功了：
+
+仓库镜像展示页
+
+大工告成！！！
+
+## 八 总结
+
+本文中，我们着重学习了 Docker 中下载镜像,、查看镜像信息、搜索镜像、删除镜像,、创建镜像、导出&加载镜像以及向 Docker Hub 上传镜像的相关操作。
\ No newline at end of file
diff --git a/docs/tools/Docker.md b/docs/tools/Docker.md
new file mode 100644
index 00000000000..b7dd4f50ffd
--- /dev/null
+++ b/docs/tools/Docker.md
@@ -0,0 +1,220 @@
+**本文只是对Docker的概念做了较为详细的介绍，并不涉及一些像Docker环境的安装以及Docker的一些常见操作和命令。**
+
+
+
+- [一 先从认识容器开始](#一-先从认识容器开始)
+ - [1.1 什么是容器?](#11-什么是容器)
+ - [先来看看容器较为官方的解释](#先来看看容器较为官方的解释)
+ - [再来看看容器较为通俗的解释](#再来看看容器较为通俗的解释)
+ - [1.2 图解物理机,虚拟机与容器](#12-图解物理机虚拟机与容器)
+- [二 再来谈谈 Docker 的一些概念](#二-再来谈谈-docker-的一些概念)
+ - [2.1 什么是 Docker?](#21-什么是-docker)
+ - [2.2 Docker 思想](#22-docker-思想)
+ - [2.3 Docker 容器的特点](#23-docker-容器的特点)
+ - [2.4 为什么要用 Docker ?](#24-为什么要用-docker-)
+- [三 容器 VS 虚拟机](#三-容器-vs-虚拟机)
+ - [3.1 两者对比图](#31-两者对比图)
+ - [3.2 容器与虚拟机总结](#32-容器与虚拟机总结)
+ - [3.3 容器与虚拟机两者是可以共存的](#33-容器与虚拟机两者是可以共存的)
+- [四 Docker基本概念](#四-docker基本概念)
+ - [4.1 镜像(Image):一个特殊的文件系统](#41-镜像image一个特殊的文件系统)
+ - [4.2 容器(Container):镜像运行时的实体](#42-容器container镜像运行时的实体)
+ - [4.3仓库(Repository):集中存放镜像文件的地方](#43仓库repository集中存放镜像文件的地方)
+- [五 最后谈谈:Build Ship and Run](#五-最后谈谈build-ship-and-run)
+- [六 总结](#六-总结)
+
+
+
+> **Docker 是世界领先的软件容器平台**，所以想要搞懂Docker的概念我们必须先从容器开始说起。
+
+## 一 先从认识容器开始
+
+### 1.1 什么是容器?
+
+#### 先来看看容器较为官方的解释
+
+**一句话概括容器：容器就是将软件打包成标准化单元，以用于开发、交付和部署。**
+
+- **容器镜像是轻量的、可执行的独立软件包** ，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。
+- **容器化软件适用于基于Linux和Windows的应用，在任何环境中都能够始终如一地运行。**
+- **容器赋予了软件独立性** ，使其免受外在环境差异（例如，开发和预演环境的差异）的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。
+
+#### 再来看看容器较为通俗的解释
+
+**如果需要通俗的描述容器的话，我觉得容器就是一个存放东西的地方，就像书包可以装各种文具、衣柜可以放各种衣服、鞋架可以放各种鞋子一样。我们现在所说的容器存放的东西可能更偏向于应用比如网站、程序甚至是系统环境。**
+
+
+
+### 1.2 图解物理机,虚拟机与容器
+关于虚拟机与容器的对比在后面会详细介绍到，这里只是通过网上的图片加深大家对于物理机、虚拟机与容器这三者的理解。
+
+**物理机**
+
+
+**虚拟机：**
+
+
+
+**容器：**
+
+
+
+通过上面这三张抽象图，我们可以大概可以通过类比概括出： **容器虚拟化的是操作系统而不是硬件，容器之间是共享同一套操作系统资源的。虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统。因此容器的隔离级别会稍低一些。**
+
+---
+
+> 相信通过上面的解释大家对于容器这个既陌生又熟悉的概念有了一个初步的认识，下面我们就来谈谈Docker的一些概念。
+
+## 二 再来谈谈 Docker 的一些概念
+
+
+
+### 2.1 什么是 Docker?
+
+说实话关于Docker是什么并太好说，下面我通过四点向你说明Docker到底是个什么东西。
+
+- **Docker 是世界领先的软件容器平台。**
+- **Docker** 使用 Google 公司推出的 **Go 语言** 进行开发实现，基于 **Linux 内核** 的cgroup，namespace，以及AUFS类的**UnionFS**等技术，**对进程进行封装隔离，属于操作系统层面的虚拟化技术。** 由于隔离的进程独立于宿主和其它的隔离的进
+程，因此也称其为容器。**Docke最初实现是基于 LXC.**
+- **Docker 能够自动执行重复性任务，例如搭建和配置开发环境，从而解放了开发人员以便他们专注在真正重要的事情上：构建杰出的软件。**
+- **用户可以方便地创建和使用容器，把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。**
+
+
+
+### 2.2 Docker 思想
+
+- **集装箱**
+- **标准化：** ①运输方式 ② 存储方式 ③ API接口
+- **隔离**
+
+### 2.3 Docker 容器的特点
+
+- #### 轻量
+
+ 在一台机器上运行的多个 Docker 容器可以共享这台机器的操作系统内核；它们能够迅速启动，只需占用很少的计算和内存资源。镜像是通过文件系统层进行构造的，并共享一些公共文件。这样就能尽量降低磁盘用量，并能更快地下载镜像。
+- #### 标准
+
+ Docker 容器基于开放式标准，能够在所有主流 Linux 版本、Microsoft Windows 以及包括 VM、裸机服务器和云在内的任何基础设施上运行。
+- #### 安全
+
+ Docker 赋予应用的隔离性不仅限于彼此隔离，还独立于底层的基础设施。Docker 默认提供最强的隔离，因此应用出现问题，也只是单个容器的问题，而不会波及到整台机器。
+
+### 2.4 为什么要用 Docker ?
+
+- **Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 “这段代码在我机器上没问题啊” 这类问题；——一致的运行环境**
+- **可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。——更快速的启动时间**
+- **避免公用的服务器，资源会容易受到其他用户的影响。——隔离性**
+- **善于处理集中爆发的服务器使用压力；——弹性伸缩，快速扩展**
+- **可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。——迁移方便**
+- **使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。——持续交付和部署**
+
+---
+
+> 每当说起容器，我们不得不将其与虚拟机做一个比较。就我而言，对于两者无所谓谁会取代谁，而是两者可以和谐共存。
+
+## 三 容器 VS 虚拟机
+
+ 简单来说： **容器和虚拟机具有相似的资源隔离和分配优势，但功能有所不同，因为容器虚拟化的是操作系统，而不是硬件，因此容器更容易移植，效率也更高。**
+
+### 3.1 两者对比图
+
+ 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便.
+
+
+
+### 3.2 容器与虚拟机总结
+
+
+
+- **容器是一个应用层抽象，用于将代码和依赖资源打包在一起。** **多个容器可以在同一台机器上运行，共享操作系统内核，但各自作为独立的进程在用户空间中运行** 。与虚拟机相比， **容器占用的空间较少**（容器镜像大小通常只有几十兆），**瞬间就能完成启动** 。
+
+- **虚拟机 (VM) 是一个物理硬件层抽象，用于将一台服务器变成多台服务器。** 管理程序允许多个 VM 在一台机器上运行。每个VM都包含一整套操作系统、一个或多个应用、必要的二进制文件和库资源，因此 **占用大量空间** 。而且 VM **启动也十分缓慢** 。
+
+ 通过Docker官网，我们知道了这么多Docker的优势，但是大家也没有必要完全否定虚拟机技术，因为两者有不同的使用场景。**虚拟机更擅长于彻底隔离整个运行环境**。例如，云服务提供商通常采用虚拟机技术隔离不同的用户。而 **Docker通常用于隔离不同的应用** ，例如前端，后端以及数据库。
+
+### 3.3 容器与虚拟机两者是可以共存的
+
+就我而言，对于两者无所谓谁会取代谁，而是两者可以和谐共存。
+
+
+
+---
+
+> Docker中非常重要的三个基本概念，理解了这三个概念，就理解了 Docker 的整个生命周期。
+
+## 四 Docker基本概念
+
+Docker 包括三个基本概念
+
+- **镜像（Image）**
+- **容器（Container）**
+- **仓库（Repository）**
+
+理解了这三个概念，就理解了 Docker 的整个生命周期
+
+
+
+### 4.1 镜像(Image):一个特殊的文件系统
+
+ **操作系统分为内核和用户空间**。对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持。而Docker 镜像（Image），就相当于是一个 root 文件系统。
+
+ **Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。** 镜像不包含任何动态数据，其内容在构建之后也不会被改变。
+
+ Docker 设计时，就充分利用 **Union FS**的技术，将其设计为 **分层存储的架构** 。 镜像实际是由多层文件系统联合组成。
+
+ **镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。** 比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。
+
+ 分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。
+
+### 4.2 容器(Container):镜像运行时的实体
+
+ 镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类 和 实例 一样，镜像是静态的定义，**容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等** 。
+
+ **容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 命名空间。前面讲过镜像使用的是分层存储，容器也是如此。**
+
+ **容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。**
+
+ 按照 Docker 最佳实践的要求，**容器不应该向其存储层内写入任何数据** ，容器存储层要保持无状态化。**所有的文件写入操作，都应该使用数据卷（Volume）、或者绑定宿主目录**，在这些位置的读写会跳过容器存储层，直接对宿主(或网络存储)发生读写，其性能和稳定性更高。数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此， **使用数据卷后，容器可以随意删除、重新 run ，数据却不会丢失。**
+
+
+### 4.3仓库(Repository):集中存放镜像文件的地方
+
+ 镜像构建完成后，可以很容易的在当前宿主上运行，但是， **如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry就是这样的服务。**
+
+ 一个 Docker Registry中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。所以说：**镜像仓库是Docker用来集中存放镜像文件的地方类似于我们之前常用的代码仓库。**
+
+ 通常，**一个仓库会包含同一个软件不同版本的镜像**，而**标签就常用于对应该软件的各个版本** 。我们可以通过```<仓库名>:<标签>```的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签.。
+
+**这里补充一下Docker Registry 公开服务和私有 Docker Registry的概念：**
+
+ **Docker Registry 公开服务** 是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像。
+
+ 最常使用的 Registry 公开服务是官方的 **Docker Hub** ，这也是默认的 Registry，并拥有大量的高质量的官方镜像，网址为：[https://hub.docker.com/](https://hub.docker.com/) 。在国内访问**Docker Hub** 可能会比较慢国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 [时速云镜像库](https://hub.tenxcloud.com/)、[网易云镜像服务](https://www.163yun.com/product/repo)、[DaoCloud 镜像市场](https://www.daocloud.io/)、[阿里云镜像库](https://www.aliyun.com/product/containerservice?utm_content=se_1292836)等。
+
+ 除了使用公开服务外，用户还可以在 **本地搭建私有 Docker Registry** 。Docker 官方提供了 Docker Registry 镜像，可以直接使用做为私有 Registry 服务。开源的 Docker Registry 镜像只提供了 Docker Registry API 的服务端实现，足以支持 docker 命令，不影响使用。但不包含图形界面，以及镜像维护、用户管理、访问控制等高级功能。
+
+---
+
+> Docker的概念基本上已经讲完，最后我们谈谈：Build, Ship, and Run。
+
+## 五 最后谈谈:Build Ship and Run
+如果你搜索Docker官网，会发现如下的字样：**“Docker - Build, Ship, and Run Any App, Anywhere”**。那么Build, Ship, and Run到底是在干什么呢？
+
+
+
+- **Build（构建镜像）** ： 镜像就像是集装箱包括文件以及运行环境等等资源。
+- **Ship（运输镜像）** ：主机和仓库间运输，这里的仓库就像是超级码头一样。
+- **Run （运行镜像）** ：运行的镜像就是一个容器，容器就是运行程序的地方。
+
+**Docker 运行过程也就是去仓库把镜像拉到本地，然后用一条命令把镜像运行起来变成容器。所以，我们也常常将Docker称为码头工人或码头装卸工，这和Docker的中文翻译搬运工人如出一辙。**
+
+## 六 总结
+
+本文主要把Docker中的一些常见概念做了详细的阐述，但是并不涉及Docker的安装、镜像的使用、容器的操作等内容。这部分东西，希望读者自己可以通过阅读书籍与官方文档的形式掌握。如果觉得官方文档阅读起来很费力的话，这里推荐一本书籍《Docker技术入门与实战第二版》。
+
+
+
+
+
+
+
diff --git a/docs/tools/Git.md b/docs/tools/Git.md
new file mode 100644
index 00000000000..e58f13b63aa
--- /dev/null
+++ b/docs/tools/Git.md
@@ -0,0 +1,258 @@
+
+
+- [版本控制](#版本控制)
+ - [什么是版本控制](#什么是版本控制)
+ - [为什么要版本控制](#为什么要版本控制)
+ - [本地版本控制系统](#本地版本控制系统)
+ - [集中化的版本控制系统](#集中化的版本控制系统)
+ - [分布式版本控制系统](#分布式版本控制系统)
+- [认识 Git](#认识-git)
+ - [Git 简史](#git-简史)
+ - [Git 与其他版本管理系统的主要区别](#git-与其他版本管理系统的主要区别)
+ - [Git 的三种状态](#git-的三种状态)
+- [Git 使用快速入门](#git-使用快速入门)
+ - [获取 Git 仓库](#获取-git-仓库)
+ - [记录每次更新到仓库](#记录每次更新到仓库)
+ - [推送改动到远程仓库](#推送改动到远程仓库)
+ - [远程仓库的移除与重命名](#远程仓库的移除与重命名)
+ - [查看提交历史](#查看提交历史)
+ - [撤销操作](#撤销操作)
+ - [分支](#分支)
+- [推荐阅读](#推荐阅读)
+
+
+
+## 版本控制
+
+### 什么是版本控制
+
+版本控制是一种记录一个或若干文件内容变化，以便将来查阅特定版本修订情况的系统。 除了项目源代码，你可以对任何类型的文件进行版本控制。
+
+### 为什么要版本控制
+
+有了它你就可以将某个文件回溯到之前的状态，甚至将整个项目都回退到过去某个时间点的状态，你可以比较文件的变化细节，查出最后是谁修改了哪个地方，从而找出导致怪异问题出现的原因，又是谁在何时报告了某个功能缺陷等等。
+
+### 本地版本控制系统
+
+许多人习惯用复制整个项目目录的方式来保存不同的版本，或许还会改名加上备份时间以示区别。 这么做唯一的好处就是简单，但是特别容易犯错。 有时候会混淆所在的工作目录，一不小心会写错文件或者覆盖意想外的文件。
+
+为了解决这个问题，人们很久以前就开发了许多种本地版本控制系统，大多都是采用某种简单的数据库来记录文件的历次更新差异。
+
+
+
+### 集中化的版本控制系统
+
+接下来人们又遇到一个问题，如何让在不同系统上的开发者协同工作？ 于是，集中化的版本控制系统（Centralized Version Control Systems，简称 CVCS）应运而生。
+
+集中化的版本控制系统都有一个单一的集中管理的服务器，保存所有文件的修订版本，而协同工作的人们都通过客户端连到这台服务器，取出最新的文件或者提交更新。
+
+
+
+这么做虽然解决了本地版本控制系统无法让在不同系统上的开发者协同工作的诟病，但也还是存在下面的问题：
+
+- **单点故障：** 中央服务器宕机，则其他人无法使用；如果中心数据库磁盘损坏有没有进行备份，你将丢失所有数据。本地版本控制系统也存在类似问题，只要整个项目的历史记录被保存在单一位置，就有丢失所有历史更新记录的风险。
+- **必须联网才能工作：** 受网络状况、带宽影响。
+
+### 分布式版本控制系统
+
+于是分布式版本控制系统（Distributed Version Control System，简称 DVCS）面世了。 Git 就是一个典型的分布式版本控制系统。
+
+这类系统，客户端并不只提取最新版本的文件快照，而是把代码仓库完整地镜像下来。 这么一来，任何一处协同工作用的服务器发生故障，事后都可以用任何一个镜像出来的本地仓库恢复。 因为每一次的克隆操作，实际上都是一次对代码仓库的完整备份。
+
+
+
+分布式版本控制系统可以不用联网就可以工作，因为每个人的电脑上都是完整的版本库，当你修改了某个文件后，你只需要将自己的修改推送给别人就可以了。但是，在实际使用分布式版本控制系统的时候，很少会直接进行推送修改，而是使用一台充当“中央服务器”的东西。这个服务器的作用仅仅是用来方便“交换”大家的修改，没有它大家也一样干活，只是交换修改不方便而已。
+
+分布式版本控制系统的优势不单是不必联网这么简单，后面我们还会看到 Git 极其强大的分支管理等功能。
+
+## 认识 Git
+
+### Git 简史
+
+Linux 内核项目组当时使用分布式版本控制系统 BitKeeper 来管理和维护代码。但是，后来开发 BitKeeper 的商业公司同 Linux 内核开源社区的合作关系结束，他们收回了 Linux 内核社区免费使用 BitKeeper 的权力。 Linux 开源社区（特别是 Linux 的缔造者 Linus Torvalds）基于使用 BitKeeper 时的经验教训，开发出自己的版本系统，而且对新的版本控制系统做了很多改进。
+
+### Git 与其他版本管理系统的主要区别
+
+ Git 在保存和对待各种信息的时候与其它版本控制系统有很大差异，尽管操作起来的命令形式非常相近，理解这些差异将有助于防止你使用中的困惑。
+
+下面我们主要说一个关于 Git 其他版本管理系统的主要差别：**对待数据的方式**。
+
+**Git采用的是直接记录快照的方式，而非差异比较。我后面会详细介绍这两种方式的差别。**
+
+大部分版本控制系统（CVS、Subversion、Perforce、Bazaar 等等）都是以文件变更列表的方式存储信息，这类系统**将它们保存的信息看作是一组基本文件和每个文件随时间逐步累积的差异。**
+
+具体原理如下图所示，理解起来其实很简单，每个我们对提交更新一个文件之后，系统记录都会记录这个文件做了哪些更新，以增量符号Δ(Delta)表示。
+
+
+
+
+
+
+
+
+
+
+
+
前言
如果你有不错的大厂面试经历
如果你对某一个Java知识点有过深刻的见解和记录
如果你有什么学习编程的经验分享给其他人
......
如果你想，你都可以把这些整理成文章投稿给我，你的文章将被更多人看到，你所写的东西也可能会默默影响到很多人。
欢迎的文章类型
本公众号主要接受下面几类文章投稿：
- 大厂Java面试经历、面试总结、面试注意事项等等
- 对某一个Java知识点的深刻讲解
- 技术热点
- 一些行业内不错的人物或者公司传记
- ......
因为本公众号主要是Java方向，所以还有其他Java方向的文章都可以投稿。
投稿的要求很简单，你能把一个知识点讲清楚就好，JavaGuide 里面还有很多知识点没有加，我觉得都是不错的方向（内容我会帮你完善）。 这个投稿的目的是完善开源项目 JavaGuide 的同时能够让大家自主去学习并总结知识点。
奖励
投稿自己的原创文章成功之后不仅可以顺利加入32k+star 的开源项目 JavaGuide:https://github.com/Snailclimb/JavaGuide 扩大自己的竞争力，还会有50元左右的任意书籍或者50元现金奖励(对于不错的文章会更高)。
投稿方式
下面 2 种方式都可以
- 将你的文章以 Markdown 格式发送到我的邮箱：koushuangbwcx@163.com ;
- 直接在 Github : https://github.com/Snailclimb/JavaGuide 提PR也可以 。
如果你也是公众号号主，你也有自己不错的文章想投稿给我的话，虽然你不会有奖励，但是发了你的文章之后，肯定会为你带来一些新人关注。
- * 用私钥解密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] decryptByPrivateKey(String data, String key) throws Exception {
- return decryptByPrivateKey(decryptBASE64(data), key);
- }
-
- /**
- * 解密
- * 用公钥解密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
- // 对密钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得公钥
- X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key publicKey = keyFactory.generatePublic(x509KeySpec);
- // 对数据解密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.DECRYPT_MODE, publicKey);
- return cipher.doFinal(data);
- }
-
- /**
- * 加密
- * 用公钥加密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] encryptByPublicKey(String data, String key) throws Exception {
- // 对公钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得公钥
- X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key publicKey = keyFactory.generatePublic(x509KeySpec);
- // 对数据加密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.ENCRYPT_MODE, publicKey);
- return cipher.doFinal(data.getBytes());
- }
-
- /**
- * 加密
- * 用私钥加密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {
- // 对密钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得私钥
- PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
- // 对数据加密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.ENCRYPT_MODE, privateKey);
- return cipher.doFinal(data);
- }
-
- /**
- * 取得私钥
- *
- * @param keyMap
- * @return
- * @throws Exception
- */
- public static String getPrivateKey(Map keyMap) throws Exception {
- Key key = (Key) keyMap.get(PRIVATE_KEY);
- return encryptBASE64(key.getEncoded());
- }
-
- /**
- * 取得公钥
- *
- * @param keyMap
- * @return
- * @throws Exception
- */
- public static String getPublicKey(Map keyMap) throws Exception {
- Key key = keyMap.get(PUBLIC_KEY);
- return encryptBASE64(key.getEncoded());
- }
-
- /**
- * 初始化密钥
- *
- * @return
- * @throws Exception
- */
- public static Map initKey() throws Exception {
- KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
- keyPairGen.initialize(1024);
- KeyPair keyPair = keyPairGen.generateKeyPair();
- Map keyMap = new HashMap(2);
- keyMap.put(PUBLIC_KEY, keyPair.getPublic());// 公钥
- keyMap.put(PRIVATE_KEY, keyPair.getPrivate());// 私钥
- return keyMap;
- }
-
-}
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/main/java/com/snailclimb/ks/securityAlgorithm/SHA1Demo.java" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/main/java/com/snailclimb/ks/securityAlgorithm/SHA1Demo.java"
deleted file mode 100644
index ab19e3d0cf9..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/main/java/com/snailclimb/ks/securityAlgorithm/SHA1Demo.java"
+++ /dev/null
@@ -1,45 +0,0 @@
-package com.snailclimb.ks.securityAlgorithm;
-
-import java.io.UnsupportedEncodingException;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-
-public class SHA1Demo {
-
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- System.out.println(getSha1("你若安好，便是晴天"));
-
- }
-
- public static String getSha1(String str) {
- if (null == str || 0 == str.length()) {
- return null;
- }
- char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
- try {
- //创建SHA1算法消息摘要对象
- MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
- //使用指定的字节数组更新摘要。
- mdTemp.update(str.getBytes("UTF-8"));
- //生成的哈希值的字节数组
- byte[] md = mdTemp.digest();
- //SHA1算法生成信息摘要关键过程
- int j = md.length;
- char[] buf = new char[j * 2];
- int k = 0;
- for (int i = 0; i < j; i++) {
- byte byte0 = md[i];
- buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
- buf[k++] = hexDigits[byte0 & 0xf];
- }
- return new String(buf);
- } catch (NoSuchAlgorithmException e) {
- e.printStackTrace();
- } catch (UnsupportedEncodingException e) {
- e.printStackTrace();
- }
- return "0";
-
- }
-}
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/main/java/com/snailclimb/ks/securityAlgorithm/readme" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/main/java/com/snailclimb/ks/securityAlgorithm/readme"
deleted file mode 100644
index 5c2d452dd23..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/main/java/com/snailclimb/ks/securityAlgorithm/readme"
+++ /dev/null
@@ -1,3 +0,0 @@
-Des算法参考：http://blog.csdn.net/super_cui/article/details/70820983
-IDEA算法参考：https://www.xttblog.com/?p=1121
-RSA算法实现参考：https://www.cnblogs.com/xlhan/p/7120488.html
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/test/java/com/snailclimb/ks/securityAlgorithm/AppTest.java" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/test/java/com/snailclimb/ks/securityAlgorithm/AppTest.java"
deleted file mode 100644
index 932254515a0..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/source code/securityAlgorithm/src/test/java/com/snailclimb/ks/securityAlgorithm/AppTest.java"
+++ /dev/null
@@ -1,38 +0,0 @@
-package com.snailclimb.ks.securityAlgorithm;
-
-import junit.framework.Test;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-/**
- * Unit test for simple App.
- */
-public class AppTest
- extends TestCase
-{
- /**
- * Create the test case
- *
- * @param testName name of the test case
- */
- public AppTest( String testName )
- {
- super( testName );
- }
-
- /**
- * @return the suite of tests being tested
- */
- public static Test suite()
- {
- return new TestSuite( AppTest.class );
- }
-
- /**
- * Rigourous Test :-)
- */
- public void testApp()
- {
- assertTrue( true );
- }
-}
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\345\270\270\350\247\201\345\256\211\345\205\250\347\256\227\346\263\225\357\274\210MD5\343\200\201SHA1\343\200\201Base64\347\255\211\347\255\211\357\274\211\346\200\273\347\273\223.md" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\345\270\270\350\247\201\345\256\211\345\205\250\347\256\227\346\263\225\357\274\210MD5\343\200\201SHA1\343\200\201Base64\347\255\211\347\255\211\357\274\211\346\200\273\347\273\223.md"
deleted file mode 100644
index 79a03d391d8..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\345\270\270\350\247\201\345\256\211\345\205\250\347\256\227\346\263\225\357\274\210MD5\343\200\201SHA1\343\200\201Base64\347\255\211\347\255\211\357\274\211\346\200\273\347\273\223.md"
+++ /dev/null
@@ -1,849 +0,0 @@
-本文主要对消息摘要算法和加密算法做了整理，包括MD5、SHA、DES、AES、RSA等，并且提供了相应算法的Java实现和测试。
-
-# 一 消息摘要算法
-
-## **1. 简介：**
-
-- **消息摘要算法的主要特征是加密过程不需要密钥，并且经过加密的数据无法被解密**
-- **只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。**
-- **消息摘要算法主要应用在“数字签名”领域，作为对明文的摘要算法。**
-- **著名的摘要算法有RSA公司的MD5算法和SHA-1算法及其大量的变体**。
-
-## **2. 特点：**
-
-1. **无论输入的消息有多长，计算出来的消息摘要的长度总是固定的。**
-2. **消息摘要看起来是“伪随机的”。也就是说对相同的信息求摘要结果相同。**
-3. **消息轻微改变生成的摘要变化会很大**
-4. **只能进行正向的信息摘要，而无法从摘要中恢复出任何的消息，甚至根本就找不到任何与原信息相关的信息**
-
-## **3. 应用：**
-
-消息摘要算法最常用的场景就是数字签名以及数据（密码）加密了。(一般平时做项目用的比较多的就是使用MD5对用户密码进行加密)
-
-## **4. 何谓数字签名：**
-
-数字签名主要用到了非对称密钥加密技术与数字摘要技术。数字签名技术是将摘要信息用发送者的私钥加密，与原文一起传送给接收者。接收者只有用发送者的公钥才能解密被加密的摘要信息，然后用HASH函数对收到的原文产生一个摘要信息，与解密的摘要信息对比。
-如果相同，则说明收到的信息是完整的，在传输过程中没有被修改，否则说明信息被修改过.
-
-因此数字签名能够验证信息的完整性。
-数字签名是个加密的过程，数字签名验证是个解密的过程。
-
-## **5. 常见消息/数字摘要算法：**
-
-### [**MD5:**](https://baike.baidu.com/item/MD5/212708?fr=aladdin)
-
-#### 简介：
-
-MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被"压缩"成一种保密的格式
- （也就是把一个任意长度的字节串变换成一定长的十六进制数字串）。
-
-#### 特点：
-
-1. **压缩性：** 任意长度的数据，算出的MD5值长度都是固定的。
-2. **容易计算：** 从原数据计算出MD5值很容易。
-3. **抗修改性：** 对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。
-4. **强抗碰撞：** 已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。
-
-#### 代码实现：
-
-**利用JDK提供java.security.MessageDigest类实现MD5算法：**
-
-```java
-package com.snailclimb.ks.securityAlgorithm;
-
-import java.security.MessageDigest;
-
-public class MD5Demo {
-
- // test
- public static void main(String[] args) {
- System.out.println(getMD5Code("你若安好，便是晴天"));
- }
-
- private MD5Demo() {
- }
-
- // md5加密
- public static String getMD5Code(String message) {
- String md5Str = "";
- try {
- //创建MD5算法消息摘要
- MessageDigest md = MessageDigest.getInstance("MD5");
- //生成的哈希值的字节数组
- byte[] md5Bytes = md.digest(message.getBytes());
- md5Str = bytes2Hex(md5Bytes);
- }catch(Exception e) {
- e.printStackTrace();
- }
- return md5Str;
- }
-
- // 2进制转16进制
- public static String bytes2Hex(byte[] bytes) {
- StringBuffer result = new StringBuffer();
- int temp;
- try {
- for (int i = 0; i < bytes.length; i++) {
- temp = bytes[i];
- if(temp < 0) {
- temp += 256;
- }
- if (temp < 16) {
- result.append("0");
- }
- result.append(Integer.toHexString(temp));
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- return result.toString();
- }
-}
-
-```
-
-**结果：**
-```
-6bab82679914f7cb480a120b532ffa80
-
-```
-
-**注意MessageDigest类的几个方法：**
-
-```java
-static MessageDigest getInstance(String algorithm)//返回实现指定摘要算法的MessageDigest对象
-```
-```java
-byte[] digest(byte[] input)//使用指定的字节数组对摘要执行最终更新，然后完成摘要计算。
-```
-
-#### 不利用Java提供的java.security.MessageDigest类实现MD5算法：
-
-```java
-package com.snailclimb.ks.securityAlgorithm;
-
-public class MD5{
- /*
- *四个链接变量
- */
- private final int A=0x67452301;
- private final int B=0xefcdab89;
- private final int C=0x98badcfe;
- private final int D=0x10325476;
- /*
- *ABCD的临时变量
- */
- private int Atemp,Btemp,Ctemp,Dtemp;
-
- /*
- *常量ti
- *公式:floor(abs(sin(i+1))×(2pow32)
- */
- private final int K[]={
- 0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,
- 0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,0x698098d8,
- 0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,
- 0xa679438e,0x49b40821,0xf61e2562,0xc040b340,0x265e5a51,
- 0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
- 0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,
- 0xfcefa3f8,0x676f02d9,0x8d2a4c8a,0xfffa3942,0x8771f681,
- 0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,
- 0xbebfbc70,0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,
- 0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,0xf4292244,
- 0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,
- 0xffeff47d,0x85845dd1,0x6fa87e4f,0xfe2ce6e0,0xa3014314,
- 0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391};
- /*
- *向左位移数,计算方法未知
- */
- private final int s[]={7,12,17,22,7,12,17,22,7,12,17,22,7,
- 12,17,22,5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
- 4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,6,10,
- 15,21,6,10,15,21,6,10,15,21,6,10,15,21};
-
-
- /*
- *初始化函数
- */
- private void init(){
- Atemp=A;
- Btemp=B;
- Ctemp=C;
- Dtemp=D;
- }
- /*
- *移动一定位数
- */
- private int shift(int a,int s){
- return(a<>>(32-s));//右移的时候，高位一定要补零，而不是补充符号位
- }
- /*
- *主循环
- */
- private void MainLoop(int M[]){
- int F,g;
- int a=Atemp;
- int b=Btemp;
- int c=Ctemp;
- int d=Dtemp;
- for(int i = 0; i < 64; i ++){
- if(i<16){
- F=(b&c)|((~b)&d);
- g=i;
- }else if(i<32){
- F=(d&b)|((~d)&c);
- g=(5*i+1)%16;
- }else if(i<48){
- F=b^c^d;
- g=(3*i+5)%16;
- }else{
- F=c^(b|(~d));
- g=(7*i)%16;
- }
- int tmp=d;
- d=c;
- c=b;
- b=b+shift(a+F+K[i]+M[g],s[i]);
- a=tmp;
- }
- Atemp=a+Atemp;
- Btemp=b+Btemp;
- Ctemp=c+Ctemp;
- Dtemp=d+Dtemp;
-
- }
- /*
- *填充函数
- *处理后应满足bits≡448(mod512),字节就是bytes≡56（mode64)
- *填充方式为先加一个0,其它位补零
- *最后加上64位的原来长度
- */
- private int[] add(String str){
- int num=((str.length()+8)/64)+1;//以512位，64个字节为一组
- int strByte[]=new int[num*16];//64/4=16，所以有16个整数
- for(int i=0;i>2]|=str.charAt(i)<<((i%4)*8);//一个整数存储四个字节，小端序
- }
- strByte[i>>2]|=0x80<<((i%4)*8);//尾部添加1
- /*
- *添加原长度，长度指位的长度，所以要乘8，然后是小端序，所以放在倒数第二个,这里长度只用了32位
- */
- strByte[num*16-2]=str.length()*8;
- return strByte;
- }
- /*
- *调用函数
- */
- public String getMD5(String source){
- init();
- int strByte[]=add(source);
- for(int i=0;i>i*8)%(1<<8))&0xff)).replace(' ', '0');
-
- }
- return str;
- }
- /*
- *单例
- */
- private static MD5 instance;
- public static MD5 getInstance(){
- if(instance==null){
- instance=new MD5();
- }
- return instance;
- }
-
- private MD5(){};
-
- public static void main(String[] args){
- String str=MD5.getInstance().getMD5("你若安好，便是晴天");
- System.out.println(str);
- }
-}
-```
-
-### [**SHA1:**](https://baike.baidu.com/item/MD5/212708?fr=aladdin)
-对于长度小于2^64位的消息，SHA1会产生一个160位(40个字符)的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。
-
-SHA1有如下特性：
-
-- 不可以从消息摘要中复原信息；
-- 两个不同的消息不会产生同样的消息摘要,(但会有1x10 ^ 48分之一的机率出现相同的消息摘要,一般使用时忽略)。
-
-#### 代码实现：
-
-**利用JDK提供java.security.MessageDigest类实现SHA1算法：*
-
-```java
-package com.snailclimb.ks.securityAlgorithm;
-
-import java.io.UnsupportedEncodingException;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-
-public class SHA1Demo {
-
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- System.out.println(getSha1("你若安好，便是晴天"));
-
- }
-
- public static String getSha1(String str) {
- if (null == str || 0 == str.length()) {
- return null;
- }
- char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
- try {
- //创建SHA1算法消息摘要对象
- MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
- //使用指定的字节数组更新摘要。
- mdTemp.update(str.getBytes("UTF-8"));
- //生成的哈希值的字节数组
- byte[] md = mdTemp.digest();
- //SHA1算法生成信息摘要关键过程
- int j = md.length;
- char[] buf = new char[j * 2];
- int k = 0;
- for (int i = 0; i < j; i++) {
- byte byte0 = md[i];
- buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
- buf[k++] = hexDigits[byte0 & 0xf];
- }
- return new String(buf);
- } catch (NoSuchAlgorithmException e) {
- e.printStackTrace();
- } catch (UnsupportedEncodingException e) {
- e.printStackTrace();
- }
- return "0";
-
- }
-}
-
-```
-
-**结果：**
-
-```
-8ce764110a42da9b08504b20e26b19c9e3382414
-```
-
-
-
-# 二 加密算法
-
-## **1. 简介：**
-
-- **加密技术包括两个元素：加密算法和密钥。**
-- **加密算法是将普通的文本（或者可以理解的信息）与一串数字（密钥）的结合，产生不可理解的密文的步骤。**
-- **密钥是用来对数据进行编码和解码的一种算法。**
-- **在安全保密中，可通过适当的密钥加密技术和管理机制来保证网络的信息通讯安全。**
-
-## **2. 分类：**
-
-**密钥加密技术的密码体制分为对称密钥体制和非对称密钥体制两种。相应地，对数据加密的技术分为两类，即对称加密（私人密钥加密）和非对称加密（公开密钥加密）。**
-
-**对称加密以数据加密标准（DES，Data Encryption Standard）算法为典型代表，非对称加密通常以RSA（Rivest Shamir Adleman）算法为代表。**
-
-**对称加密的加密密钥和解密密钥相同。非对称加密的加密密钥和解密密钥不同，加密密钥可以公开而解密密钥需要保密**
-## **3. 应用：**
-
-常被用在电子商务或者其他需要保证网络传输安全的范围。
-
-## **4. 对称加密：**
-
-加密密钥和解密密钥相同的加密算法。
-
-对称加密算法使用起来简单快捷，密钥较短，且破译困难，除了数据加密标准（DES），
-另一个对称密钥加密系统是国际数据加密算法（IDEA），它比DES的加密性好，而且对计算机功能要求也没有那么高。IDEA加密标准由PGP（Pretty Good Privacy）系统使用。
-### [**DES:**](https://baike.baidu.com/item/DES)
-
-DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，现在已经过时。
-
-#### 代码实现：
-
-DES算法实现 ：
-
-```java
-package com.snailclimb.ks.securityAlgorithm;
-
-import java.io.UnsupportedEncodingException;
-import java.security.SecureRandom;
-import javax.crypto.spec.DESKeySpec;
-import javax.crypto.SecretKeyFactory;
-import javax.crypto.SecretKey;
-import javax.crypto.Cipher;
-
-/**
- * DES加密介绍 DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，
- * 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，
- * 24小时内即可被破解。虽然如此，在某些简单应用中，我们还是可以使用DES加密算法，本文简单讲解DES的JAVA实现 。
- * 注意：DES加密和解密过程中，密钥长度都必须是8的倍数
- */
-public class DesDemo {
- public DesDemo() {
- }
-
- // 测试
- public static void main(String args[]) {
- // 待加密内容
- String str = "cryptology";
- // 密码，长度要是8的倍数
- String password = "95880288";
-
- byte[] result;
- try {
- result = DesDemo.encrypt(str.getBytes(), password);
- System.out.println("加密后：" + result);
- byte[] decryResult = DesDemo.decrypt(result, password);
- System.out.println("解密后：" + new String(decryResult));
- } catch (UnsupportedEncodingException e2) {
- // TODO Auto-generated catch block
- e2.printStackTrace();
- } catch (Exception e1) {
- e1.printStackTrace();
- }
- }
-
- // 直接将如上内容解密
-
- /**
- * 加密
- *
- * @param datasource
- * byte[]
- * @param password
- * String
- * @return byte[]
- */
- public static byte[] encrypt(byte[] datasource, String password) {
- try {
- SecureRandom random = new SecureRandom();
- DESKeySpec desKey = new DESKeySpec(password.getBytes());
- // 创建一个密匙工厂，然后用它把DESKeySpec转换成
- SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
- SecretKey securekey = keyFactory.generateSecret(desKey);
- // Cipher对象实际完成加密操作
- Cipher cipher = Cipher.getInstance("DES");
- // 用密匙初始化Cipher对象,ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量
- cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
- // 现在，获取数据并加密
- // 正式执行加密操作
- return cipher.doFinal(datasource); // 按单部分操作加密或解密数据，或者结束一个多部分操作
- } catch (Throwable e) {
- e.printStackTrace();
- }
- return null;
- }
-
- /**
- * 解密
- *
- * @param src
- * byte[]
- * @param password
- * String
- * @return byte[]
- * @throws Exception
- */
- public static byte[] decrypt(byte[] src, String password) throws Exception {
- // DES算法要求有一个可信任的随机数源
- SecureRandom random = new SecureRandom();
- // 创建一个DESKeySpec对象
- DESKeySpec desKey = new DESKeySpec(password.getBytes());
- // 创建一个密匙工厂
- SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");// 返回实现指定转换的
- // Cipher
- // 对象
- // 将DESKeySpec对象转换成SecretKey对象
- SecretKey securekey = keyFactory.generateSecret(desKey);
- // Cipher对象实际完成解密操作
- Cipher cipher = Cipher.getInstance("DES");
- // 用密匙初始化Cipher对象
- cipher.init(Cipher.DECRYPT_MODE, securekey, random);
- // 真正开始解密操作
- return cipher.doFinal(src);
- }
-}
-```
-
-结果：
-
-```
-加密后：[B@50cbc42f
-解密后：cryptology
-```
-
-### [**IDEA:**](https://baike.baidu.com/item/%E5%9B%BD%E9%99%85%E6%95%B0%E6%8D%AE%E5%8A%A0%E5%AF%86%E7%AE%97%E6%B3%95/11048972?fr=aladdin)
-
-- **这种算法是在DES算法的基础上发展出来的，类似于三重DES。**
-- **发展IDEA也是因为感到DES具有密钥太短等缺点。**
-- **DEA的密钥为128位，这么长的密钥在今后若干年内应该是安全的。**
-- **在实际项目中用到的很少了解即可。**
-
-#### 代码实现：
-
-IDEA算法实现
-
-```java
-package com.snailclimb.ks.securityAlgorithm;
-
-import java.security.Key;
-import java.security.Security;
-
-import javax.crypto.Cipher;
-import javax.crypto.KeyGenerator;
-import javax.crypto.SecretKey;
-import javax.crypto.spec.SecretKeySpec;
-
-import org.apache.commons.codec.binary.Base64;
-import org.bouncycastle.jce.provider.BouncyCastleProvider;
-
-public class IDEADemo {
- public static void main(String args[]) {
- bcIDEA();
- }
- public static void bcIDEA() {
- String src = "www.xttblog.com security idea";
- try {
- Security.addProvider(new BouncyCastleProvider());
-
- //生成key
- KeyGenerator keyGenerator = KeyGenerator.getInstance("IDEA");
- keyGenerator.init(128);
- SecretKey secretKey = keyGenerator.generateKey();
- byte[] keyBytes = secretKey.getEncoded();
-
- //转换密钥
- Key key = new SecretKeySpec(keyBytes, "IDEA");
-
- //加密
- Cipher cipher = Cipher.getInstance("IDEA/ECB/ISO10126Padding");
- cipher.init(Cipher.ENCRYPT_MODE, key);
- byte[] result = cipher.doFinal(src.getBytes());
- System.out.println("bc idea encrypt : " + Base64.encodeBase64String(result));
-
- //解密
- cipher.init(Cipher.DECRYPT_MODE, key);
- result = cipher.doFinal(result);
- System.out.println("bc idea decrypt : " + new String(result));
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-}
-
-```
-
-## **5. 非对称加密：**
-
-- 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥 （privatekey）。
-- 公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；
-- 如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。
-- 因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
-### [**RAS:**](https://baike.baidu.com/item/DES)
-
-RSA是目前最有影响力和最常用的公钥加密算法。它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。
-
-#### 代码实现：
-
-RAS算法实现：
-
-```java
-package com.snailclimb.ks.securityAlgorithm;
-
-import org.apache.commons.codec.binary.Base64;
-
-import java.security.*;
-import java.security.spec.PKCS8EncodedKeySpec;
-import java.security.spec.X509EncodedKeySpec;
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.crypto.Cipher;
-
-/**
- * Created by humf.需要依赖 commons-codec 包
- */
-public class RSADemo {
-
- public static void main(String[] args) throws Exception {
- Map keyMap = initKey();
- String publicKey = getPublicKey(keyMap);
- String privateKey = getPrivateKey(keyMap);
-
- System.out.println(keyMap);
- System.out.println("-----------------------------------");
- System.out.println(publicKey);
- System.out.println("-----------------------------------");
- System.out.println(privateKey);
- System.out.println("-----------------------------------");
- byte[] encryptByPrivateKey = encryptByPrivateKey("123456".getBytes(), privateKey);
- byte[] encryptByPublicKey = encryptByPublicKey("123456", publicKey);
- System.out.println(encryptByPrivateKey);
- System.out.println("-----------------------------------");
- System.out.println(encryptByPublicKey);
- System.out.println("-----------------------------------");
- String sign = sign(encryptByPrivateKey, privateKey);
- System.out.println(sign);
- System.out.println("-----------------------------------");
- boolean verify = verify(encryptByPrivateKey, publicKey, sign);
- System.out.println(verify);
- System.out.println("-----------------------------------");
- byte[] decryptByPublicKey = decryptByPublicKey(encryptByPrivateKey, publicKey);
- byte[] decryptByPrivateKey = decryptByPrivateKey(encryptByPublicKey, privateKey);
- System.out.println(decryptByPublicKey);
- System.out.println("-----------------------------------");
- System.out.println(decryptByPrivateKey);
-
- }
-
- public static final String KEY_ALGORITHM = "RSA";
- public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
-
- private static final String PUBLIC_KEY = "RSAPublicKey";
- private static final String PRIVATE_KEY = "RSAPrivateKey";
-
- public static byte[] decryptBASE64(String key) {
- return Base64.decodeBase64(key);
- }
-
- public static String encryptBASE64(byte[] bytes) {
- return Base64.encodeBase64String(bytes);
- }
-
- /**
- * 用私钥对信息生成数字签名
- *
- * @param data
- * 加密数据
- * @param privateKey
- * 私钥
- * @return
- * @throws Exception
- */
- public static String sign(byte[] data, String privateKey) throws Exception {
- // 解密由base64编码的私钥
- byte[] keyBytes = decryptBASE64(privateKey);
- // 构造PKCS8EncodedKeySpec对象
- PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
- // KEY_ALGORITHM 指定的加密算法
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- // 取私钥匙对象
- PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
- // 用私钥对信息生成数字签名
- Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
- signature.initSign(priKey);
- signature.update(data);
- return encryptBASE64(signature.sign());
- }
-
- /**
- * 校验数字签名
- *
- * @param data
- * 加密数据
- * @param publicKey
- * 公钥
- * @param sign
- * 数字签名
- * @return 校验成功返回true 失败返回false
- * @throws Exception
- */
- public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
- // 解密由base64编码的公钥
- byte[] keyBytes = decryptBASE64(publicKey);
- // 构造X509EncodedKeySpec对象
- X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
- // KEY_ALGORITHM 指定的加密算法
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- // 取公钥匙对象
- PublicKey pubKey = keyFactory.generatePublic(keySpec);
- Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
- signature.initVerify(pubKey);
- signature.update(data);
- // 验证签名是否正常
- return signature.verify(decryptBASE64(sign));
- }
-
- public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
- // 对密钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得私钥
- PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
- // 对数据解密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.DECRYPT_MODE, privateKey);
- return cipher.doFinal(data);
- }
-
- /**
- * 解密
- * 用私钥解密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] decryptByPrivateKey(String data, String key) throws Exception {
- return decryptByPrivateKey(decryptBASE64(data), key);
- }
-
- /**
- * 解密
- * 用公钥解密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
- // 对密钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得公钥
- X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key publicKey = keyFactory.generatePublic(x509KeySpec);
- // 对数据解密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.DECRYPT_MODE, publicKey);
- return cipher.doFinal(data);
- }
-
- /**
- * 加密
- * 用公钥加密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] encryptByPublicKey(String data, String key) throws Exception {
- // 对公钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得公钥
- X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key publicKey = keyFactory.generatePublic(x509KeySpec);
- // 对数据加密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.ENCRYPT_MODE, publicKey);
- return cipher.doFinal(data.getBytes());
- }
-
- /**
- * 加密
- * 用私钥加密
- *
- * @param data
- * @param key
- * @return
- * @throws Exception
- */
- public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {
- // 对密钥解密
- byte[] keyBytes = decryptBASE64(key);
- // 取得私钥
- PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
- KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
- Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
- // 对数据加密
- Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
- cipher.init(Cipher.ENCRYPT_MODE, privateKey);
- return cipher.doFinal(data);
- }
-
- /**
- * 取得私钥
- *
- * @param keyMap
- * @return
- * @throws Exception
- */
- public static String getPrivateKey(Map keyMap) throws Exception {
- Key key = (Key) keyMap.get(PRIVATE_KEY);
- return encryptBASE64(key.getEncoded());
- }
-
- /**
- * 取得公钥
- *
- * @param keyMap
- * @return
- * @throws Exception
- */
- public static String getPublicKey(Map keyMap) throws Exception {
- Key key = keyMap.get(PUBLIC_KEY);
- return encryptBASE64(key.getEncoded());
- }
-
- /**
- * 初始化密钥
- *
- * @return
- * @throws Exception
- */
- public static Map initKey() throws Exception {
- KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
- keyPairGen.initialize(1024);
- KeyPair keyPair = keyPairGen.generateKeyPair();
- Map keyMap = new HashMap(2);
- keyMap.put(PUBLIC_KEY, keyPair.getPublic());// 公钥
- keyMap.put(PRIVATE_KEY, keyPair.getPrivate());// 私钥
- return keyMap;
- }
-
-}
-```
-
-结果：
-
-```
-{RSAPublicKey=Sun RSA public key, 1024 bits
- modulus: 115328826086047873902606456571034976538836553998745367981848911677968062571831626674499650854318207280419960767020601253071739555161388135589487284843845439403614883967713749605268831336418001722701924537624573180276356615050309809260289965219855862692230362893996010057188170525719351126759886050891484226169
- public exponent: 65537, RSAPrivateKey=sun.security.rsa.RSAPrivateCrtKeyImpl@93479}
------------------------------------
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkO9PBTOFJQTkzznALN62PU7ixd9YFjXrt2dPOGj3wwhymbOU8HLoCztjwpLXHgbpBUJlGmbURV955M1BkZ1kr5dkZYR5x1gO4xOnu8rEipy4AAMcpFttfiarIZrtzL9pKEvEOxABltVN4yzFDr3IjBqY46aHna7YjwhXI0xHieQIDAQAB
------------------------------------
-MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKQ708FM4UlBOTPOcAs3rY9TuLF31gWNeu3Z084aPfDCHKZs5TwcugLO2PCktceBukFQmUaZtRFX3nkzUGRnWSvl2RlhHnHWA7jE6e7ysSKnLgAAxykW21+Jqshmu3Mv2koS8Q7EAGW1U3jLMUOvciMGpjjpoedrtiPCFcjTEeJ5AgMBAAECgYAK4sxOa8IjEOexv2U92Rrv/SSo3sCY7Z/QVDft2V9xrewoO9+V9HF/7iYDDWffKYInAiimvVl7JM/iSLxza0ZFv29VMpyDcr4TigYmWwBlk7ZbxSTkqLdNwxxldMmEoTn1py53MUm+1V1K3rzNvJjuZaZFAevU7vUnwQwD+JGQYQJBAM9HBaC+dF3PJ2mkXekHpDS1ZPaSFdrdzd/GvHFi/cJAMM+Uz6PmpkosNXRtOpSYWwlOMRamLZtrHhfQoqSk3S8CQQDK1qL1jGvVdqw5OjqxktR7MmOsWUVZdWiBN+6ojxBgA0yVn0n7vkdAAgEZBj89WG0VHPEu3hd4AgXFZHDfXeDXAkBvSn7nE9t/Et7ihfI2UHgGJO8UxNMfNMB5Skebyb7eMYEDs67ZHdpjMOFypcMyTatzj5wjwQ3zyMvblZX+ONbZAkAX4ysRy9WvL+icXLUo0Gfhkk+WrnSyUldaUGH0y9Rb2kecn0OxN/lgGlxSvB+ac910zRHCOTl+Uo6nbmq0g3PFAkAyqA4eT7G9GXfncakgW1Kdkn72w/ODpozgfhTLNX0SGw1ITML3c4THTtH5h3zLi3AF9zJO2O+K6ajRbV0szHHI
------------------------------------
-[B@387c703b
------------------------------------
-[B@224aed64
------------------------------------
-la4Hc4n/UbeBu0z9iLRuwKVv014SiOJMXkO5qdJvKBsw0MlnsrM+89a3p73yMrb1dAnCU/2kgO0PtFpvmG8pzxTe1u/5nX/25iIyUXALlwVRptJyjzFE83g2IX0XEv/Dxqr1RCRcrMHOLQM0oBoxZCaChmyw1Ub4wsSs6Ndxb9M=
------------------------------------
-true
------------------------------------
-[B@c39f790
------------------------------------
-[B@71e7a66b
-
-```
-
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225.md"
deleted file mode 100644
index ec53e7002f9..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225.md"
+++ /dev/null
@@ -1,90 +0,0 @@
-
-## LeetCode
-[LeetCode（中国）官网](https://leetcode-cn.com/)
-
-[如何高效地使用 LeetCode](https://leetcode-cn.com/articles/%E5%A6%82%E4%BD%95%E9%AB%98%E6%95%88%E5%9C%B0%E4%BD%BF%E7%94%A8-leetcode/)
-
-
-## 牛客网：
-
-[牛客网首页](https://www.nowcoder.com)
-
-
-> ### **[剑指offer编程题](https://www.nowcoder.com/ta/coding-interviews)**
-
-**分类解析：**
-- [（1）斐波那契数列问题和跳台阶问题](https://github.com/Snailclimb/Java-Guide/tree/master/数据结构与算法/算法题解析/剑指offer/（1）斐波那契数列问题和跳台阶问题.md)
-- [（2）二维数组查找和替换空格问题](https://github.com/Snailclimb/Java-Guide/tree/master/数据结构与算法/算法题解析/剑指offer/（2）二维数组查找和替换空格问题.md)
-- [（3）数值的整数次方和调整数组元素顺序](https://github.com/Snailclimb/Java-Guide/tree/master/数据结构与算法/算法题解析/剑指offer/（3）数值的整数次方和调整数组元素顺序.md)
-- [（4）链表相关编程题](https://github.com/Snailclimb/Java-Guide/tree/master/数据结构与算法/算法题解析/剑指offer/（4）链表相关编程题.md)
-- [（5）栈变队列和栈的压入、弹出序列](https://github.com/Snailclimb/Java-Guide/tree/master/数据结构与算法/算法题解析/剑指offer/（5）栈变队列和栈的压入、弹出序列.md)
-
-> ### [2017校招真题](https://www.nowcoder.com/ta/2017test)
-
-> ### [华为机试题](https://www.nowcoder.com/ta/huawei)
-
-
-## 公司真题
-
-> [ 网易2018校园招聘编程题真题集合](https://www.nowcoder.com/test/6910869/summary)
-
-**解析：**
-- [ 网易2018校招编程题1-3](https://github.com/Snailclimb/Java-Guide/tree/master/数据结构与算法/算法题解析/公司真题/网易2018校招编程题1-3.md)
-
-> [ 网易2018校招内推编程题集合](https://www.nowcoder.com/test/6291726/summary)
-
-> [2017年校招全国统一模拟笔试(第五场)编程题集合](https://www.nowcoder.com/test/5986669/summary)
-
- > [2017年校招全国统一模拟笔试(第四场)编程题集合](https://www.nowcoder.com/test/5507925/summary)
-
-> [2017年校招全国统一模拟笔试(第三场)编程题集合](https://www.nowcoder.com/test/5217106/summary)
-
-> [2017年校招全国统一模拟笔试(第二场)编程题集合](https://www.nowcoder.com/test/4546329/summary)
-
-> [ 2017年校招全国统一模拟笔试(第一场)编程题集合](https://www.nowcoder.com/test/4236887/summary)
-
-
-> [百度2017春招笔试真题编程题集合](https://www.nowcoder.com/test/4998655/summary)
-
-> [网易2017春招笔试真题编程题集合](https://www.nowcoder.com/test/4575457/summary)
-
- > [网易2017秋招编程题集合](https://www.nowcoder.com/test/2811407/summary)
-
- > [网易有道2017内推编程题](https://www.nowcoder.com/test/2385858/summary)
-
- > [ 滴滴出行2017秋招笔试真题-编程题汇总](https://www.nowcoder.com/test/3701760/summary)
-
-> [腾讯2017暑期实习生编程题](https://www.nowcoder.com/test/1725829/summary)
-
- > [今日头条2017客户端工程师实习生笔试题](https://www.nowcoder.com/test/1649301/summary)
-
- > [今日头条2017后端工程师实习生笔试题](https://www.nowcoder.com/test/1649268/summary)
-
-
-
-## 排序算法：
-[图解排序算法(一)之3种简单排序(选择，冒泡，直接插入)](http://www.cnblogs.com/chengxiao/p/6103002.html)
-
-[图解排序算法(二)之希尔排序](https://www.cnblogs.com/chengxiao/p/6104371.html)
-
-[图解排序算法(三)之堆排序](http://www.cnblogs.com/chengxiao/p/6129630.html)
-
-[图解排序算法(四)之归并排序](http://www.cnblogs.com/chengxiao/p/6194356.html)
-
-[图解排序算法(五)之快速排序——三数取中法](http://www.cnblogs.com/chengxiao/p/6262208.html)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2101\357\274\211\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227\351\227\256\351\242\230\345\222\214\350\267\263\345\217\260\351\230\266\351\227\256\351\242\230.md" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2101\357\274\211\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227\351\227\256\351\242\230\345\222\214\350\267\263\345\217\260\351\230\266\351\227\256\351\242\230.md"
deleted file mode 100644
index 87a51d9083e..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2101\357\274\211\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227\351\227\256\351\242\230\345\222\214\350\267\263\345\217\260\351\230\266\351\227\256\351\242\230.md"
+++ /dev/null
@@ -1,127 +0,0 @@
-### 一 斐波那契数列
-#### **题目描述：**
-大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
-n<=39
-
-#### **问题分析：**
-可以肯定的是这一题通过递归的方式是肯定能做出来，但是这样会有一个很大的问题，那就是递归大量的重复计算会导致内存溢出。另外可以使用迭代法，用fn1和fn2保存计算过程中的结果，并复用起来。下面我会把两个方法示例代码都给出来并给出两个方法的运行时间对比。
-
-#### **示例代码：**
-**采用迭代法：**
-
-```java
-
- int Fibonacci(int number) {
- if (number <= 0) {
- return 0;
- }
- if (number == 1 || number == 2) {
- return 1;
- }
- int first = 1, second = 1, third = 0;
- for (int i = 3; i <= number; i++) {
- third = first + second;
- first = second;
- second = third;
- }
- return third;
- }
-```
-**采用递归：**
-```java
- public int Fibonacci(int n) {
-
- if (n <= 0) {
- return 0;
- }
- if (n == 1||n==2) {
- return 1;
- }
-
- return Fibonacci(n - 2) + Fibonacci(n - 1);
-
- }
-```
-
-#### **运行时间对比：**
-假设n为40我们分别使用迭代法和递归法计算，计算结果如下：
-1. 迭代法
-
-2. 递归法
- 
-
-
-### 二 跳台阶问题
-#### **题目描述：**
-一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
-#### **问题分析：**
-**正常分析法：**
-a.如果两种跳法，1阶或者2阶，那么假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1);
-b.假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)
-c.由a，b假设可以得出总跳法为: f(n) = f(n-1) + f(n-2)
-d.然后通过实际的情况可以得出：只有一阶的时候 f(1) = 1 ,只有两阶的时候可以有 f(2) = 2
-**找规律分析法：**
-f(1) = 1, f(2) = 2, f(3) = 3, f(4) = 5， 可以总结出f(n) = f(n-1) + f(n-2)的规律。
-但是为什么会出现这样的规律呢？假设现在6个台阶，我们可以从第5跳一步到6，这样的话有多少种方案跳到5就有多少种方案跳到6，另外我们也可以从4跳两步跳到6，跳到4有多少种方案的话，就有多少种方案跳到6，其他的不能从3跳到6什么的啦，所以最后就是f(6) = f(5) + f(4)；这样子也很好理解变态跳台阶的问题了。
-
-**所以这道题其实就是斐波那契数列的问题。**
-代码只需要在上一题的代码稍做修改即可。和上一题唯一不同的就是这一题的初始元素变为 1 2 3 5 8.....而上一题为1 1 2 3 5 .......。另外这一题也可以用递归做，但是递归效率太低，所以我这里只给出了迭代方式的代码。
-#### **示例代码：**
-```java
-
- int jumpFloor(int number) {
- if (number <= 0) {
- return 0;
- }
- if (number == 1) {
- return 1;
- }
- if (number == 2) {
- return 2;
- }
- int first = 1, second = 2, third = 0;
- for (int i = 3; i <= number; i++) {
- third = first + second;
- first = second;
- second = third;
- }
- return third;
- }
-```
-
-
-### 三 变态跳台阶问题
-#### **题目描述：**
-一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
-
-#### **问题分析：**
-假设n>=2，第一步有n种跳法：跳1级、跳2级、到跳n级
-跳1级，剩下n-1级，则剩下跳法是f(n-1)
-跳2级，剩下n-2级，则剩下跳法是f(n-2)
-......
-跳n-1级，剩下1级，则剩下跳法是f(1)
-跳n级，剩下0级，则剩下跳法是f(0)
-所以在n>=2的情况下：
-f(n)=f(n-1)+f(n-2)+...+f(1)
-因为f(n-1)=f(n-2)+f(n-3)+...+f(1)
-所以f(n)=2*f(n-1) 又f(1)=1,所以可得**f(n)=2^(number-1)**
-
-#### **示例代码：**
-
-```java
- int JumpFloorII(int number) {
- return 1 << --number;//2^(number-1)用位移操作进行，更快
- }
-```
-#### **补充：**
-**java中有三种移位运算符：**
-
-1. “<<” : **左移运算符**，等同于乘2的n次方
-2. “>>”: **右移运算符**，等同于除2的n次方
-3. “>>>” **无符号右移运算符**，不管移动前最高位是0还是1，右移后左侧产生的空位部分都以0来填充。与>>类似。
-例：
- int a = 16;
- int b = a << 2;//左移2，等同于16 * 2的2次方，也就是16 * 4
- int c = a >> 2;//右移2，等同于16 / 2的2次方，也就是16 / 4
-
-
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2102\357\274\211\344\272\214\347\273\264\346\225\260\347\273\204\346\237\245\346\211\276\345\222\214\346\233\277\346\215\242\347\251\272\346\240\274\351\227\256\351\242\230.md" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2102\357\274\211\344\272\214\347\273\264\346\225\260\347\273\204\346\237\245\346\211\276\345\222\214\346\233\277\346\215\242\347\251\272\346\240\274\351\227\256\351\242\230.md"
deleted file mode 100644
index 964ed6c9892..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2102\357\274\211\344\272\214\347\273\264\346\225\260\347\273\204\346\237\245\346\211\276\345\222\214\346\233\277\346\215\242\347\251\272\346\240\274\351\227\256\351\242\230.md"
+++ /dev/null
@@ -1,64 +0,0 @@
-### 一 二维数组查找
-#### **题目描述：**
-在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
-#### **问题解析：**
-这一道题还是比较简单的，我们需要考虑的是如何做，效率最快。这里有一种很好理解的思路：
-
-> 矩阵是有序的，从左下角来看，向上数字递减，向右数字递增，
- 因此从左下角开始查找，当要查找数字比左下角数字大时。右移
- 要查找数字比左下角数字小时，上移。这样找的速度最快。
-
-#### **示例代码：**
-```java
- public boolean Find(int target, int [][] array) {
- //基本思路从左下角开始找，这样速度最快
- int row = array.length-1;//行
- int column = 0;//列
- //当行数大于0，当前列数小于总列数时循环条件成立
- while((row >= 0)&& (column< array[0].length)){
- if(array[row][column] > target){
- row--;
- }else if(array[row][column] < target){
- column++;
- }else{
- return true;
- }
- }
- return false;
- }
-```
-### 二 替换空格
-#### **题目描述：**
-请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
-#### **问题分析：**
-这道题不难，我们可以通过循环判断字符串的字符是否为空格，是的话就利用append()方法添加追加“%20”，否则还是追加原字符。
-
-或者最简单的方法就是利用： replaceAll(String regex,String replacement)方法了，一行代码就可以解决。
-
-#### **示例代码：**
-**常规做法：**
-```java
- public String replaceSpace(StringBuffer str) {
- StringBuffer out=new StringBuffer();
- for (int i = 0; i < str.toString().length(); i++) {
- char b=str.charAt(i);
- if(String.valueOf(b).equals(" ")){
- out.append("%20");
- }else{
- out.append(b);
- }
- }
- return out.toString();
- }
-```
-**一行代码解决：**
-```java
- public String replaceSpace(StringBuffer str) {
- //return str.toString().replaceAll(" ", "%20");
- //public String replaceAll(String regex,String replacement)
- //用给定的替换替换与给定的regular expression匹配的此字符串的每个子字符串。
- //\ 转义字符. 如果你要使用 "\" 本身, 则应该使用 "\\". String类型中的空格用“\s”表示，所以我这里猜测"\\s"就是代表空格的意思
- return str.toString().replaceAll("\\s", "%20");
- }
-
-```
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2103\357\274\211\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271\345\222\214\350\260\203\346\225\264\346\225\260\347\273\204\345\205\203\347\264\240\351\241\272\345\272\217.md" "b/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2103\357\274\211\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271\345\222\214\350\260\203\346\225\264\346\225\260\347\273\204\345\205\203\347\264\240\351\241\272\345\272\217.md"
deleted file mode 100644
index 291569c0375..00000000000
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/\347\256\227\346\263\225\351\242\230\350\247\243\346\236\220/\345\211\221\346\214\207offer/\357\274\2103\357\274\211\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271\345\222\214\350\260\203\346\225\264\346\225\260\347\273\204\345\205\203\347\264\240\351\241\272\345\272\217.md"
+++ /dev/null
@@ -1,113 +0,0 @@
-### 一 数值的整数次方
-#### **题目描述：**
-给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
-#### **问题解析：**
-这道题算是比较麻烦和难一点的一个了。我这里采用的是**二分幂**思想，当然也可以采用**快速幂**。
-更具剑指offer书中细节，该题的解题思路如下：
-1.当底数为0且指数<0时，会出现对0求倒数的情况，需进行错误处理，设置一个全局变量；
-2.判断底数是否等于0，由于base为double型，所以不能直接用==判断
-3.优化求幂函数（二分幂）。
-当n为偶数，a^n =（a^n/2）*（a^n/2）；
-当n为奇数，a^n = a^[(n-1)/2] * a^[(n-1)/2] * a。时间复杂度O(logn)
-
-**时间复杂度**：O(logn)
-#### **示例代码：**
-```java
-public class Solution {
- boolean invalidInput=false;
- public double Power(double base, int exponent) {
- //如果底数等于0并且指数小于0
- //由于base为double型，不能直接用==判断
- if(equal(base,0.0)&&exponent<0){
- invalidInput=true;
- return 0.0;
- }
- int absexponent=exponent;
- //如果指数小于0，将指数转正
- if(exponent<0)
- absexponent=-exponent;
- //getPower方法求出base的exponent次方。
- double res=getPower(base,absexponent);
- //如果指数小于0，所得结果为上面求的结果的倒数
- if(exponent<0)
- res=1.0/res;
- return res;
- }
- //比较两个double型变量是否相等的方法
- boolean equal(double num1,double num2){
- if(num1-num2>-0.000001&&num1-num2<0.000001)
- return true;
- else
- return false;
- }
- //求出b的e次方的方法
- double getPower(double b,int e){
- //如果指数为0，返回1
- if(e==0)
- return 1.0;
- //如果指数为1，返回b
- if(e==1)
- return b;
- //e>>1相等于e/2，这里就是求a^n =（a^n/2）*（a^n/2）
- double result=getPower(b,e>>1);
- result*=result;
- //如果指数n为奇数，则要再乘一次底数base
- if((e&1)==1)
- result*=b;
- return result;
- }
-}
-```
-
-当然这一题也可以采用笨方法：累乘。不过这种方法的时间复杂度为O（n），这样没有前一种方法效率高。
-```java
- // 使用累乘
- public double powerAnother(double base, int exponent) {
- double result = 1.0;
- for (int i = 0; i < Math.abs(exponent); i++) {
- result *= base;
- }
- if (exponent >= 0)
- return result;
- else
- return 1 / result;
- }
-```
-### 二 调整数组顺序使奇数位于偶数前面
-#### **题目描述：**
-输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
-
-#### **问题解析：**
-这道题有挺多种解法的，给大家介绍一种我觉得挺好理解的方法：
-我们首先统计奇数的个数假设为n,然后新建一个等长数组，然后通过循环判断原数组中的元素为偶数还是奇数。如果是则从数组下标0的元素开始，把该奇数添加到新数组；如果是偶数则从数组下标为n的元素开始把该偶数添加到新数组中。
-
-#### **示例代码：**
-时间复杂度为O（n），空间复杂度为O（n）的算法
-```java
-public class Solution {
- public void reOrderArray(int [] array) {
- //如果数组长度等于0或者等于1，什么都不做直接返回
- if(array.length==0||array.length==1)
- return;
- //oddCount：保存奇数个数
- //oddBegin：奇数从数组头部开始添加
- int oddCount=0,oddBegin=0;
- //新建一个数组
- int[] newArray=new int[array.length];
- //计算出（数组中的奇数个数）开始添加元素
- for(int i=0;i stack1 = new Stack();
- Stack stack2 = new Stack();
-
- //当执行push操作时，将元素添加到stack1
- public void push(int node) {
- stack1.push(node);
- }
-
- public int pop() {
- //如果两个队列都为空则抛出异常,说明用户没有push进任何元素
- if(stack1.empty()&&stack2.empty()){
- throw new RuntimeException("Queue is empty!");
- }
- //如果stack2不为空直接对stack2执行pop操作，
- if(stack2.empty()){
- while(!stack1.empty()){
- //将stack1的元素按后进先出push进stack2里面
- stack2.push(stack1.pop());
- }
- }
- return stack2.pop();
- }
-}
-```
-
-### 二 栈的压入、弹出序列
-#### **题目描述：**
-输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
-#### **题目分析：**
-这道题想了半天没有思路，参考了Alias的答案，他的思路写的也很详细应该很容易看懂。
-作者：Alias
-https://www.nowcoder.com/questionTerminal/d77d11405cc7470d82554cb392585106
-来源：牛客网
-
-【思路】借用一个辅助的栈，遍历压栈顺序，先讲第一个放入栈中，这里是1，然后判断栈顶元素是不是出栈顺序的第一个元素，这里是4，很显然1≠4，所以我们继续压栈，直到相等以后开始出栈，出栈一个元素，则将出栈顺序向后移动一位，直到不相等，这样循环等压栈顺序遍历完成，如果辅助栈还不为空，说明弹出序列不是该栈的弹出顺序。
-
-举例：
-
-入栈1,2,3,4,5
-
-出栈4,5,3,2,1
-
-首先1入辅助栈，此时栈顶1≠4，继续入栈2
-
-此时栈顶2≠4，继续入栈3
-
-此时栈顶3≠4，继续入栈4
-
-此时栈顶4＝4，出栈4，弹出序列向后一位，此时为5，,辅助栈里面是1,2,3
-
-此时栈顶3≠5，继续入栈5
-
-此时栈顶5=5，出栈5,弹出序列向后一位，此时为3，,辅助栈里面是1,2,3
-
-….
-依次执行，最后辅助栈为空。如果不为空说明弹出序列不是该栈的弹出顺序。
-
-
-
-#### **考察内容：**
-栈
-
-#### **示例代码：**
-```java
-import java.util.ArrayList;
-import java.util.Stack;
-//这道题没想出来，参考了Alias同学的答案：https://www.nowcoder.com/questionTerminal/d77d11405cc7470d82554cb392585106
-public class Solution {
- public boolean IsPopOrder(int [] pushA,int [] popA) {
- if(pushA.length == 0 || popA.length == 0)
- return false;
- Stack s = new Stack();
- //用于标识弹出序列的位置
- int popIndex = 0;
- for(int i = 0; i< pushA.length;i++){
- s.push(pushA[i]);
- //如果栈不为空，且栈顶元素等于弹出序列
- while(!s.empty() &&s.peek() == popA[popIndex]){
- //出栈
- s.pop();
- //弹出序列向后一位
- popIndex++;
- }
- }
- return s.empty();
- }
-}
-```
\ No newline at end of file
diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" "b/\351\235\242\350\257\225\345\277\205\345\244\207/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md"
deleted file mode 100644
index 91c24d1a180..00000000000
--- "a/\351\235\242\350\257\225\345\277\205\345\244\207/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md"
+++ /dev/null
@@ -1,80 +0,0 @@
-
-
-> 俗话说的好：“工欲善其事，必先利其器”。准备一份好的简历对于能不能找到一份好工作起到了至关重要的作用。
-
-
-
-## 六 如何写自己的简历？
-
-一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。
-
-### 6.1 为什么说简历很重要？
-
-假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。
-
-假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。
-
-另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面试。
-
-### 6.2 这3点你必须知道
-
-1. **大部分应届生找工作的硬伤是没有工作经验或实习经历；**
-2. **写在简历上的东西一定要慎重，这可能是面试官大量提问的地方；**
-3. **将自己的项目经历完美的展示出来非常重要。**
-
-### 6.3 两大法则了解一下
-目前写简历的方式有两种普遍被认可，一种是 STAR， 一种是 FAB。
-
-**STAR法则（Situation Task Action Result）：**
-
-- **Situation：** 事情是在什么情况下发生；
-- **Task:：** 你是如何明确你的任务的；
-- **Action：** 针对这样的情况分析，你采用了什么行动方式；
-- **Result：** 结果怎样，在这样的情况下你学习到了什么。
-
-**FAB 法则（Feature Advantage Benefit）：**
-
-- **Feature：** 是什么；
-- **Advantage：** 比别人好在哪些地方；
-- **Benefit：** 如果雇佣你，招聘方会得到什么好处。
-
-### 6.4 项目经历怎么写？
-简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。对于项目经历大家可以考虑从如下几点来写：
-
-1. 对项目整体设计的一个感受
-2. 在这个项目中你负责了什么、做了什么、担任了什么角色
-3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
-4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的。
-
-### 6.5 专业技能该怎么写？
-先问一下你自己会什么，然后看看你意向的公司需要什么。一般HR可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。比如你可以这样写：
-
-- Dubbo：精通
-- Spring：精通
-- Docker：掌握
-- SOA分布式开发 ：掌握
-- Spring Cloud:了解
-
-
-### 6.6 开源程序员简历模板分享
-
-分享一个Github上开源的程序员简历模板。包括PHP程序员简历模板、iOS程序员简历模板、Android程序员简历模板、Web前端程序员简历模板、Java程序员简历模板、C/C++程序员简历模板、NodeJS程序员简历模板、架构师简历模板以及通用程序员简历模板 。
-Github地址：[https://github.com/geekcompany/ResumeSample](https://github.com/geekcompany/ResumeSample)
-
-### 6.7 其他的一些小tips
-
-1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。
-2. 注意排版（不需要花花绿绿的），尽量使用Markdown语法。
-3. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。
-4. 如果自己的Github比较活跃的话，写上去也会为你加分很多。
-5. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容
-6. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。
-7. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。
-8. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。
-
-
-本文摘自我的Gitchat:[《从应届程序员角度分析如何备战大厂面试》](https://gitbook.cn/gitchat/activity/5b457a5df64d4d62e64a449a)。
-
-
-
-
+
+
+ 
+ 
+ 
+ 
+
+
+
+
+实例.jpg,_ANDesc=img,)
+
+
+
+.jpg,_ANDesc=img,)
+