Queue（学习java编程思想）

一Queue

队列是一个典型的先进先出的容器。队列常被当作一种可靠的将对象从程序的某个区域传输到另一个区域的途径。队列在并发编程中特别重要，因为它们可以安全地将对象从一个任务传输给另一个任务。LinkedList提供了方法以支持队列的行为，并且实现了Queue接口，因此LinkedList可以用作Queue的一种实现。通过将LinkedList向上转型为Queue。

import java.util.*;

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 queue = new LinkedList();

Random rand = new Random(47);

for(int i = 0; i < 10; i++)
  queue.offer(rand.nextInt(i + 10));

printQ(queue);

Queue qc = new LinkedList();

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
*///:~

offer()方法是与Queue相关的方法之一，它在允许的情况下，将一个元素插入到队尾，或者返回false。peek()和element()都将在不移除的情况下返回对头，但是peek()方法在队列为空时返回null，而element()会抛出异常。pool()和remove()方法将移除并返回队头，但是pool()在队列为空时返回null,而remove()会抛出异常。

Queue接口窄化了对LinkedList的方法访问权限，以使得只有恰当的方法才可以使用，因此，你能够访问的LinkedList的方法会变少（这里实际上可以将Queue转型回LinkedList，但是至少我们不鼓励这么做）

注意，与Queue相关的方法提供了完整而独立的功能。即，对于Queue所继承的Collection，在不需要使用它的任何方法的情况下，就可以拥有一个可用的Queue。

二Priority

先进先出描述了最典型的队列规则。队列规则是指字啊给点一组队列中的元素的情况下，确定下一个弹出队列的元素的规则。先进先出声明的是下一个元素应该是等待时间最长的元素。优先级队列声明的是下一个弹出元素是最需要的元素（具有最高的优先级）。当你在PriorityQueue上调用offer()方法来插入一个对象时，这个对象会字啊队列中被排序。默认的排序将使用对象在队列中的自然顺序，但是你可以提供自己的Comparator来修改这个顺序。PriorityQueue可以确保当你调用peek()、pool()和remove()方法时，获取的元素将是队列中有限级最高的元素。

让PriorityQueue与Integer、String、Character这样的内置类型一起工作易如反掌。因为这些类已经内建了自然排序。

import java.util.*;

public class PriorityQueueDemo {
public static void main(String[] args) {
  
PriorityQueue priorityQueue =
  new PriorityQueue();

Random rand = new Random(47);

for(int i = 0; i < 10; i++)
  priorityQueue.offer(rand.nextInt(i + 10));

QueueDemo.printQ(priorityQueue);

List ints = Arrays.asList(25, 22, 20,
  18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25);

priorityQueue = new PriorityQueue(ints);

QueueDemo.printQ(priorityQueue);

priorityQueue = new PriorityQueue(
    ints.size(), Collections.reverseOrder());

priorityQueue.addAll(ints);
QueueDemo.printQ(priorityQueue);

String fact = "EDUCATION SHOULD ESCHEW OBFUSCATION";

List strings = Arrays.asList(fact.split(""));

PriorityQueue stringPQ =
  new PriorityQueue(strings);

QueueDemo.printQ(stringPQ);

//传入集合的尺寸、排序规则是反序
stringPQ = new PriorityQueue(
  strings.size(), Collections.reverseOrder());

stringPQ.addAll(strings);
QueueDemo.printQ(stringPQ);

Set charSet = new HashSet();
for(char c : fact.toCharArray())
  charSet.add(c); // Autoboxing

PriorityQueue characterPQ =
  new PriorityQueue(charSet);

QueueDemo.printQ(characterPQ);
}
} /* 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
  A A B C C C D D E E E F H H I I L N N O O O O S S S T T U U U W
W U U U T T S S S O O O O N N L I I H H F E E E D D C C C B A A
A B C D E F H I L N O S T U W
*///:~

你可以看到重复是允许的，最小的值拥有最高的优先级（如果是String，空格也可以算作值，并且比字母的优先级高），第三个对PriorityQueue的构造器调用，和第二个对PriorityQueue的调用使用了由Collections.reverseOrder()产生的反序的Comparator.最后一部分添加了一个HashSet来消除重复的Character。