有几个简单的问题，请教下大家（高分，但是简单！！）

Question

代码虽然有点长，但真的不难！！！
代码1：
import typeinfo.pets.*;
import java.util.*;
import static net.mindview.util.Print.*;public class ListFeatures {
  public static void main(String[] args) {
    Random rand = new Random(47);
    List<Pet> pets = Pets.arrayList(7);
    print("1: " + pets);
    Hamster h = new Hamster();
    pets.add(h); 
    print("2: " + pets);
    print("3: " + pets.contains(h));
    pets.remove(h); 
    Pet p = pets.get(2);
    print("4: " +  p + " " + pets.indexOf(p));
    Pet cymric = new Cymric();
    print("5: " + pets.indexOf(cymric));    //代码1.问题1：为什么这里不能再加一个new Cymric()？？
    print("6: " + pets.remove(cymric));
    // Must be the exact object:
    print("7: " + pets.remove(p));
    print("8: " + pets);
    pets.add(3, new Mouse()); 
    print("9: " + pets);
    List<Pet> sub = pets.subList(1, 4);
    print("subList: " + sub);
    print("10: " + pets.containsAll(sub));
    Collections.sort(sub); 
    print("sorted subList: " + sub);
    print("11: " + pets.containsAll(sub));
    Collections.shuffle(sub, rand); 
    print("shuffled subList: " + sub);
    print("12: " + pets.containsAll(sub));
    List<Pet> copy = new ArrayList<Pet>(pets);
    sub = Arrays.asList(pets.get(1), pets.get(4));
    print("sub: " + sub);   //代码1.问题2：答案怎么会是下面的输出结果？pets.get(1)应该是Manx，而pets.get(4)应该是Pug。怎么会是sub: [Mouse, Pug]？？
  }
}/* Output:
1: [Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug]
2: [Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Hamster]
3: true
4: Cymric 2
5: -1
6: false
7: true
8: [Rat, Manx, Mutt, Pug, Cymric, Pug]
9: [Rat, Manx, Mutt, Mouse, Pug, Cymric, Pug]
subList: [Manx, Mutt, Mouse]
10: true
sorted subList: [Manx, Mouse, Mutt]
11: true
shuffled subList: [Mouse, Manx, Mutt]
12: true
sub: [Mouse, Pug]*/代码2：
import java.util.LinkedList;public class Stack<T> {
  private LinkedList<T> storage = new LinkedList<T>();
  public void push(T v) { storage.addFirst(v); }
  public T peek() { return storage.getFirst(); }
  public T pop() { return storage.removeFirst(); }
  public boolean empty() { return storage.isEmpty(); }
  public String toString() { return storage.toString(); }
}
import net.mindview.util.*;public class StackTest {
  public static void main(String[] args) {
    Stack<String> stack = new Stack<String>();
    for(String s : "My dog has fleas".split(" "))
      stack.push(s);
    while(!stack.empty())
      System.out.print(stack.pop() + " ");  //代码2.问题：这个输出我看不懂了，removeFirst();不是先要将第一个对象删掉，然后再返回第一个的吗？ 所以我觉得输出应该是 has dog My。
  }
} /* Output:
fleas has dog My
*///

问题3：关于 iterator() 的介绍，书上有句话看不懂该怎么理解呢？“：能够将遍历序列的操作与序列底层的结构分离。”这句话怎么读，我都没有任何感觉。

Answer 1

iterator的特点是:将遍历一个序列的操作与此序列底层结构香分离.  Iterator隐藏了容器底层的结构.   
迭代器是一个对象,它的工作是遍历并选择序列中的对象,而客户端程序员不必知道或关心该序列底层的结构.而且创建它的代价小. Iterator     集合框架中的接口，主要用于迭代集合中的元素，如果你用For循环，它就像你用吸管从饮料瓶吸饮料一样，每吸一口就消耗掉一点，它的迭代效率很高。

Answer 2

import   java.util.*;   
  public   class   Printer{   
  static   void   printAll(Iterator   e){   
  while(e.hasNext())   
        System.out.println(e.next());   
  }   
  }   
  
这个程序中,没有关于序列类型的信息,只有一个迭代器Iterator.不需要知道要遍历的是ArrayList还是LinkedList.

Answer 3

   System.out.print(stack.pop() + " ");  //代码2.问题：这个输出我看不懂了，removeFirst();不是先要将第一个对象删掉，然后再返回第一个的吗？ 所以我觉得输出应该是 has dog My。
这里不知道楼主如何理解的，栈内的内容是fleas has dog My
正因为要先将第一个对象删除，再返回它，所以第一次返回的是fleas，这时候栈内还剩三个
循环，再删除第一个，得到has。还剩两个
继续。
一直到栈内的内容都输出了。

Answer 4

Collection是个接口吧？它定义了集合的相关操作。
Collection下边有很多的实现类，对吧 ？比如ArrayList,HashSet等等。每种实现类，它对元素的存储结构都是不尽相同的，对吧。
你可以发现，Collection定义了一个iterator()方法，他可以返回一个Iterator接口的实现类。现在，当我们实例化一个Collection的实现类的时候，我们是可以调用Collection定义的那些方法的，所以，在实例化一个实现类以后，我们是可以只使用
Collection定义的那些方法对该对象进行关于集合方面的操作的，这样的编程方式，其实是在面向Collection编程，我们不用考虑Collection对集合元素的
具体的实现过程。同样的，每个Collection的实现类也会实现iterator()方法，从而返回一个Iterator具体的实现类，实现Iterator所定义的方法，我们也同样可以面向
Iterator来编程，而不必考虑它具体是怎样实现的。上面我所说的面向Collection来编程，其实就是将关于集合的操作与集合底层的结构分离；而那个面向Iterator编程，其实就是将遍历序列的操作与序列
底层的结构分离。明白了么 ？以上是我的个人理解。仅供参考。哈哈。

Answer 5

这样做没问题的  对吧？
Printer printer = new Printer();
printer.printAll(arrayList);

Answer 6

第一段没研究，
第二段是一个栈，　后进先出。　只有一个出口，和入口push　入栈　　fleas->has->dog->Mypop   出栈   fleas<-has<-dog<-My   

Answer 7

    Pet cymric = new Cymric();       
    print("5: " + pets.indexOf(cymric));    //代码1.问题1：为什么这里不能再加一个new Cymric()？？这里它没有没有添加cymric进去，就行没有pets.add(cymric)，所以cymric不是在pets里面，所以结果是pets.indexOf(cymric))
的结果就是-1.

Answer 8

print("10: " + pets.containsAll(sub));
    Collections.sort(sub); // In-place sort
    print("sorted subList: " + sub);
    print(pets);          //加入这个，我们可以看到pets的变化，可以推断，sub只是引用pets的，
                        //所以sub改变了，pets也跟这个改变了,这里是[Rat, Manx, Mouse, Mutt, Pug, Cymric, Pug]
    // Order is not important in containsAll():
    print("11: " + pets.containsAll(sub));
    Collections.shuffle(sub, rand); // Mix it up
    print("shuffled subList: " + sub);
    print(pets);          //这里也加个，这里的pets是[Rat, Mouse, Manx, Mutt, Pug, Cymric, Pug]
    print("12: " + pets.containsAll(sub));
    List<Pet> copy = new ArrayList<Pet>(pets);
    sub = Arrays.asList(pets.get(1), pets.get(4));
    print("sub: " + sub);        //所以结果也自然是这个 [Mouse, Pug]
    copy.retainAll(sub);

Answer 9

哦~根据12的解答，原来操纵sub 等于同样在操纵pets ，我去看看，为什么会这样，如果有朋友知道的话请发一下~谢谢！！！

Answer 10

代码2.问题：这个输出我看不懂了，removeFirst();不是先要将第一个对象删掉，然后再返回第一个的吗？ 所以我觉得输出应该是 has dog My。
  
对于这个问题，JDK是这么说的
removeFirst() 
          移除并返回此列表的第一个元素。就是移除了这个元素，并且还返回这个元素的值，我是这么理解的

Answer 11

关于堆栈的解释是  storage.removeFirst()就是把栈顶元素弹出 并把堆栈指针下移一位