chart11 持有对象

11.3  添加对象 实例：AsListInference.java，

//: holding/AsListInference.java  
// Arrays.asList() makes its best guess about type.  
import java.util.*;  
class Snow {}  
class Powder extends Snow {}  
class Light extends Powder {}  
class Heavy extends Powder {}  
class Crusty extends Snow {}  
class Slush extends Snow {}  
public class AsListInference {  
    public static void main(String[] args) {  
        List<Snow> snow1 = Arrays.asList(  
            new Crusty(), new Slush(), new Powder());  
        // Won't compile:  
        // List<Snow> snow2 = Arrays.asList(  
            // new Light(), new Heavy());  
        // Compiler says:  
        // found : java.util.List<Powder>  
        // required: java.util.List<Snow>  
        // Collections.addAll() doesn't get confused:  
        List<Snow> snow3 = new ArrayList<Snow>();  
        Collections.addAll(snow3, new Light(), new Heavy());  
        // Give a hint using an  
        // explicit type argument specification:  
        List<Snow> snow4 = Arrays.<Snow>asList(  
            new Light(), new Heavy());  
    }  
} ///:~

1. 解决办法：使用显式类型参数说明（List<Snow> snow4 = Arrays.<Snow>asList(new Light(), new Heavy());） ，象上面的例子中最后所做的那样。
2. Collections.addAll()。
   public static <T> boolean addAll(Collection<? super T> c, T... elements)该方法接受一个Collection对象，以及一个数组或是一个用逗号分割的列表，将元素添加到Collection中。先构建一个不包含元素的Collection，然后调用Collections.addAll()这种方式很方便，因此是首选方式。
3. Collection导出类构造器，可以接受另一个Collection，用它来将自身初始化。
4. Collection的addAll()方法，将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。相比使用构造函数初始化，这种方法快的多。

11.5 当确定一个元素是否属于List（不知这里是否可以换为容器），发现某个元素的索引，以及从某个List中移除一个元素时，都会用到equal（）​方法

11.6 迭代器，

           Iterater的四个作用

          在调用remove()之前，必须先调用next()

        “接受对象容器，并传递他，从而在每个对象上都执行操作，这种思想十分强大，并且贯穿于本书”

      

//: holding/CrossContainerIteration.java
import typeinfo.pets.*;
import java.util.*;

public class CrossContainerIteration {
  public static void display(Iterator<Pet> it) {
    while(it.hasNext()) {
      Pet p = it.next();
      System.out.print(p.id() + ":" + p + " ");
    }
    System.out.println();
  }	
  public static void main(String[] args) {
    ArrayList<Pet> pets = Pets.arrayList(8);
    LinkedList<Pet> petsLL = new LinkedList<Pet>(pets);
    HashSet<Pet> petsHS = new HashSet<Pet>(pets);
    TreeSet<Pet> petsTS = new TreeSet<Pet>(pets);
    display(pets.iterator());
    display(petsLL.iterator());
    display(petsHS.iterator());
    display(petsTS.iterator());
  }
} /* Output:
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx
4:Pug 6:Pug 3:Mutt 1:Manx 5:Cymric 7:Manx 2:Cymric 0:Rat
5:Cymric 2:Cymric 7:Manx 1:Manx 3:Mutt 6:Pug 4:Pug 0:Rat
*///:~

       Iterater,能够将遍历序列的操作与序列的底层的结构分离，迭代器统一对容器的访问形式​

       listIterater只适用于list类型的访问，不过它能够实现双向的移动

//: holding/ListIteration.java
import typeinfo.pets.*;
import java.util.*;

public class ListIteration {
  public static void main(String[] args) {
    List<Pet> pets = Pets.arrayList(8);
    ListIterator<Pet> it = pets.listIterator();
    while(it.hasNext())
      System.out.print(it.next() + ", " + it.nextIndex() +
        ", " + it.previousIndex() + "; ");
    System.out.println();
    // Backwards:
    while(it.hasPrevious())
      System.out.print(it.previous().id() + " ");
    System.out.println();
    System.out.println(pets);	
    it = pets.listIterator(3);
    while(it.hasNext()) {
      it.next();
      it.set(Pets.randomPet());
    }
    System.out.println(pets);
  }
} /* Output:
Rat, 1, 0; Manx, 2, 1; Cymric, 3, 2; Mutt, 4, 3; Pug, 5, 4; Cymric, 6, 5; Pug, 7, 6; Manx, 8, 7;
7 6 5 4 3 2 1 0
[Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Manx]
[Rat, Manx, Cymric, Cymric, Rat, EgyptianMau, Hamster, EgyptianMau]
*///:~

11.10 Map可以返回它的键的Set,它的值得Collection,或者他的键值对的Set

linklist 实现了list接口和Queue接口​

11.3 迭代器与Foreach 

       foreach语法可以用于数组和任何的collection容器，一个类如果想用foreach来遍历这个类的对象，那么这个类必须实现Iterater接口，（Demo）

//: holding/IterableClass.java
// Anything Iterable works with foreach.
import java.util.*;

public class IterableClass implements Iterable<String> {
  protected String[] words = ("And that is how " +
    "we know the Earth to be banana-shaped.").split(" ");
  public Iterator<String> iterator() {
    return new Iterator<String>() {
      private int index = 0;
      public boolean hasNext() {
        return index < words.length;
      }
      public String next() { return words[index++]; }
      public void remove() { // Not implemented
        throw new UnsupportedOperationException();
      }
    };
  }	
  public static void main(String[] args) {
    for(String s : new IterableClass())
      System.out.print(s + " ");
  }
} /* Output:
And that is how we know the Earth to be banana-shaped.
*///:~

11.13.1 适配器方法惯用法  

ModifyingArraysASList.java重要​

//: holding/ModifyingArraysAsList.java
import java.util.*;

public class ModifyingArraysAsList {
  public static void main(String[] args) {
    Random rand = new Random(47);
    Integer[] ia = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    List<Integer> list1 =
      new ArrayList<Integer>(Arrays.asList(ia));
    System.out.println("Before shuffling: " + list1);
    Collections.shuffle(list1, rand);
    System.out.println("After shuffling: " + list1);
    System.out.println("array: " + Arrays.toString(ia));

    List<Integer> list2 = Arrays.asList(ia);
    System.out.println("Before shuffling: " + list2);
    Collections.shuffle(list2, rand);
    System.out.println("After shuffling: " + list2);
    System.out.println("array: " + Arrays.toString(ia));
  }
} /* Output:
Before shuffling: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
After shuffling: [4, 6, 3, 1, 8, 7, 2, 5, 10, 9]
array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Before shuffling: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
After shuffling: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8]
array: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8]
*///:~

11.14  总结

​    ​