Arrays.asList

Arrays.asList（非 List 类型的集合对象/可变参数的对象）；方法可以将传递的参数转变为 List 集合。如：Arrays.asList(new Object1(),new Object2(),…);

注意：Arrays.asList() 方法转换后的 List 对象是一个 size 不能改变的对象（底层是数组），如果对该对象做增加或者删除元素操作时，将会报错。

// Snow 是Light，Heavy的父类
List<Snow> snow = Arrays.<Snow>asList(new Light(), new Heavy());
// 不加 <Snow> 会报错

List<Snow> snow3 = new ArrayList<Snow>();
Collections.addAll(snow3, new Light(), new Heavy());
// Collections.addAll() 可以根据第一个参数了解到目标类型

TreeSet

// 按照字母顺序排序
Set<String> words = new TreeSet<Strings>(String.CASE_INSENSITIVE_ORDER)

Stack

“栈”通常是指“先进后出”（LIFO）的容器。

LinkedList 具有能够实现栈的所有功能的方法，因此可以直接将 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(); }
}

如果只需要栈的行为，使用继承就不合适了，所以这里使用组合。

java.util.Stack 使用了继承（Vector），所以一般不使用。

Queue

队列是一个典型的先进先出（FIFO）的容器。

LinkedList 实现了 Queue 接口。因此可用作 Queue 的一种实现（向上转型为 Queue） 。

public class QueueDemo {
    public static void printQ(Queue queue) {
        while (queue.peek() != null) {
            System.out.print(queue.remove() + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<Integer>();
        Random rand = new Random(47);
        for (int i = 0; i < 10; i++) {
            queue.offer(rand.nextInt(i + 10));
        }
        printQ(queue);
        Queue<Character> qc = new LinkedList<Character>();
        for (char c : "Brontosaurus".toCharArray()) {
            qc.offer(c);
        }
        printQ(qc);
    }
}
/* Output:
8 1 1 1 5 14 3 1 0 1
B r o n t o s a u r u s
*///:~

PriorityQueue

队列规则：给定一组队列中的元素，确定下一个弹出队列的元素的规则 。FIFO 是典型的一种规则，声明的是下一个元素应该是等待时间最长的元素。

优先级队列：下一个元素是最需要的元素（优先级最高的元素）。 Java SE5添加了这种队列。

offer() 插入一个对象到 PriorityQueue 时，会在队列中被排序 （实际上依赖于具体实现，典型的是插入时排序，但也可以在移除时选择最重要的元素，如果对象的优先级在队列等待时可以改变，那算法的选择就很重要）。默认排序使用对象的自然顺序，但可以通过提供 Comparator（如Collections.reverseOrder()，Java SE5）改变这个顺序。peek()、poll() 和 remove() 可以获得优先级最高的元素 （对于内置类型，最小值拥有最高优先级）。

如果要在PriorityQueue使用自定义类型，就需要添加额外的功能以提供自然顺序，或者提供自己的 Comparator。public PriorityQueue(Comparator<? super E> comparator)。

public class PriorityQueueDemo {
  public static void main(String[] args) {
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();
    Random rand = new Random(47);
    for(int i = 0; i < 10; i++)
      priorityQueue.offer(rand.nextInt(i + 10));
    QueueDemo.printQ(priorityQueue);

    List<Integer> ints = Arrays.asList(25, 22, 20, 18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25);
    priorityQueue = new PriorityQueue<Integer>(ints);
    QueueDemo.printQ(priorityQueue);
    priorityQueue = new PriorityQueue<Integer>(ints.size(), Collections.reverseOrder());
    priorityQueue.addAll(ints);
    QueueDemo.printQ(priorityQueue);
  }
} /* Output:
0 1 1 1 1 1 3 5 8 14
1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25
25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1
*///:~