Stack/Set/Map/Queue浅析

栈

“栈”通常是表示“后进先出”的容器。就好比在盘子里叠入披萨，最后放进去的总是在最上面。
ListkedList具有能直接实现栈的所有功能的方法，因此可以直接将LinkedList当作栈使用。
不过，有时候一个真正的“栈”更能把事情说明白：

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();
    }
}

这里使用泛型，引入了在栈的类定义中最简单的可行示例。T表示告诉编译器这是参数化的类型，实际类型会在使用时被替换。如果我们只需要栈的行为，那使用继承就不合适了，因为这样就会产生具有LinkedList的其他所有方法的类。

public static void main(String[] args) {
    //创建具有泛型T的Stack类。并声明了T为String类型
    Stack<String> stack = new Stack<String>();
    for(String s : "My dog has fleas".split(" ")){
        stack.push(s);
    }
    while (!stack.empty()) {
        //pop()方法是移除栈顶元素，并且返回。
        System.out.println(stack.pop() + " ");
    }
}

---

Set

Set不保存重复元素。如果我们需要查询功能，那么用hashSet是很好的选择，因为它专门针对了查找进行优化。
Set和Collection有完全一样的接口。实际上Set就是Collection，只是行为不同。行为的不同是继承和多态的典型应用。Set是基于对象的值来确定归属的。

public static void main(String[] args) {
        Random rand = new Random(47);
        Set<Integer> intset = new HashSet<Integer>();
        for(int i = 0; i < 10000; i++){
            intset.add(rand.nextInt(30));
        }
        System.out.println(intset);
    }
//out
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

在hashSet中插入了0-29的10000个随机数，但是实际结果只有0-29，并且是无序的。这里的无序指的是存入和取出的顺序不一致。因为考虑到速度原因，HashSet用到了散列。其顺序与TreeSet和LinkedHashSet都不同，因为他们的实现具有不同的元素存储方式。TreeSet将元素存储在红-黑树数据结构中，而HashSet是散列函数。LinkedHashSet也使用了散列，但是看起来它使用了链表来维护插入顺序。如果我们需要排序，可以用TreeSet来替换HashSet，默认安装字典排序，并且区分大小写。如果想用字母排序，可以向TreeSet构造器传入String.CASE_INSENTIVE_ORDER

public static void main(String[] args) {
        String sort = "A B C J Y O M G M U O aa b c j y o m g m u o";
        Set<String> words = new TreeSet<String>();
        for(String s : sort.split(" ")){
            words.add(s);
        }
        System.out.println("not set para:" + words);
        Set<String> words2 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        for(String s : sort.split(" ")){
            words2.add(s);
        }
        System.out.println("use set para:" + words2);
    }
//out 
not set para:[A, B, C, G, J, M, O, U, Y, a, b, c, g, j, m, o, u, y]
use set para:[A, aa, B, C, G, J, M, O, U, Y]

很明显String.CASE_INSENSITIVE_ORDER虽然是按照字符排序了，但是其实际含义是不区分大小写。也就是B和b只能在Set中存在一个了。

---

Map

将对象映射到其他对象的能力是一种解决编程问题的杀手锏。

public static void main(String[] args) {
        Random rand = new Random(47);
        Map<Integer, Integer> m = new HashMap<>();
        for(int i = 0; i < 10000; i++){
            int r = rand.nextInt(20);
            Integer freq = m.get(r);
            m.put(r, freq == null ? 1:freq+1);
        }
        System.out.println(m);
    }
//out
{0=481, 1=502, 2=489, 3=508, 4=481, 5=503, 6=519, 7=471, 8=468, 9=549, 10=513, 11=531, 12=521, 13=506, 14=477, 15=497, 16=533, 17=509, 18=478, 19=464}

自动包装机制，将随机生成的int转换成了Integer类型，用生成的int类型去Map中找，是否有该key，如果没有会返回null，如果有则会返回对应的value值。为null的情况会赋值给freq为1，不为null就进行累加。在累加中，自动拆包又进行的操作，否则Integer不能进行累加的。

---

Map与数组和其他的Collection一样。可以很简单的扩展到多维结果，比如Map<Stirng,Map<Integer,String>>或者更复杂的数据结构。

//这句话表示，该变量petPeople的数据类型是Map,而Map中key是String，value是List。这个List的类型是未知但且继承String
    public static Map<String,List<? extends String>> petPeople = new HashMap<>();
    static{
        petPeople.put("Dawn", Arrays.asList("Molly","Spot"));
        petPeople.put("Kata", Arrays.asList("Shackleton","Elsie May","Margrett"));
        petPeople.put("Marilyn", Arrays.asList("Louie aka Louis Snorkelstein Dupree",
                "Stanford aka Srinky el Negro",
                "Pinkola"));
        petPeople.put("Luke", Arrays.asList("Fuzzy","Fizzy"));
        petPeople.put("Isaac", Arrays.asList("Freckly"));
    }
    public static void main(String[] args) {
        //keySet返回了所有key组成的Set
        System.out.println("People: " + petPeople.keySet());
        //values返回了所有对应的value，根据Set的默认排序
        System.out.println("Pets: " + petPeople.values());
        for (String string : petPeople.keySet()) {
            System.out.println(string + " has:");
            for (String s : petPeople.get(string)) {
                System.out.println("   " + s);
            }
        }
    }

---

Queue

队列是保持先进先出，和LinkedList相反。就像排队打饭一样，先排队的人，就能先打到饭，排除插队的情况。
队列在并发编程中特别重要，因为它们可以安全地将对象从一个任务传给另一个任务。
LinkedList提供了方法以支持队列的行为，并且它是想了Queue接口，因此LinkedList可以用做Queue的一种实现。通过将LinkedList向上转型为Queue。

public static void printQ(Queue queue){
        while(queue.peek() != null){
            System.out.print(queue.remove() + " ");
        }
    }
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        Random rand = new Random(47);
        for (int i = 0; i < 10; i++) {
            queue.offer(rand.nextInt(i+10));
        }
        printQ(queue);
    }

offer()将一个元素插入到队列尾端。在将LinkedList转化为Queue后，LinkedList的方法会不能使用。当然我们可以将Queue又转成LinkedList。

PriorityQueue

PriorityQueue在Java SE5中被添加，是为了提供这种行为的一种自动实现。
当你在PriorityQueue上调用offer()方法来插入一个对象时，这个对象会在队列中被排序。默认的排序将使用对象在队列中的自然顺序，但是你可以通过提供自己的Comparator来修改这个顺序。PriorityQueue可以确保当你在调用Peel(),poll()和remove()时，获取的是最高优先级的元素。

public static void printQ(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<>();
        Random rand = new Random(47);
        for (int i = 0; i < 10; i++) {
            //队列存值
            priorityQueue.offer(rand.nextInt(i + 10));
        }
        //输出第一次删除被返回的值
        PriorityQueueDemo.printQ(priorityQueue);
        //构建ints的List容器。此种构建方式，不允许被add
        List<Integer> ints = Arrays.asList(25,22,20,18,14,9,3,1,1,2,3,9,14,18,21,23,25);
        //将此List给优先级队列
        priorityQueue = new PriorityQueue<>(ints);
        PriorityQueueDemo.printQ(priorityQueue);
        priorityQueue = new PriorityQueue<>(ints.size(),Collections.reverseOrder());
        priorityQueue.addAll(ints);
        PriorityQueueDemo.printQ(priorityQueue);
    }

由此可以看出，队列运行重复，数字小的优先级高（比字母高）。大写字母比小写字母优先级高。
Collections.reverseOrder()同样是在JAVA SE5中增加的反序Comparator。

下节会讲Collection和Iterator和Foreach和适配器方法惯用法