Queue、Deque、Stack

Table of Contents

1.类图结构

2.Queue

3.Deque（Double Ended Queue双端队列）

4.Stack

---

1.类图结构

2.Queue

1.使用场景：需要出现队列的数据结构时，使用Queue.

2.使用方法：Queue<Integer> queue = new LinkedList<>();

3.Queue的方法：

	抛出异常	返回特殊值
队列末插入数据	add(e)	offer(e)
队列头移除数据	remove()	poll()
获取队列头数据	element()	peek()
判空	isEmpty()

3.Deque（Double Ended Queue双端队列）

1.使用场景：需要出现栈的数据结构时，使用Deque.

2.使用方法：Deque<Integer> deque = new LinkedList<>();

3.Deque的方法：

堆栈方法	方法
入栈	push()
出栈	pop()
取栈顶元素	peek()
判空	isEmpty()

• LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList 实现 List 接口，能对它进行队列操作。
• LinkedList适用场景：队列结构和栈结构

import java.util.*;

public class TEST {
    public static void main(String[] args) {
         //1、Queue 实现队列结构
            
        /**public interface Queue<E>extends Collection<E>
         队列， 一种常用的数据结构，可以将队列看做是一种特殊的线性表，该结构遵循的先进先出原则。Java中，LinkedList实现了Queue接口,因为LinkedList进行插入、删除操作效率较高
         相关方法：
         boolean offer(E e):将元素追加到队列末尾,若添加成功则返回true。
         E poll():从队首删除并返回该元素。
         E peek():返回队首元素，但是不删除
         */
        public class QueueDemo {
            public static void main(String [] args) {
                Queue<String> queue = new LinkedList<String>();
                //追加元素
                queue.offer("one");
                queue.offer("two");
                queue.offer("three");
                queue.offer("four");
                System.out.println(queue);
                //从队首取出元素并删除
                String poll = queue.poll();
                System.out.println(poll);
                System.out.println(queue);
                //从队首取出元素但是不删除
                String peek = queue.peek();
                System.out.println(peek);
                System.out.println(queue);
                //遍历队列，这里要注意，每次取完元素后都会删除，整个
                //队列会变短，所以只需要判断队列的大小即可
                while(queue.size() > 0) {
                    System.out.println(queue.poll());
                }
            }
        }

        //2、Deque  实现栈结构
          /**
              public interface Deque<E>extends Queue<E>

        双向队列，指该队列两端的元素既能入队(offer)也能出队(poll),如果将Deque限制为只能从一端入队和出队，则可实现栈的数据结构。对于栈而言，有入栈(push)和出栈(pop)，遵循先进后出原则

        常用方法如下：
        void push(E e):将给定元素”压入”栈中。存入的元素会在栈首。即:栈的第一个元素
        E pop():将栈首元素删除并返回。
        E peek():返回栈顶元素，但是不删除
         */

        public class DequeDemo {
            public static void main(String[] args) {
                Deque<String> deque = new LinkedList<String>();
                deque.push("a");
                deque.push("b");
                deque.push("c");
                System.out.println(deque);
                //获取栈首元素后，元素不会出栈
                String str = deque.peek();
                System.out.println(str);
                System.out.println(deque);
                while(deque.size() > 0) {
                    //获取栈首元素后，元素将会出栈
                    System.out.println(deque.pop());
                }
                System.out.println(deque);
            }
        }

    }
}

4.Stack

1.使用场景：需要出现栈的数据结构时，使用Stack.

2.使用方法：Stack<Integer> stack = new Stack<>();

3.Stack的方法：

        boolean isEmpyt()  （这个是Vector中的方法）   或者  boolean empty()  （这个是Stack中的方法）

        synchronized E peek()

        synchronized E pop()

        E push(E object)

       synchronized int search(Object o)