Merge pull request #14 from my-learn/gh-pages-1.0

Gh pages 1.0

Author: maskleo

README.md

@@ -26,6 +26,11 @@
     * [2.5 数组](hc02/05_Arrays.md#数组)
     * [2.6 通配符与类型参数](ch02/06_Wildcards_Versus_Type_Parameters.md#通配符与类型参数)
     * [2.7 通配符捕获](ch02/07_Wildcard_Capture.md#通配符捕获)
+    * [2.8 对通配符的限制](ch02/08_Restrictions_on_Wildcards.md)
+  * [第三章(集合类)](ch03/00_Comparison_and_Bounds.md)
+    * [3.1 可比较的](ch03/01_Comparable.md)
+    * [3.2 集合的最大值](ch03/02_Maximum_of_a_Collection.md)
+
 
 ## PR
 提交 PR 前请先确认排版,示例: [中文文案排版](https://github.com/maskleo-doc/chinese-copywriting-guidelines)

ch01/00_Introduction.md

@@ -3,26 +3,21 @@
 
 ## 第一章(简介)
 
-`Java` 最新版本中现在对泛型和集合与许多其他新功能有良好的支持，包括装箱和拆箱，新的循环形式，以及接受可变数量参数的函数。我们从一个例子开始说明了这
-些。 我们将会看到，将它们相结合是协同的：整数求和。
+`Java` 最新版本中现在对泛型和集合与许多其他新功能有良好的支持，包括装箱和拆箱，新的循环形式，以及接受可变数量参数的函数。我们从一个例子开始说明了这些。 我们将会看到，将它们相结合是协同的：整数求和。
 
-因此作为我们的座右铭，让我们做一些简单求和：把三个数字一个列表并将它们加在一起。 下面是如何在 `Java` 中使用泛型：   
+因此作为我们的座右铭，让我们做一些简单求和：把三个数字一个列表并将它们加在一起。 下面是如何在 `Java` 中使用泛型：
 
 ```java
    List<Integer> ints = Arrays.asList(1,2,3);
    int s = 0;
    for (int n : ints) {
-     s += n; 
+     s += n;
    }
    assert s == 6;
 ```
- 
-不需要太多的解释你就可以读懂代码，但是让我们来看看关键特征。接口列表和类数组是集合框架的一部分（都可以在 `java.util` 包中找到）。类型 `List` 现在是
-通用的；你写 `List<E>` 以指示具有类型 `E` 的元素的列表。这里我们写 `List<Integer>` 指出列表的元素属于 `Integer` 类，即包装类对应于基本类型`int`。
-装箱和拆箱操作，用于转换从原始类型到包装类，自动插入。静态方法 `asList` 可以使用任意数量的参数，将它们放入一个数组中，然后返回一个由数组支持的新列
-表。新的循环形式，`foreach` 被用来绑定一个变量依次到列表的每个元素，循环体将这些添加到总和中。该断言语句（在 `Java1.4` 中引入）用于检查总和是否正
-确。当启用断言时，如果条件不成立，则会引发错误。
- 
+
+不需要太多的解释你就可以读懂代码，但是让我们来看看关键特征。接口列表和类数组是集合框架的一部分（都可以在 `java.util` 包中找到）。类型 `List` 现在是通用的；你写 `List<E>` 以指示具有类型 `E` 的元素的列表。这里我们写 `List<Integer>` 指出列表的元素属于 `Integer` 类，即包装类对应于基本类型`int`。装箱和拆箱操作，用于转换从原始类型到包装类，自动插入。静态方法 `asList` 可以使用任意数量的参数，将它们放入一个数组中，然后返回一个由数组支持的新列表。新的循环形式，`foreach` 被用来绑定一个变量依次到列表的每个元素，循环体将这些添加到总和中。该断言语句（在 `Java1.4` 中引入）用于检查总和是否正确。当启用断言时，如果条件不成立，则会引发错误。
+
 下面是在泛型之前 `Java` 中相同作用的代码：
 
 ```java
@@ -37,24 +32,20 @@
    assert s == 6;
 ```
 
-阅读这段代码并不是那么容易。 没有泛型，就没有办法指出类型声明你打算在列表中存储什么样的元素，所以而不是写 `List<Integer>`，你写 `List`。  现在是
-编辑器而不是编译器谁负责记住列表元素的类型，所以你必须写下从列表中提取元素时将其转换为（整数）。 没有装箱和拆箱，你必须显式地分配属于包装类 
-`Integer` 的每个对象并使用 `intValue` 方法提取相应的基元 `int`。 没有功能接受可变数量的参数，您必须显式地分配一个数组传递给`asList`方法。 没有新的
-循环形式，你必须显式声明一个迭代器，并通过列表推进。
+阅读这段代码并不是那么容易。 没有泛型，就没有办法指出类型声明你打算在列表中存储什么样的元素，所以而不是写 `List<Integer>`，你写 `List`。  现在是编辑器而不是编译器谁负责记住列表元素的类型，所以你必须写下从列表中提取元素时将其转换为（整数）。 没有装箱和拆箱，你必须显式地分配属于包装类 `Integer` 的每个对象并使用 `intValue` 方法提取相应的基元 `int`。 没有功能接受可变数量的参数，您必须显式地分配一个数组传递给`asList`方法。 没有新的循环形式，你必须显式声明一个迭代器，并通过列表推进。
 
 顺便说一句，下面是如何在泛型之前用 `Java` 中的数组做同样的事情：
 
 ```java
    int[] ints = new int[] { 1,2,3 };
    int s = 0;
-   for (int i = 0; i < ints.length; i++) { 
-     s += ints[i]; 
+   for (int i = 0; i < ints.length; i++) {
+     s += ints[i];
    }
    assert s == 6;
 ```
 
-这比使用泛型和集合的相应代码略长，可以说是不太可读，而且肯定不够灵活。 集合让你轻松增大或缩小集合的大小，或在切换到适当的不同的表示形式时，如链表或散
-列表或有序树。`java` 的泛型，装箱和拆箱，`foreach` 循环和 `Java` 中的可变参数标志着第一次使用集合与使用数组一样简单，甚至可能更简单。
+这比使用泛型和集合的相应代码略长，可以说是不太可读，而且肯定不够灵活。 集合让你轻松增大或缩小集合的大小，或在切换到适当的不同的表示形式时，如链表或散列表或有序树。`java` 的泛型，装箱和拆箱，`foreach` 循环和 `Java` 中的可变参数标志着第一次使用集合与使用数组一样简单，甚至可能更简单。
 
 现在我们来看一下这些功能的更多细节。
 

ch01/02_Boxing_and_Unboxing.md

@@ -24,29 +24,29 @@
 式 `e.intValue()`。例如，集合
 
 ```java
-  List<Integer> ints = new ArrayList<Integer>();
-  ints.add(1);
-  int n = ints.get(0);
+   List<Integer> ints = new ArrayList<Integer>();
+   ints.add(1);
+   int n = ints.get(0);
 ```
 
 相当于集合:
 
 ```java
-  List<Integer> ints = new ArrayList<Integer>();
-  ints.add(Integer.valueOf(1));
-  int n = ints.get(0).intValue();
+   List<Integer> ints = new ArrayList<Integer>();
+   ints.add(Integer.valueOf(1));
+   int n = ints.get(0).intValue();
 ```
 
 调用 `Integer.valueOf(1)` 与新的 `Integer(1)` 表达式类似，但是可能会缓存一些值以提高性能，正如我们稍后解释的那样。
 
 在这里，再次，是代码来找到一个整数集合的和，方便打包为一个静态的方法：
 
 ```java
-  public static int sum (List<Integer> ints) {
-  int s = 0;
-  for (int n : ints) { s += n; }
-  return s;
-  }
+   public static int sum (List<Integer> ints) {
+   int s = 0;
+   for (int n : ints) { s += n; }
+     return s;
+   }
 ```
 
 为什么参数的类型是 `List<Integer>` 而不是 `List<int>`？ 因为类型参数必须始终绑定到引用类型，而不是基本类型。 
@@ -58,11 +58,11 @@
 我们可以重写这个方法，用Integer来替换每个 `int` 的出现：
 
 ```java
-  public static Integer sumInteger(List<Integer> ints) {
-    Integer s = 0;
-    for (Integer n : ints) { s += n; }
-    return s;
-  }
+   public static Integer sumInteger(List<Integer> ints) {
+     Integer s = 0;
+     for (Integer n : ints) { s += n; }
+     return s;
+   }
 ```
 
 此代码编译，但执行了很多不必要的工作。 循环的每个迭代将 `s` 和 `n` 中的值拆箱，执行加法操作，然后再次结束结果。使用 `Sun` 当前的编译器，测量结果显示
@@ -72,9 +72,9 @@
 来定义。 所以下面的两个断言使用 `Sun` 的 `JVM` 是成功的： 
 
 ```java
-  List<Integer> bigs = Arrays.asList(100,200,300);
-  assert sumInteger(bigs) == sum(bigs);
-  assert sumInteger(bigs) != sumInteger(bigs); // 不推荐
+   List<Integer> bigs = Arrays.asList(100,200,300);
+   assert sumInteger(bigs) == sum(bigs);
+   assert sumInteger(bigs) != sumInteger(bigs); // 不推荐
 ```
 
 在第一个断言中，拆箱会导致值进行比较，所以结果是相同的。在第二个断言中，没有拆箱，两个方法调用返回不同整数对象，所以即使两个整数对象都表示结果也是不
@@ -85,9 +85,9 @@
 个字节或一个布尔值; 并在装箱时允许进行缓存。因此，与我们之前的例子相比，我们有以下几点：
 
 ```java
-  List<Integer> smalls = Arrays.asList(1,2,3);
-  assert sumInteger(smalls) == sum(smalls);
-  assert sumInteger(smalls) == sumInteger(smalls); // 不推荐
+   List<Integer> smalls = Arrays.asList(1,2,3);
+   assert sumInteger(smalls) == sum(smalls);
+   assert sumInteger(smalls) == sumInteger(smalls); // 不推荐
 ```
 
 这是因为 `6` 小于 `128`，所以装箱数值 `6` 总是返回正确的同一个对象。 一般来说，没有规定两次是否装箱相同的值返回相同或不同的对象，所以前面显示的不等

ch01/03_Foreach.md

@@ -6,19 +6,21 @@
 在这里，我们的代码也是计算整数列表的总和
 
 ```java
-List<Integer> ints = Arrays.asList(1,2,3);
-int s = 0;
-for (int n : ints) { s += n; }
-assert s == 6;
+   List<Integer> ints = Arrays.asList(1,2,3);
+   int s = 0;
+   for (int n : ints) {
+     s += n; 
+   }
+   assert s == 6;
 ```
 
 第三行中的循环被称为 `foreach` 循环，即使它是用关键字。 它相当于以下内容：
 
 ```java
-for (Iterator<Integer> it = ints. iterator(); it.hasNext(); ) {
-  int n = it.next();
-  s += n;
-}
+   for (Iterator<Integer> it = ints. iterator(); it.hasNext(); ) {
+     int n = it.next();
+     s += n;
+   }
 ```
 
 强调的代码对应于用户编写的内容，编码器以系统的方式添加失码代码。 它引入了 `Iterator<Integer>` 类型的变量来迭代 `List<Integer>` 类型的列表整型。 通
@@ -29,54 +31,54 @@ for (Iterator<Integer> it = ints. iterator(); it.hasNext(); ) {
 定义了 `iterator`，`hasNext` 和 `next`，它们被 `foreach` 循环的翻译使用（迭代器也有一个方法 `remove`，它不被翻译使用）：
 
 ```java
-interface Iterable<E> {
-  public Iterator<E> iterator();
-}
-interface Iterator<E> {
-  public boolean hasNext();
-  public E next();
-  public void remove();
-}
+   interface Iterable<E> {
+     public Iterator<E> iterator();
+   }
+   interface Iterator<E> {
+     public boolean hasNext();
+     public E next();
+     public void remove();
+   }
 ```
 
 集合框架中的所有集合，集合和列表都实现了 `Iterable<E>` 接口; 而其他供应商或用户定义的类也可以实现它。`foreach` 循环也可以应用于一个数组：
 
 ```java
-public static int sumArray(int[] a) {
-    int s = 0;
-    for (int n : a) { s += n; }
-      return s;
-    }
+   public static int sumArray(int[] a) {
+     int s = 0;
+     for (int n : a) { s += n; }
+       return s;
+   }
 ```
 
 `foreach` 循环是故意保持简单的，只捕获最常见的情况。如果你想使用 `remove` 方法或者并行迭代多个列表，你需要明确地引入一个迭代器。这是一个从 
 `Double` 列表中删除负值的方法：
 
 ```java
-public static void removeNegative(List<Double> v) {
-    for (Iterator<Double> it = v.iterator(); it.hasNext();) {
-      if (it.next() < 0) it.remove();
-    }
-}
+   public static void removeNegative(List<Double> v) {
+     for (Iterator<Double> it = v.iterator(); it.hasNext();) {
+       if (it.next() < 0) it.remove();
+     }
+   }
 ```
 
 这里是计算两个向量的点积的方法，表示为 `Double` 列表，两个长度都相同。 给定两个向量:
  `u1, … , un` 和 `v1, … , vn` 他们计算： u1 * v1> + … + un * vn:
 
 ```java
-public static double dot(List<Double> u, List<Double> v) {
-    if (u.size() != v.size())
-      throw new IllegalArgumentException("different sizes");
-    double d = 0;
-    Iterator<Double> uIt = u.iterator();
-    Iterator<Double> vIt = v.iterator();
-    while (uIt.hasNext()) {
-      assert uIt.hasNext() && vIt.hasNext();
-      d += uIt.next() * vIt.next();
-    }
-    assert !uIt.hasNext() && !vIt.hasNext();
-    return d;
-}
+   public static double dot(List<Double> u, List<Double> v) {
+     if (u.size() != v.size())
+       throw new IllegalArgumentException("different sizes");
+     double d = 0;
+     Iterator<Double> uIt = u.iterator();
+     Iterator<Double> vIt = v.iterator();
+     while (uIt.hasNext()) {
+       assert uIt.hasNext() && vIt.hasNext();
+       d += uIt.next() * vIt.next();
+     }
+     assert !uIt.hasNext() && !vIt.hasNext();
+     return d;
+   }
 ```
 
 两个迭代器 `uIt` 和 `vIt` 在锁定步骤中跨越列表 `u` 和 `v`。 循环条件只检查第一个迭代器，但断言确认我们可以有使用第二个迭代器，因为我们先前测试了两

ch02/08_Restrictions_on_Wildcards.md

@@ -1,6 +1,8 @@
 《《《 [返回首页](../README.md)       <br/>
 《《《 [上一节](07_Wildcard_Capture.md)
 
+ ### 对通配符的限制
+
  通配符可能不会出现在类实例创建表达式（新建）的顶层，泛型方法调用中的显式类型参数或超类型（扩展和实现）中。
 
  **实例创建**在类实例创建表达式中，如果类型是参数化类型，则没有任何类型参数可能是通配符。 例如，以下是非法的：
@@ -10,8 +12,7 @@
      Map<String, ? extends Number> map = new HashMap<String, ? extends Number>(); // 编译报错
   ```
 
-这通常不是困难。 `Get` 和 `Put` 原则告诉我们，如果一个结构体包含通配符，那么我们只应该从中得到值（如果它是一个扩展通配符）或者只将值放入它中（如果它
-是一个超级通配符）。 为了使结构有用，我们必须同时做到这两点。 因此，我们通常以精确的类型创建结构，即使我们使用通配符类型将值放入或从结构中获取值，如
+这通常不是困难。 `Get` 和 `Put` 原则告诉我们，如果一个结构体包含通配符，那么我们只应该从中得到值（如果它是一个扩展通配符）或者只将值放入它中（如果它是一个超级通配符）。 为了使结构有用，我们必须同时做到这两点。 因此，我们通常以精确的类型创建结构，即使我们使用通配符类型将值放入或从结构中获取值，如
 下例所示：    
 
   ```java
@@ -36,8 +37,7 @@
 即使列表的列表是以通配符类型创建的，其中的每个单独列表都有一个特定的类型：第一个列表是整数列表，第二个列表是字符串列表。 通配符类型禁止我们将内部列表
 中的元素作为 `Object` 以外的任何类型提取，但由于这是 `toString` 使用的类型，因此此代码的类型很好。  
 
-记住限制的一种方式是通配符和普通类型之间的关系类似于接口和类通配符之间的关系，接口更普遍，普通类型和类更具体，实例创建需要更具体的信息。 考虑以下三条
-陈述：  
+记住限制的一种方式是通配符和普通类型之间的关系类似于接口和类通配符之间的关系，接口更普遍，普通类型和类更具体，实例创建需要更具体的信息。 考虑以下三条陈述：  
 
   ```java
      List<?> list = new ArrayList<Object>(); // ok

ch03/00_Comparison_and_Bounds.md

@@ -1,7 +1,7 @@
 《《《 [返回首页](../README.md)       <br/>
 《《《 [上一节](../ch02/08_Restrictions_on_Wildcards.md)
 
-## 比较和界限
+### 比较和界限
 
 现在我们已经掌握了基本知识，让我们看看泛型的一些更高级的用法。本章介绍用于支持元素比较的接口 `Comparable <T>` 和 `Comparator <T>`。 例如，如果要查找
 集合的最大元素或对列表进行排序，这些接口很有用。 一路上，我们将介绍类型变量的界限，这是泛型的一个重要特性，与 `Comparable <T>` 界面结合使用特别有用。

ch03/07_Bridges.md

@@ -1,7 +1,7 @@
 《《《 [返回首页](../README.md)       <br/>
 《《《 [上一节](06_Multiple_Bounds.md)
 
-## 桥梁
+### 桥梁
 
 正如我们前面提到的，泛型是通过擦除来实现的：当你用泛型编写代码时，它的编译方式几乎与没有泛型编写的代码完全相同。在参数化接口（如 `Comparable<T>`）的
 情况下，这可能会导致编译器插入其他方法;这些附加的方法被称为网桥。

ch03/08_Covariant_Overriding.md

@@ -1,7 +1,7 @@
 《《《 [返回首页](../README.md)       <br/>
 《《《 [上一节](07_Bridges.md)
 
-## 协变覆盖
+### 协变覆盖
 
 `Java 5` 支持协变方法重写。 这个特性与泛型没有直接关系，但我们在这里提到它，因为它值得了解，并且因为它使用了上一节中描述的桥接技术来实现。
 

ch04/00_Declarations.md

@@ -1,7 +1,7 @@
 《《《 [返回首页](../README.md)       <br/>
 《《《 [上一节](../ch03/08_Covariant_Overriding.md)
 
-# 声明
+## 声明
 
 本章讨论如何声明一个通用类。 它描述了构造函数，静态成员和嵌套类，它填补了擦除工作的一些细节。
 

ch04/01_Constructors.md

@@ -1,7 +1,7 @@
 《《《 [返回首页](../README.md)       <br/>
 《《《 [上一节](00_Declarations.md)
 
-## 构造函数
+### 构造函数
 
 在泛型类中，类型参数出现在声明类的头中，但不在构造函数中：