From 7848d43ed5abba053ddef37db3b5d8a0985a2e1d Mon Sep 17 00:00:00 2001
From: sjsdfg <736777445@qq.com>
Date: Sat, 5 Jan 2019 15:58:28 +0800
Subject: [PATCH] =?UTF-8?q?47.=20=E4=BC=98=E5=85=88=E4=BD=BF=E7=94=A8=20Co?=
 =?UTF-8?q?llection=20=E8=80=8C=E4=B8=8D=E6=98=AF=20Stream=20=E6=9D=A5?=
 =?UTF-8?q?=E4=BD=9C=E4=B8=BA=E6=96=B9=E6=B3=95=E7=9A=84=E8=BF=94=E5=9B=9E?=
 =?UTF-8?q?=E7=B1=BB=E5=9E=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...¨Collection而ä¸�是Streamæ�¥ä½œä¸ºæ–¹æ³•çš„返回类型.md | 153 ++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 47. 优先使用Collection而�是Stream�作为方法的返回类型.md

diff --git a/47. 优先使用Collection而�是Stream�作为方法的返回类型.md b/47. 优先使用Collection而�是Stream�作为方法的返回类型.md
new file mode 100644
index 0000000..63ad675
--- /dev/null
+++ b/47. 优先使用Collection而�是Stream�作为方法的返回类型.md	
@@ -0,0 +1,153 @@
+# 47. 优先使用 Collection 而�是 Stream �作为方法的返回类型
+
+　　许多方法返回元素�列（sequence）。在 Java 8 之�，通常方法的返回类型是 `Collection`，`Set` 和 `List` 这些接�；还包括 `Iterable` 和数组类型。通常，很容易决定返回哪一�类型。规范（norm）是集�接�。如果该方法仅用于�用 for-each 循环，或者返回的�列�能实现�些 `Collection` 方法 (通常是 `contains(Object)`)，则使用迭代（`Iterable`）接�。如果返回的元素是基本类型或有严格的性能�求，则使用数组。在 Java 8 中，将�（Stream）添加到平�中，这使得为�列返回方法选择适当的返回类型的任务�得�常��。
+
+　　你�能�说过，�现在是返回元素�列的明显的选择，但是正如�目 45 所讨论的，��会使迭代过时：编写好的代�需�明智地结��和迭代。如果一个 API �返回一个�，并且一些用户想用 for-each 循环�历返回的�列，那么这些用户肯定会感到�安。这尤其令人沮丧，因为 `Stream` 接�在 `Iterable` 接�中包�唯一的抽象方法，`Stream` 的方法规范与 `Iterable` 兼容。阻止程�员使用 for-each 循环在�上迭代的唯一原因是 `Stream` 无法继承 `Iterable`。
+
+　　�憾的是，这个问题没有好的解决方法。 �一看，似乎�以将方法引用传递给 `Stream` 的 iterator 方法。 结果代��能有点嘈�和��明，但并����：
+
+```Java
+// Won't compile, due to limitations on Java's type inference
+for (ProcessHandle ph : ProcessHandle.allProcesses()::iterator) {
+    // Process the process
+}
+```
+
+　　�幸的是，如果你试图编译这段代�，会得到一个错误信�:
+
+```Java
+Test.java:6: error: method reference not expected here
+for (ProcessHandle ph : ProcessHandle.allProcesses()::iterator) {
+```
+
+　　为了使代�编译，必须将方法引用强制转�为适当�数化的 `Iterable` 类型：
+
+```Java`此处输入代�`
+// Hideous workaround to iterate over a stream
+for  (ProcessHandle ph : (Iterable<ProcessHandle>)ProcessHandle.allProcesses()::iterator)
+```
+
+　　此代�有效，但在实践中使用它太嘈�和��明。 更好的解决方法是使用适�器方法。 JDK 没有�供这样的方法，但是使用上�的代�片段中使用的相�技术，很容易编写一个方法。 请注�，在适�器方法中�需�强制转�，因为 Java 的类型推断在此上下文中能够正常工作：
+
+```Java
+// Adapter from  Stream<E> to Iterable<E>
+public static <E> Iterable<E> iterableOf(Stream<E> stream) {
+    return stream::iterator;
+}
+```
+
+　　使用此适�器，�以使用 for-each 语�迭代任何�：
+
+```Java
+for (ProcessHandle p : iterableOf(ProcessHandle.allProcesses())) {
+    // Process the process
+}
+```
+
+　　注�，�目 34 中的 `Anagrams` 程�的�版本使用 `Files.lines` 方法读�字典，而迭代版本使用了 scanner。`Files.lines` 方法优于 scanner，scanner 在读�文件时无声地�噬所有异常。�想情况下，我们也会在迭代版本中使用 `Files.lines`。如果 API ��供对�列的�访问，而程�员希望使用 for-each 语��历�列，那么他们就��出这�妥�。
+
+　　相�，如果一个程�员想�使用�管��处�一个�列，那么一个��供 `Iterable` 的 API 会让他感到�安。JDK �样没有�供适�器，但是编写这个适�器�常简�:
+
+```Java
+// Adapter from Iterable<E> to Stream<E>
+public static <E> Stream<E> streamOf(Iterable<E> iterable) {
+    return StreamSupport.stream(iterable.spliterator(), false);
+}
+```
+
+　　如果你正在编写一个返回对象�列的方法，并且它�会在�管�中使用，那么当然�以自由地返回�。类似地，返回仅用于迭代的�列的方法应该返回一个 `Iterable`。但是如果你写一个公共 API，它返回一个�列，你应该为用户�供哪些想写�管�，哪些想写 for-each 语�，除�你有充分的�由相信大多数用户想�使用相�的机制。
+
+　　`Collection` 接�是 `Iterable` 的�类型，并且具有 `stream` 方法，因此它�供迭代和�访问。 因此，**`Collection` 或适当的�类型通常是公共�列返回方法的最佳返回类型。** 数组还使用 `Arrays.asList` 和 `Stream.of` 方法�供简�的迭代和�访问。 如果返回的�列�到足以容易地放入内存中，那么最好返回一个标准集�实现，例如 `ArrayList` 或 `HashSet`。 **但是��在内存中存储大的�列，�是为了将它作为集�返回。**
+
+　　如果返回的�列很大但�以简�地表示，请考虑实现一个专用集�。 例如，�设返回给定集�的幂集（power set：就是原集�中所有的�集（包括全集和空集）构�的集�），该集包�其所有�集。 {a，b，c} 的幂集为 {{}，{a}，{b}，{c}，{a，b}，{a，c}，{b，c}，{a，b, c}}。 如果一个集�具有 n 个元素，则幂集具有 2n 个。 因此，你甚至�应考虑将幂集存储在标准集�实现中。 但是，在 `AbstractList` 的帮助下，很容易为此实现自定义集�。
+
+　　诀�是使用幂集中�个元素的索引作为���（bit vector），其中索引中的第 n �指示�集�中是�存在第 n 个元素。 本质上，从 0 到 2n-1 的二进制数和 n 个元素集和的幂集之间存在自然映射。 这是代�：
+
+```Java
+// Returns the power set of an input set as custom collection
+public class PowerSet {
+   public static final <E> Collection<Set<E>> of(Set<E> s) {
+      List<E> src = new ArrayList<>(s);
+
+      if (src.size() > 30)
+         throw new IllegalArgumentException("Set too big " + s);
+
+      return new AbstractList<Set<E>>() {
+         @Override 
+         public int size() {
+            return 1 << src.size(); // 2 to the power srcSize
+         }
+
+         @Override
+         public boolean contains(Object o) {
+            return o instanceof Set && src.containsAll((Set)o);
+         }
+
+         @Override 
+         public Set<E> get(int index) {
+            Set<E> result = new HashSet<>();
+            for (int i = 0; index != 0; i++, index >>= 1)
+               if ((index & 1) == 1)
+                  result.add(src.get(i));
+            return result;
+         }
+      };
+   }
+}
+```
+
+　　请注�，如果输入集�超过 30 个元素，则 `PowerSet.of` 方法会引�异常。 这�出了使用 `Collection` 作为返回类型而�是 `Stream` 或 `Iterable` 的缺点：`Collection` 有 int 返回类型的 size 的方法，该方法将返回�列的长度�制为 `Integer.MAX_VALUE` 或 2<sup>31</sup>-1。`Collection` 规范�许 size 方法返回 2<sup>31</sup> - 1，如果集�更大，甚至无�，但这�是一个完全令人满�的解决方案。
+
+　　为了在 `AbstractCollection` 上编写 `Collection` 实现，除了 `Iterable` 所需的方法之外，�需�实现两�方法：`contains` 和 `size`。 通常，编写这些方法的有效实现很容易。 如果��行，�能是因为在迭代�生之�未预先确定�列的内容，返回 `Stream` 还是 `Iterable` 的，无论哪�感觉更自然。 如果选择，�以使用两���的方法分别返回。
+
+　　有时，你会仅根�实现的易用性选择返回类型。例如，�设希望编写一个方法，该方法返回输入列表的所有 (连续的) �列表。生�这些�列表并将它们放到标准集�中�需�三行代�，但是�存这个集�所需的内存是�列表大�的二次方。虽然这没有指数幂集那么糟糕，但显然是��接�的。实现自定义集� (就�我们对幂集所�的那样) 会很�味，因为 JDK 缺少一个框架 `Iterator` 实现�帮助我们。
+
+　　然而，实现输入列表的所有�列表的�是直截了当的，尽管它确实需�一点的洞察力（insight）。 让我们调用一个�列表，该�列表包�列表的第一个元素和列表的�缀。 例如，（a，b，c）的�缀是（a），（a，b）和（a，b，c）。 类似地，让我们调用包��缀的最�一个元素的�列表，因此（a，b，c）的�缀是（a，b，c），（b，c）和（c）。 洞察力是列表的�列表�是�缀的�缀（或相�的�缀的�缀）和空列表。 这一观察直接展现了一个清晰，��简�的实现：
+
+```Java
+// Returns a stream of all the sublists of its input list
+public class SubLists {
+
+   public static <E> Stream<List<E>> of(List<E> list) {
+      return Stream.concat(Stream.of(Collections.emptyList()),
+         prefixes(list).flatMap(SubLists::suffixes));
+   }
+
+   private static <E> Stream<List<E>> prefixes(List<E> list) {
+      return IntStream.rangeClosed(1, list.size())
+         .mapToObj(end -> list.subList(0, end));
+   }
+
+   private static <E> Stream<List<E>> suffixes(List<E> list) {
+      return IntStream.range(0, list.size())
+         .mapToObj(start -> list.subList(start, list.size()));
+   }
+}
+```
+
+　　请注�，`Stream.concat` 方法用于将空列表添加到返回的�中。 还有，`flatMap` 方法（�目 45）用于生�由所有�缀的所有�缀组�的�个�。 最�，通过映射 `IntStream.range` 和 `IntStream.rangeClosed` 返回的连续 int 值��生��缀和�缀。这个习惯用法，粗略地说，�等价于整数索引上的标准 for 循环。因此，我们的�列表实现似于明显的嵌套 for 循环:
+
+```Java
+for (int start = 0; start < src.size(); start++)
+    for (int end = start + 1; end <= src.size(); end++)
+        System.out.println(src.subList(start, end));
+```
+
+　　�以将这个 for 循环直接转�为�。结果比我们以�的实现更简�，但�能�读性�差。它类似于�目 45 中的笛�尔积的使用�的代�:
+
+```Java
+// Returns a stream of all the sublists of its input list
+public static <E> Stream<List<E>> of(List<E> list) {
+   return IntStream.range(0, list.size())
+      .mapToObj(start ->
+         IntStream.rangeClosed(start + 1, list.size())
+            .mapToObj(end -> list.subList(start, end)))
+      .flatMap(x -> x);
+}
+```
+　　与之�的 for 循环一样，此代��会包�空列表。 为了解决这个问题，�以使用 `concat` 方法，就�我们在之�版本中所�的那样，或者在 `rangeClosed` 调用中用 `(int) Math.signum(start)` 替� 1。
+
+　　这两��列表的�实现都�以，但都需�一些用户使用�-迭代适�器 ( Stream-to-Iterable adapte)，或者在更自然的地方使用�。�-迭代适�器�仅打乱了客户端代�，而且在我的机器上使循环速度�低了 2.3 �。一个专门构建的 Collection 实现 (此处未显示) �冗长，但�行速度大约是我的机器上基于�的实现的 1.4 �。
+
+　　总之，在编写返回元素�列的方法时，请记�，�些用户�能希望将它们作为�处�，而其他用户�能希望迭代方��处�它们。 尽�适应两个群体。 如果返回集�是�行的，请执行此�作。 如果已�拥有集�中的元素，或者�列中的元素数�足够�，�以创建一个新的元素，那么返回一个标准集�，比如 `ArrayList`。 �则，请考虑实现自定义集�，就�我们为幂集程�里所�的那样。 如果返回集�是��行的，则返回�或�迭代的，无论哪个看起�更自然。 如果在将�的 Java 版本中，`Stream` 接�声明被修改为继承 `Iterable`，那么应该��返回�，因为它们将�许�和迭代处�。
+