up doc

java/jdk8/Stream.md

@@ -8,25 +8,117 @@
 
 ### Stream类型
 
-​		jdk8提供了BaseStream流的基本接口,以及四种实现了BaseStream的Stream接口
+​		**jdk8提供了BaseStream流的基本接口,以及四种实现了BaseStream的Stream接口**
 
-| 接口                                                         | 类型 |
-| ------------------------------------------------------------ | ---- |
-| interface BaseStream<T, S extends BaseStream<T, S>>          |      |
-| interface Stream&lt;T&gt; extends BaseStream<T, Stream&lt;T&gt;> |      |
-| interface DoubleStream extends BaseStream<Double, DoubleStream> |      |
-| IntStream extends BaseStream<Integer, IntStream>             |      |
-| interface LongStream extends BaseStream<Long, LongStream>    |      |
+| 接口                                                         | 类型 | 概述                                                     |
+| ------------------------------------------------------------ | ---- | -------------------------------------------------------- |
+| interface BaseStream<T, S extends BaseStream<T, S>>          |      | Stream流顶级接口所有的Stream都是基于BaseStream进行实现的 |
+| interface Stream&lt;T&gt; extends BaseStream<T, Stream&lt;T&gt;> | 通用 | 支持顺序和并行操作的任意类型的元素流                     |
+| interface DoubleStream extends BaseStream<Double, DoubleStream> | 数值 | 支持顺序和并行聚合操作的原始 double 值的元素流           |
+| interface IntStream extends BaseStream<Integer, IntStream>   | 数值 | 支持顺序和并行聚合操作的原始 int 值的元素流              |
+| interface LongStream extends BaseStream<Long, LongStream>    | 数值 | 支持顺序和并行聚合操作的原始 long 值的元素流             |
+
+​		**BaseStream 抽象方法介绍**
+
+| 方法                             | 类型     | 概述                                                         |
+| -------------------------------- | -------- | ------------------------------------------------------------ |
+| Iterator<T> iterator()           | 终端操作 | 返回此流的元素的迭代器                                       |
+| Spliterator<T> spliterator()     | 终端操作 | 返回此流的元素的拆分器                                       |
+| boolean isParallel()             |          | 检测stream是否为并行stream(执行过终端操作方法的流在执行此方法会出现不可预知的问题) |
+| S sequential()                   | 中间操作 | 返回一个顺序流                                               |
+| S parallel()                     | 中间操作 | 返回一个并行流                                               |
+| S unordered()                    | 中间操作 | 返回一个无序流                                               |
+| S onClose(Runnable closeHandler) | 中间操作 | 返回具有附加关闭处理程序的等效流                             |
+| void close()                     |          | 关闭此流，从而调用此流管道的所有关闭处理程序                 |
+
+> 数值类型的Stream流额外提供了sum、average、boxed等方法，sum方法用于求和、average用于求平均值，boxed方法会将数值流转换为通用流；
+>
+> **下面我会以通用Stream<T>流来做讲解**
+
+### Stream的创建方式
+
+**下面我举例常用Stream流创建的方式，其中加粗的方法是用到最多的几种.**
+
+| 创建方法                      | 方法类型 | 顺序流/并行流 |
+| ----------------------------- | -------- | ------------- |
+| **Stream.of**                 | 静态方法 | 顺序流        |
+| Stream.generate               | 静态方法 | 顺序流        |
+| Stream.builder                | 静态方法 | 顺序流        |
+| Stream.iterate                | 静态方法 | 顺序流        |
+| **Arrays.stream**             | 静态方法 | 顺序流        |
+| **Collection.stream**         | 成员方法 | 顺序流        |
+| **Collection.parallelStream** | 成员方法 | 并行流        |
+
+> 并行流：内部以多线程并行执行的方式对流进行操作,因为是多线程并行操作所以无法保证集合数据的顺序，除了无法保证顺序以外还会有线程不安全的问题。
+
+**案例演示**
+
+```java
+@Test
+public void test1(){
+    //通过Stream.of静态方法创建顺序流
+    Stream<Integer> stream1 = Stream.of(1, 2, 3);
+    System.out.print("stream1:");
+    stream1.forEach(System.out::print);
+
+    //通过Stream.generate静态方法创建顺序流
+    Stream<Double> stream2 = Stream.generate((Math::random)).limit(2);
+    System.out.print("\nstream2:");
+    stream2.forEach(System.out::print);
+
+    //通过Stream.builder静态方法创建顺序流
+    Stream<Object> stream3 = Stream.builder()
+        .add(4)
+        .add(5)
+        .add(6).build();
+    System.out.print("\nstream3:");
+    stream3.forEach(System.out::print);
+
+    //通过Stream.iterate静态方法创建顺序流
+    Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 10).limit(5);
+    System.out.print("\nstream4:");
+    stream4.forEach(System.out::print);
 
 
+    //通过Arrays.stream静态方法创建顺序流
+    Stream<Integer> stream5 = Arrays.stream(new Integer[]{7, 8, 9});
+    System.out.print("\nstream5:");
+    stream5.forEach(System.out::print);
 
-### Stream的创建
+    Collection<String> collection = new ArrayList<>();
+    collection.add("大山");
+    collection.add("大海");
+    collection.add("大地");
 
-### Stream创建
+    //Collection.stream方法创建顺序流
+    Stream<String> stream6 = collection.stream();
+    System.out.print("\nstream6:");
+    stream6.forEach(System.out::print);
 
-### Stream方法类型
+    //通过Collection.parallelStream创建并行流
+    Stream<String> stream7 = collection.parallelStream();
+    System.out.print("\nstream7:");
+    stream7.forEach(System.out::print);
+}
+```
 
-### Stream顺序流和并行流
+**输出内容**
+
+```
+stream1:123
+stream2:0.63071892380716040.5348826766523751
+stream3:456
+stream4:010203040
+stream5:789
+stream6:大山大海大地
+stream7:大海大地大山
+```
+
+### Stream方法类型以及方法概述
+
+### Stream方法案例演示
+
+### Stream并行流
 
 ### Collectors
 

设计模式/创建型/工厂模式-工厂方法.md

@@ -0,0 +1,197 @@
+### 简述
+
+工厂模式分为工厂方法和抽象工厂，工厂方法原理比较简单，在实际的项目中也比较常用。而抽象工厂的原理稍微复杂点，在实际的项目中相对也不常用；本章讲解工厂模式的用法和示例。工厂方法又分为简单工厂（Simple Factory）和工厂方法（Factory Method）两种，其中简单工厂还叫作静态工厂方法模式（Static Factory Method Pattern），之所以叫静态工厂方法模式，是因为其中创建对象的方法是静态的。
+
+### 实例①
+
+在下面这段代码中，我们根据配置文件的后缀（json、xml、yaml、properties），选择不同的解析器（JsonRuleConfigParser、XmlRuleConfigParser……），将存储在文件中的配置解析成内存对象 RuleConfig。接下来我们分别用简单工厂和工厂方法来优化这段代码
+
+```java
+public class RuleConfigSource {
+  public RuleConfig load(String ruleConfigFilePath) {
+    String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
+    IRuleConfigParser parser = null;
+    if ("json".equalsIgnoreCase(ruleConfigFileExtension)) {
+      parser = new JsonRuleConfigParser();
+    } else if ("xml".equalsIgnoreCase(ruleConfigFileExtension)) {
+      parser = new XmlRuleConfigParser();
+    } else if ("yaml".equalsIgnoreCase(ruleConfigFileExtension)) {
+      parser = new YamlRuleConfigParser();
+    } else if ("properties".equalsIgnoreCase(ruleConfigFileExtension)) {
+      parser = new PropertiesRuleConfigParser();
+    } else {
+      throw new InvalidRuleConfigException(
+             "Rule config file format is not supported: " + ruleConfigFilePath);
+    }
+
+    String configText = "";
+    //从ruleConfigFilePath文件中读取配置文本到configText中
+    RuleConfig ruleConfig = parser.parse(configText);
+    return ruleConfig;
+  }
+
+  private String getFileExtension(String filePath) {
+    //...解析文件名获取扩展名，比如rule.json，返回json
+    return "json";
+  }
+}
+```
+
+### 简单工厂（Simple Factory）
+
+使用简单工厂对实例①代码进行重构，我们可以将代码中涉及 parser 创建的部分逻辑剥离出来，抽象成 createParser() 函数；为了让类的职责更加单一、代码更加清晰，我们还可以进一步将 createParser() 函数剥离到一个独立的类中，让这个类只负责对象的创建。而这个类就是我们现在要讲的简单工厂模式类。具体的代码如下所示：
+
+#### 方法一：
+
+```java
+
+public class RuleConfigSource {
+  public RuleConfig load(String ruleConfigFilePath) {
+    String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
+    IRuleConfigParser parser = RuleConfigParserFactory.createParser(ruleConfigFileExtension);
+    if (parser == null) {
+      throw new InvalidRuleConfigException(
+              "Rule config file format is not supported: " + ruleConfigFilePath);
+    }
+
+    String configText = "";
+    //从ruleConfigFilePath文件中读取配置文本到configText中
+    RuleConfig ruleConfig = parser.parse(configText);
+    return ruleConfig;
+  }
+
+  private String getFileExtension(String filePath) {
+    //...解析文件名获取扩展名，比如rule.json，返回json
+    return "json";
+  }
+}
+//工厂类
+public class RuleConfigParserFactory {
+  public static IRuleConfigParser createParser(String configFormat) {
+    IRuleConfigParser parser = null;
+    if ("json".equalsIgnoreCase(configFormat)) {
+      parser = new JsonRuleConfigParser();
+    } else if ("xml".equalsIgnoreCase(configFormat)) {
+      parser = new XmlRuleConfigParser();
+    } else if ("yaml".equalsIgnoreCase(configFormat)) {
+      parser = new YamlRuleConfigParser();
+    } else if ("properties".equalsIgnoreCase(configFormat)) {
+      parser = new PropertiesRuleConfigParser();
+    }
+    return parser;
+  }
+}
+```
+
+> 大部分工厂类都是以“Factory”这个单词结尾的，但也不是必须的，比如 Java 中的 DateFormat、Calender。除此之外，工厂类中创建对象的方法一般都是 create 开头，比如代码中的 createParser()，但有的也命名为 getInstance()、createInstance()、newInstance()，有的甚至命名为 valueOf()（比如 Java String 类的 valueOf() 函数）等等，这个我们根据具体的场景和习惯来命名就好。
+
+#### 方法二：
+
+在上面的代码实现中，我们每次调用 RuleConfigParserFactory 的 createParser() 的时候，都要创建一个新的 parser。实际上，如果 parser 可以复用，为了节省内存和对象创建的时间，我们可以将 parser 事先创建好缓存起来。当调用 createParser() 函数的时候，我们从缓存中取出 parser 对象直接使用。这有点类似单例模式和简单工厂模式的结合，具体的代码实现如下所示
+
+```java
+//工厂类
+public class RuleConfigParserFactory {
+  private static final Map<String, RuleConfigParser> cachedParsers = new HashMap<>();
+
+  static {
+    cachedParsers.put("json", new JsonRuleConfigParser());
+    cachedParsers.put("xml", new XmlRuleConfigParser());
+    cachedParsers.put("yaml", new YamlRuleConfigParser());
+    cachedParsers.put("properties", new PropertiesRuleConfigParser());
+  }
+
+  public static IRuleConfigParser createParser(String configFormat) {
+    if (configFormat == null || configFormat.isEmpty()) {
+      return null;//返回null还是IllegalArgumentException全凭你自己说了算
+    }
+    IRuleConfigParser parser = cachedParsers.get(configFormat.toLowerCase());
+    return parser;
+  }
+}
+```
+
+对于上面两种简单工厂模式的实现方法，如果我们要添加新的 parser，那势必要改动到 RuleConfigParserFactory 的代码，那这是不是违反开闭原则呢？实际上，如果不是需要频繁地添加新的 parser，只是偶尔修改一下 RuleConfigParserFactory 代码，稍微不符合开闭原则，也是完全可以接受的。
+
+除此之外，在 RuleConfigParserFactory 的第一种代码实现中，有一组 if 分支判断逻辑，是不是应该用多态或其他设计模式来替代呢？实际上，如果 if 分支并不是很多，代码中有 if 分支也是完全可以接受的。应用多态或设计模式来替代 if 分支判断逻辑，也并不是没有任何缺点的，它虽然提高了代码的扩展性，更加符合开闭原则，但也增加了类的个数，牺牲了代码的可读性。
+
+**总结一下，尽管简单工厂模式的代码实现中，有多处 if 分支判断逻辑，违背开闭原则，但权衡扩展性和可读性，这样的代码实现在大多数情况下（比如，不需要频繁地添加 parser，也没有太多的 parser）是没有问题的。**
+
+### 工厂方法（Factory Method）
+
+对上面的代码进行重构
+
+```java
+
+public class RuleConfigSource {
+  public RuleConfig load(String ruleConfigFilePath) {
+    String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
+
+    IRuleConfigParserFactory parserFactory = RuleConfigParserFactoryMap.getParserFactory(ruleConfigFileExtension);
+    if (parserFactory == null) {
+      throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
+    }
+    IRuleConfigParser parser = parserFactory.createParser();
+
+    String configText = "";
+    //从ruleConfigFilePath文件中读取配置文本到configText中
+    RuleConfig ruleConfig = parser.parse(configText);
+    return ruleConfig;
+  }
+
+  private String getFileExtension(String filePath) {
+    //...解析文件名获取扩展名，比如rule.json，返回json
+    return "json";
+  }
+}
+
+//因为工厂类只包含方法，不包含成员变量，完全可以复用，
+//不需要每次都创建新的工厂类对象，所以，简单工厂模式的第二种实现思路更加合适。
+public class RuleConfigParserFactoryMap { //工厂的工厂
+  private static final Map<String, IRuleConfigParserFactory> cachedFactories = new HashMap<>();
+
+  static {
+    cachedFactories.put("json", new JsonRuleConfigParserFactory());
+    cachedFactories.put("xml", new XmlRuleConfigParserFactory());
+    cachedFactories.put("yaml", new YamlRuleConfigParserFactory());
+    cachedFactories.put("properties", new PropertiesRuleConfigParserFactory());
+  }
+
+  public static IRuleConfigParserFactory getParserFactory(String type) {
+    if (type == null || type.isEmpty()) {
+      return null;
+    }
+    IRuleConfigParserFactory parserFactory = cachedFactories.get(type.toLowerCase());
+    return parserFactory;
+  }
+}
+```
+
+
+
+
+
+### 
+
+我们前面提到，之所以将某个代码块剥离出来，独立为函数或者类，原因是这个代码块的逻辑过于复杂，剥离之后能让代码更加清晰，更加可读、可维护。但是，如果代码块本身并不复杂，就几行代码而已，我们完全没必要将它拆分成单独的函数或者类。基于这个设计思想，当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。而使用简单工厂模式，将所有的创建逻辑都放到一个工厂类中，会导致这个工厂类变得很复杂。除此之外，在某些场景下，如果对象不可复用，那工厂类每次都要返回不同的对象。如果我们使用简单工厂模式来实现，就只能选择第一种包含 if 分支逻辑的实现方式。如果我们还想避免烦人的 if-else 分支逻辑，这个时候，我们就推荐使用工厂方法模式。
+
+
+
+### 总结
+
+**当创建逻辑比较复杂，是一个“大工程”的时候，我们就考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。何为创建逻辑比较复杂呢？我总结了下面两种情况。**
+
++ 第一种情况：类似规则配置解析的例子，代码中存在 if-else 分支判断，动态地根据不同的类型创建不同的对象。针对这种情况，我们就考虑使用工厂模式，将这一大坨 if-else 创建对象的代码抽离出来，放到工厂类中。
++ 还有一种情况，尽管我们不需要根据不同的类型创建不同的对象，但是，单个对象本身的创建过程比较复杂，比如前面提到的要组合其他类对象，做各种初始化操作。在这种情况下，我们也可以考虑使用工厂模式，将对象的创建过程封装到工厂类中。
+
+对于第一种情况，当每个对象的创建逻辑都比较简单的时候，我推荐使用简单工厂模式，将多个对象的创建逻辑放到一个工厂类中。当每个对象的创建逻辑都比较复杂的时候，为了避免设计一个过于庞大的简单工厂类，我推荐使用工厂方法模式，将创建逻辑拆分得更细，每个对象的创建逻辑独立到各自的工厂类中。同理，对于第二种情况，因为单个对象本身的创建逻辑就比较复杂，所以，我建议使用工厂方法模式。除了刚刚提到的这几种情况之外，如果创建对象的逻辑并不复杂，那我们就直接通过 new 来创建对象就可以了，不需要使用工厂模式。
+
+**使用工厂模式最本质的参考标准：**
+
++ 封装变化：创建逻辑有可能变化，封装成工厂类之后，创建逻辑的变更对调用者透明。
+
++ 代码复用：创建代码抽离到独立的工厂类之后可以复用。
+
+- 隔离复杂性：封装复杂的创建逻辑，调用者无需了解如何创建对象。
+
+- 控制复杂度：将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁。课堂讨论

设计模式/创建型/工厂模式-抽象工厂.md

@@ -0,0 +1,2 @@
+### 简述
+