From 6e10b5332fad4712afc07e1348c8a950761a1133 Mon Sep 17 00:00:00 2001 From: dashan Date: Mon, 31 Oct 2022 23:01:42 +0800 Subject: [PATCH] up doc --- Untitled.md | 0 java/jdk8/Stream.md | 116 ++++++++++++++-- 设计模式/创建型/单例模式.md | 0 设计模式/创建型/原型模式.md | 0 设计模式/创建型/工厂模式-工厂方法.md | 197 +++++++++++++++++++++++++++ 设计模式/创建型/工厂模式-抽象工厂.md | 2 + 设计模式/创建型/建造者模式.md | 0 设计模式/结构型/享元模式.md | 0 设计模式/结构型/代理模式.md | 0 设计模式/结构型/桥接模式.md | 0 设计模式/结构型/组合模式.md | 0 设计模式/结构型/装饰器模式.md | 0 设计模式/结构型/适配器模式.md | 0 设计模式/结构型/门面模式.md | 0 设计模式/行为型/中介模式.md | 0 设计模式/行为型/命令模式.md | 0 设计模式/行为型/备忘录模式.md | 0 设计模式/行为型/模板模式.md | 0 设计模式/行为型/状态模式.md | 0 设计模式/行为型/策略模式.md | 0 设计模式/行为型/观察者模式.md | 0 设计模式/行为型/解释器模式.md | 0 设计模式/行为型/访问者模式.md | 0 设计模式/行为型/责任链模式.md | 0 设计模式/行为型/迭代器模式.md | 0 25 files changed, 303 insertions(+), 12 deletions(-) create mode 100644 Untitled.md create mode 100644 设计模式/创建型/单例模式.md create mode 100644 设计模式/创建型/原型模式.md create mode 100644 设计模式/创建型/工厂模式-工厂方法.md create mode 100644 设计模式/创建型/工厂模式-抽象工厂.md create mode 100644 设计模式/创建型/建造者模式.md create mode 100644 设计模式/结构型/享元模式.md create mode 100644 设计模式/结构型/代理模式.md create mode 100644 设计模式/结构型/桥接模式.md create mode 100644 设计模式/结构型/组合模式.md create mode 100644 设计模式/结构型/装饰器模式.md create mode 100644 设计模式/结构型/适配器模式.md create mode 100644 设计模式/结构型/门面模式.md create mode 100644 设计模式/行为型/中介模式.md create mode 100644 设计模式/行为型/命令模式.md create mode 100644 设计模式/行为型/备忘录模式.md create mode 100644 设计模式/行为型/模板模式.md create mode 100644 设计模式/行为型/状态模式.md create mode 100644 设计模式/行为型/策略模式.md create mode 100644 设计模式/行为型/观察者模式.md create mode 100644 设计模式/行为型/解释器模式.md create mode 100644 设计模式/行为型/访问者模式.md create mode 100644 设计模式/行为型/责任链模式.md create mode 100644 设计模式/行为型/迭代器模式.md diff --git a/Untitled.md b/Untitled.md new file mode 100644 index 0000000..e69de29 diff --git a/java/jdk8/Stream.md b/java/jdk8/Stream.md index 44f9078..b2607e8 100644 --- a/java/jdk8/Stream.md +++ b/java/jdk8/Stream.md @@ -8,25 +8,117 @@ ### Stream类型 -​ jdk8提供了BaseStream流的基本接口,以及四种实现了BaseStream的Stream接口 +​ **jdk8提供了BaseStream流的基本接口,以及四种实现了BaseStream的Stream接口** -| 接口 | 类型 | -| ------------------------------------------------------------ | ---- | -| interface BaseStream> | | -| interface Stream<T> extends BaseStream | | -| interface DoubleStream extends BaseStream | | -| IntStream extends BaseStream | | -| interface LongStream extends BaseStream | | +| 接口 | 类型 | 概述 | +| ------------------------------------------------------------ | ---- | -------------------------------------------------------- | +| interface BaseStream> | | Stream流顶级接口所有的Stream都是基于BaseStream进行实现的 | +| interface Stream<T> extends BaseStream | 通用 | 支持顺序和并行操作的任意类型的元素流 | +| interface DoubleStream extends BaseStream | 数值 | 支持顺序和并行聚合操作的原始 double 值的元素流 | +| interface IntStream extends BaseStream | 数值 | 支持顺序和并行聚合操作的原始 int 值的元素流 | +| interface LongStream extends BaseStream | 数值 | 支持顺序和并行聚合操作的原始 long 值的元素流 | + +​ **BaseStream 抽象方法介绍** + +| 方法 | 类型 | 概述 | +| -------------------------------- | -------- | ------------------------------------------------------------ | +| Iterator iterator() | 终端操作 | 返回此流的元素的迭代器 | +| Spliterator 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流来做讲解** + +### Stream的创建方式 + +**下面我举例常用Stream流创建的方式，其中加粗的方法是用到最多的几种.** + +| 创建方法 | 方法类型 | 顺序流/并行流 | +| ----------------------------- | -------- | ------------- | +| **Stream.of** | 静态方法 | 顺序流 | +| Stream.generate | 静态方法 | 顺序流 | +| Stream.builder | 静态方法 | 顺序流 | +| Stream.iterate | 静态方法 | 顺序流 | +| **Arrays.stream** | 静态方法 | 顺序流 | +| **Collection.stream** | 成员方法 | 顺序流 | +| **Collection.parallelStream** | 成员方法 | 并行流 | + +> 并行流：内部以多线程并行执行的方式对流进行操作,因为是多线程并行操作所以无法保证集合数据的顺序，除了无法保证顺序以外还会有线程不安全的问题。 + +**案例演示** + +```java +@Test +public void test1(){ + //通过Stream.of静态方法创建顺序流 + Stream stream1 = Stream.of(1, 2, 3); + System.out.print("stream1:"); + stream1.forEach(System.out::print); + + //通过Stream.generate静态方法创建顺序流 + Stream stream2 = Stream.generate((Math::random)).limit(2); + System.out.print("\nstream2:"); + stream2.forEach(System.out::print); + + //通过Stream.builder静态方法创建顺序流 + Stream stream3 = Stream.builder() + .add(4) + .add(5) + .add(6).build(); + System.out.print("\nstream3:"); + stream3.forEach(System.out::print); + + //通过Stream.iterate静态方法创建顺序流 + Stream stream4 = Stream.iterate(0, (x) -> x + 10).limit(5); + System.out.print("\nstream4:"); + stream4.forEach(System.out::print); + //通过Arrays.stream静态方法创建顺序流 + Stream stream5 = Arrays.stream(new Integer[]{7, 8, 9}); + System.out.print("\nstream5:"); + stream5.forEach(System.out::print); -### Stream的创建 + Collection collection = new ArrayList<>(); + collection.add("大山"); + collection.add("大海"); + collection.add("大地"); -### Stream创建 + //Collection.stream方法创建顺序流 + Stream stream6 = collection.stream(); + System.out.print("\nstream6:"); + stream6.forEach(System.out::print); -### Stream方法类型 + //通过Collection.parallelStream创建并行流 + Stream 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 diff --git a/设计模式/创建型/单例模式.md b/设计模式/创建型/单例模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/创建型/原型模式.md b/设计模式/创建型/原型模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/创建型/工厂模式-工厂方法.md b/设计模式/创建型/工厂模式-工厂方法.md new file mode 100644 index 0000000..6b87291 --- /dev/null +++ b/设计模式/创建型/工厂模式-工厂方法.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 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 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 来创建对象就可以了，不需要使用工厂模式。 + +**使用工厂模式最本质的参考标准：** + ++ 封装变化：创建逻辑有可能变化，封装成工厂类之后，创建逻辑的变更对调用者透明。 + ++ 代码复用：创建代码抽离到独立的工厂类之后可以复用。 + +- 隔离复杂性：封装复杂的创建逻辑，调用者无需了解如何创建对象。 + +- 控制复杂度：将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁。课堂讨论 \ No newline at end of file diff --git a/设计模式/创建型/工厂模式-抽象工厂.md b/设计模式/创建型/工厂模式-抽象工厂.md new file mode 100644 index 0000000..8c4b4b9 --- /dev/null +++ b/设计模式/创建型/工厂模式-抽象工厂.md @@ -0,0 +1,2 @@ +### 简述 + diff --git a/设计模式/创建型/建造者模式.md b/设计模式/创建型/建造者模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/享元模式.md b/设计模式/结构型/享元模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/代理模式.md b/设计模式/结构型/代理模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/桥接模式.md b/设计模式/结构型/桥接模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/组合模式.md b/设计模式/结构型/组合模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/装饰器模式.md b/设计模式/结构型/装饰器模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/适配器模式.md b/设计模式/结构型/适配器模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/结构型/门面模式.md b/设计模式/结构型/门面模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/中介模式.md b/设计模式/行为型/中介模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/命令模式.md b/设计模式/行为型/命令模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/备忘录模式.md b/设计模式/行为型/备忘录模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/模板模式.md b/设计模式/行为型/模板模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/状态模式.md b/设计模式/行为型/状态模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/策略模式.md b/设计模式/行为型/策略模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/观察者模式.md b/设计模式/行为型/观察者模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/解释器模式.md b/设计模式/行为型/解释器模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/访问者模式.md b/设计模式/行为型/访问者模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/责任链模式.md b/设计模式/行为型/责任链模式.md new file mode 100644 index 0000000..e69de29 diff --git a/设计模式/行为型/迭代器模式.md b/设计模式/行为型/迭代器模式.md new file mode 100644 index 0000000..e69de29