Update 08_Array_Creation_and_Varargs.md

Author: maskleo

Diff for: ch06/08_Array_Creation_and_Varargs.md

@@ -9,93 +9,115 @@
 例 `6-2`。 如何定义 `ArrayList`
 
 ```java
-   import java.util.*;
-    class ArrayList<E> extends AbstractList<E> implements RandomAccess {
-      private E[] arr;
-      private int size = 0;
-      public ArrayList(int cap) {
-        if (cap < 0)
-        throw new IllegalArgumentException("Illegal Capacity: "+cap);
-        arr = (E[])new Object[cap]; // unchecked cast
-      }
-      public ArrayList() { this(10); }
-      public ArrayList(Collection<? extends E> c) { this(c.size()); addAll(c); }
-      public void ensureCapacity(int mincap) {
-        int oldcap = arr.length;
-        if (mincap > oldcap) {
-          int newcap = Math.max(mincap, (oldcap*3)/2+1);
-          E[] oldarr = arr;
-          arr = (E[])new Object[newcap]; // unchecked cast
-          System.arraycopy(oldarr,0,arr,0,size);
-        }
-      }
-      public int size() { return size; }
-      private void checkBounds(int i, int size) {
-        if (i < 0 || i >= size)
-        throw new IndexOutOfBoundsException("Index: "+i+", Size: "+size);
-      }
-      public E get(int i) { checkBounds(i,size); return arr[i]; }
-      public E set(int i, E elt) {
-        checkBounds(i,size); E old = arr[i]; arr[i] = elt; return old;
-      }
-      public void add(int i, E elt) {
-        checkBounds(i,size+1); ensureCapacity(size+1);
-        System.arraycopy(arr,i,arr,i+1,size-i); arr[i] = elt; size++;
-      }
-      public E remove(int i) {
-        checkBounds(i,size); E old = arr[i]; arr[i] = null; size--;
-        System.arraycopy(arr,i+1,arr,i,size-i); return old;
-      }
-      public <T> T[] toArray(T[] a) {
-        if (a.length < size)
-        a = (T[])java.lang.reflect.Array. // unchecked cast
-        newInstance(a.getClass().getComponentType(), size);
-        System.arraycopy(arr,0,a,0,size);
-        if (size < a.length) a[size] = null;
-        return a;
-      }
-      public Object[] toArray() { return toArray(new Object[0]); }
+import java.util.*;
+class ArrayList<E> extends AbstractList<E> implements RandomAccess {
+  private E[] arr;
+  private int size = 0;
+  public ArrayList(int cap) {
+    if (cap < 0)
+      throw new IllegalArgumentException("Illegal Capacity: "+cap);
+    arr = (E[])new Object[cap]; // unchecked cast
+  }
+  public ArrayList() { 
+    this(10); 
+  }
+  public ArrayList(Collection<? extends E> c) { 
+    this(c.size()); 
+    addAll(c); 
+  }
+  public void ensureCapacity(int mincap) {
+    int oldcap = arr.length;
+    if (mincap > oldcap) {
+      int newcap = Math.max(mincap, (oldcap*3)/2+1);
+      E[] oldarr = arr;
+      arr = (E[])new Object[newcap]; // unchecked cast
+      System.arraycopy(oldarr,0,arr,0,size);
     }
+  }
+  public int size() { 
+    return size; 
+  }
+  private void checkBounds(int i, int size) {
+    if (i < 0 || i >= size)
+      throw new IndexOutOfBoundsException("Index: "+i+", Size: "+size);
+  }
+  public E get(int i) { 
+    checkBounds(i,size); 
+    return arr[i]; 
+  }
+  public E set(int i, E elt) {
+    checkBounds(i,size); 
+    E old = arr[i]; 
+    arr[i] = elt; 
+    return old;
+  }
+  public void add(int i, E elt) {
+    checkBounds(i,size+1); 
+    ensureCapacity(size+1);
+    System.arraycopy(arr,i,arr,i+1,size-i); 
+    arr[i] = elt; 
+    size++;
+  }
+  public E remove(int i) {
+    checkBounds(i,size); 
+    E old = arr[i]; 
+    arr[i] = null; 
+    size--;
+    System.arraycopy(arr,i+1,arr,i,size-i); return old;
+  }
+  public <T> T[] toArray(T[] a) {
+    if (a.length < size)
+      a = (T[])java.lang.reflect.Array. // unchecked cast
+    newInstance(a.getClass().getComponentType(), size);
+    System.arraycopy(arr,0,a,0,size);
+    if (size < a.length) 
+      a[size] = null;
+    return a;
+  }
+  public Object[] toArray() { 
+    return toArray(new Object[0]); 
+  }
+}
 ```
 
 在 `1.4` 节我们讨论了声明为的方法 `java.util.Arrays.asList` 如下：
 
 ```java
-   public static <E> List<E> asList(E... arr)
+public static <E> List<E> asList(E... arr)
 ```
 
 例如，这里有三个对这个方法的调用：
 
 ```java
-   List<Integer> a = Arrays.asList(1, 2, 3);
-   List<Integer> b = Arrays.asList(4, 5, 6);
-   List<List<Integer>> x = Arrays.asList(a, b); // 通用数组创建
+List<Integer> a = Arrays.asList(1, 2, 3);
+List<Integer> b = Arrays.asList(4, 5, 6);
+List<List<Integer>> x = Arrays.asList(a, b); // 通用数组创建
 ```
 
 回想一下，可变长度的参数列表是通过将参数打包到数组中并传递它来实现的。 因此这三个呼叫相当于以下内容：
 
 ```java
-   List<Integer> a = Arrays.asList(new Integer[] { 1, 2, 3 });
-   List<Integer> b = Arrays.asList(new Integer[] { 4, 5, 6 });
-   List<List<Integer>> x = Arrays.asList(new List<Integer>[] { a, b }); // 通用数组创建
+List<Integer> a = Arrays.asList(new Integer[] { 1, 2, 3 });
+List<Integer> b = Arrays.asList(new Integer[] { 4, 5, 6 });
+List<List<Integer>> x = Arrays.asList(new List<Integer>[] { a, b }); // 通用数组创建
 ```
 
 前两个调用很好，但由于 `List<Integer>` 不是可重用的类型，所以第三次在编译时警告未经检查的泛型数组的创建。
 
 ```java
-   VarargError.java:6: warning: [unchecked] unchecked generic array creation
-   of type java.util.List<java.lang.Integer>[] for varargs parameter
-   List<List<Integer>> x = Arrays.asList(a, b);
+VarargError.java:6: warning: [unchecked] unchecked generic array creation
+of type java.util.List<java.lang.Integer>[] for varargs parameter
+List<List<Integer>> x = Arrays.asList(a, b);
 ```
 
 此警告可能会造成混淆，特别是因为该源代码行不包含数组创建的显式实例！
 
 如果您尝试创建泛型类型的列表，则会出现类似的问题。 这是一个使用 `Arrays.asList` 创建包含给定元素的长度列表的方法：
 
 ```java
-   public static List<E> singleton(E elt) {
-     return Arrays.asList(elt); // 通用数组创建
-   }
+public static List<E> singleton(E elt) {
+  return Arrays.asList(elt); // 通用数组创建
+}
 ```
 
 这也会产生警告，出于同样的原因可能会造成混淆。