QueueDemo+Deque 两种队列的演示

/**
 *    队列Queue 的演示
 *    知识点: 队列是一种常用的数据机构, 遵循先进先出的原则
 *    可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：
 *    只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。
 *    JDK中提供了Queue接口，同时使得LinkedList实现了该接口
 *    原因: 选择LinkedList实现Queue,因为Queue经常要进行插入和删除的操作，
 *    而LinkedList在这方面效率较高。
 *    应用: 比如游戏列队,需要有序的出入,有排队需求的情况,可以使用队列数据结构.
 *    
 *    主要方法:
 *    1. boolean offer(E e):将元素追加到队列末尾,若添加成功则返回true。
    2. E poll():从队首删除并返回该元素。
    3. E peek():返回队首元素，但是不删除。
 *    
 *    练习:
 *    1） 使用LinkedList构建队列，将字符串“a”、“b”、“c”放入队列中。
    2） 获取队列中队首元素。
    3      添加字符串"d"到队列中.
    4） 从队首开始删除元素，直到队列中没有元素为止，并在删除的同时输出删除的队首元素。

    个人总结:
    1.关于队列数据结构,是线性的,就是只能从尾巴进去,头出来. 遵循先进先出原则(例如一根多节铅笔)
    2.遍历操作在队列中用for不如用while, 而且要把队列的size()当循环条件和循环变量.
    3.遍历操作在队列中是一次性的,遍历一次,队列就无元素了.
    4.如果用peek方法遍历队列,只能无限的取出同一个队首元素.因为它只是获取队首元素,并不移除队首元素.
 */
public class QueueDemo {
    public static void main(String[] args) {
        //1.使用LinkedList构建队列，将字符串“a”、“b”、“c”放入队列中。
        Queue<String> queueList = new LinkedList<String>();
        queueList.offer("a");
        queueList.offer("b");
        queueList.offer("c");

        //2.获取队列中队首元素。
        /*
         * E peek()
         */
        String first = queueList.peek();    //获取但不移除此队列的头；如果此队列为空，则返回 null。 
                        //返回值 队列首元素, 但是并不移除队列首元素.
        System.out.println("队列首元素为"+first);    //队列首元素为a
        System.out.println(queueList);    //[a, b, c]

        //3.添加字符串"d"到队列中.
        /*
         * boolean offer()
         * 将指定的元素插入此队列, 如果该元素已添加到此队列，则返回 true；否则返回 false 
         */
        boolean r = queueList.offer("d");    
        System.out.println("字符串是否添加成功:"+r);
        //字符串是否添加成功:true
        System.out.println(queueList);    
        //[a, b, c, d]

        //4.从队首开始删除元素，直到队列中没有元素为止，并在删除的同时输出删除的队首元素。
        /*
         * E poll
         * 获取并移除此队列的头，如果此队列为空，则返回 null。 
         * 思路:遍历队列, 不断取出队首, 即删除成功
         * 注意:遍历队列不要常做,因为需要都取出来才能遍历全部元素.
         *           遍历队列的方法用while,因为for经实验,不合适,因为队列的Size(),在不断的循环
         * 过程中,不断的减少.所以while( 队列的Size()>0 )即可.
         * 
         */
        while(queueList.size()>0){
            String delStr = queueList.poll();    
            //注意:这里如果使用list.peek(),会死循环,不断的查看同一个队首元素
            System.out.println("删除元素(队首元素): "+delStr);
        }
        System.out.println(queueList);
        /*
         * 输出结果:
         *     删除元素(队首元素): a
            删除元素(队首元素): b
            删除元素(队首元素): c
            删除元素(队首元素): d
            []
         */
    }
}

/**
 *    Deque接口,是Queue的子接口.定义了所谓“双端队列.
 *    即从列队的两端分别可以入队(offer)和出队(poll).
 *    同样LinkedList实现了该接口.如果将Deque限制成
 *    只从一端入队(push)出队(pop),就形成了Stack的数据结构.
 *    栈 遵循 先进后出原则.
 *    应用场景:需要后退操作,前进操作的时候(例如Windos的前进后退功能)
 *    
 *    Deque提供了操作栈的相关方法,其主要方法如下:
    void push(E e):将给定元素"压入"栈中。存入的元素会在栈首。即:栈的第一个元素
    E pop():将栈首元素删除并返回。

 *    本案例要求测试Deque的用法，详细要求如下：
    1） 使用LinkedList构建栈，将字符串“a”、“b”、“c”放入栈中。
    2） 获取栈中栈顶元素。
    3） 从栈顶开始删除元素，直到栈中没有元素为止，并在删除的同时输出删除的栈顶元素。
 *    
 */
public class StackDemo {

    public static void main(String[] args) {
        //1） 使用LinkedList构建栈，将字符串“a”、“b”、“c”放入栈中。
        Deque<String> stackList = new LinkedList<String>();
        stackList.push("a");
        stackList.push("b");
        stackList.push("c");

        /*
         * void push(E e) 
         * 将给定元素"压入"栈中。存入的元素会在栈首。
         */
        stackList.push("d");     //"d" 入栈

        //2） 获取栈中栈顶元素。
        /*
         * E peek()  获取，但不移除此双端队列所表示的队列的头部
         * （换句话说，此双端队列的第一个元素）；
         * 如果此双端队列为空，则返回 null。
         */
        String topStr = stackList.peek();
        System.out.println("栈顶元素 :"+topStr);        //栈顶元素 :d
        System.out.println(stackList);                    //[d, c, b, a]

        //3） 从栈顶开始删除元素，直到栈中没有元素为止，并在删除的同时输出删除的栈顶元素。
        /*
         * E pop() 
         * 将栈首元素删除并返回。
         * 思路:遍历栈队列,挨个弹栈(pop)
         */
        while(stackList.size()>0){
            String outStr = stackList.pop();
            System.out.println("弹栈元素: "+outStr);
        }
        System.out.println(stackList);
        /*输出结果:
             弹栈元素: d
            弹栈元素: c
            弹栈元素: b
            弹栈元素: a
            []
         */
    }
}