java集合类（六）About Queue

终于来到了java集合类的尾声，太兴奋了，不是因为可以休息一阵了，而是因为又到了开启新知识的时刻，大家一起加油打气！！Come on...Fighting！

About “interface Queue<E>”

All Superinterfaces:Collection<E>, Iterable<E>

All Known Subinterfaces:BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E>

All Known Implementing Classes:AbstractQueue, ArrayBlockingQueue, ArrayDeque, ConcurrentLinkedDeque, ConcurrentLinkedQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedList, LinkedTransferQueue, PriorityBlockingQueue, PriorityQueue, SynchronousQueue

先简要说明下队列：
之前，在“java集合类（三）About Iterator & Vector（Stack）”中讲到堆（heap）与栈（stack）的区别，现在讨论栈Stack与队列Queue的区别：
1）队列：FIFO先进先出，栈LIFO后进先出
2）队列：从队尾进对头出，栈：栈顶进栈顶出
3）遍历的速度不同：栈只能从栈顶取数，要得到最先入栈的元素，必须遍历这个栈，而且还需要开辟临时空间；队列则不同，它基于指针进行遍历，可以从对头或者队尾开始（不能同时），无需临时空间，遍历过程不影响数据结构，速度要快得多

Queue的实现：在学习LinkedList的时候，我们已知道LinkedList实现了Queue接口，所以今天的Queue也可以用LinkedList实现，并且LinkedList还实现了Stack（java集合类（三）About Iterator & Vector（Stack）提到），所以我们也可以设想能不能用Stack实现Queue？答案是肯定的，不过要用两个Stack才能实现！现在来看一个Queue的基础例子：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
 
/**
 * @author jp
 *@date 2013-12-16
 */
public class queuedemo {
    public static void printqueue(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 random  = new Random(32);
        for (int i = 0; i < 10; i++) 
            queue.offer(random.nextInt(i + 10));
        printqueue(queue);
        Queue<Character> qCharacters  = new LinkedList<Character>();
        for(char c: "GreatUniversity".toCharArray())
            qCharacters.offer(c);
        printqueue(qCharacters);
    }
}

Output：

7 7 5 9 9 2 9 3 0 2
G r e a t U n i v e r s i t y

说明：关于Queue的操作

	`Throws exception`	`Returns special value`
Insert	`add(e)`	`offer(e)`
Remove	`remove()`	`poll()`
Examine	`element()`	`peek()`

add（）& offer（）：在队尾插入元素，成功则返回true，失败则返回false，并且可能会会抛出IllegalStateException等；但offer（）不会抛出任何异常；

remove（）& poll（）：移除并返回对头元素，但在队列为空时，pull（）返回null，而remove（）则抛出NoSuchElementException；

element（） & peek（）：不移除并返回对头元素，但在队列为空时，peek（）返回null，而element（）则抛出NoSuchElementException；

About PriorityQueue：PriorityQueue与Queue的最基本的区别在于，优先级队列PriorityQueue具有顺序性；通常PriorityQueue用offer（）方法进行插入元素的时候，它的默认顺序是对象的自然顺序（数字小到大，字母按字母表），但程序员可以通过提供自己的Comparator修改默认排序，以确保在通过peek（），poll（），remove（）等方法获取元素时，得到的是具有最高优先级的的元素。另外，在学习数据结构堆排序的时候，老师跟我们讲得一般都是基于大顶堆而不是小顶堆，因为一般小顶堆通常用来实现维持优先级队列。下面举例说明：

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
 
/**
 * @author jp
 *@date 2013-12-16
 */
public class priorityqueuedemo {
    public static void printqueue(Queue queue) {
        while (queue.peek() != null) {
            System.out.print(queue.remove() + " ");
        }
        System.out.println();   
    }
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();
        Random random = new Random(32);
        for(int i = 0;i < 10; i++)
            priorityQueue.offer(random.nextInt(i + 10));
        printqueue(priorityQueue);
        java.util.List<Integer> list = Arrays.asList(12,14,15,16,17,18,19,20);
        priorityQueue = new PriorityQueue<Integer>(list);
        printqueue(priorityQueue);
        priorityQueue = new PriorityQueue<Integer>(list.size(), Collections.reverseOrder());
        priorityQueue.addAll(list);
        printqueue(priorityQueue);
          
        String string = "i have a great dream";
        Set<Character> charset = new HashSet<Character>();
        for (char c: string.toCharArray()) {
            charset.add(c);
        }
        PriorityQueue<Character> pCharacters = new PriorityQueue<Character>(charset);
        printqueue(pCharacters);
    }
}

Output:

从最后一行可以看出：空格的优先级比一般的字母要高。下面看一个关于自己定义顺序，修改Comparator的例子：

import java.util.*;
 
class ToDoList extends PriorityQueue<ToDoList.ToDoItem> {
 
    static class ToDoItem implements Comparable<ToDoItem> {
        private char primary;
        private int secondary;
        private String item;
 
        public ToDoItem(String s, char c, int i) {
            primary = c;
            secondary = i;
            item = s;
        }
 
        /*
         * @see java.lang.Comparable#compareTo(java.lang.Object)
         * @implements Comparabale,then define the CompareTo()
         * @function firstly compare "key value",then "secondary value"(+1,0,-1)
         */
        public int compareTo(ToDoItem arg) {
            if(primary > arg.primary)
                return +1;
            if(primary == arg.primary)
                if(secondary > arg.secondary)
                    return +1;
                else if(secondary == arg.secondary)
                    return 0;
            return -1;
        }
         
        public String toString() {
            return Character.toString(primary) + secondary +": " + item;
        }
    }
     
    public void add(String s, char c, int i) {
        super.add(new ToDoItem(s, c, i));
    }
     
    public static void  main(String[] args) {
        ToDoList toDoList = new ToDoList();
        toDoList.add("allen",'a',2);
        toDoList.add("jackson",'a',3);
        toDoList.add("davil",'b',3);
        toDoList.add("avily",'b',2);
        while (!toDoList.isEmpty()) {
            System.out.println(toDoList.remove());
        }
    }
}