3分钟了解Java中Stack,Queue,Deque常用方法

标签：Deque Java System st Queue println dq queue out

stack

常用语法

boolean empty() 
    测试堆栈是否为空。
Object peek( )
    查看堆栈顶部的对象，但不从堆栈中移除它。
Object pop( )
    移除堆栈顶部的对象，并作为此函数的值返回该对象。
Object push(Object element)
    把项压入堆栈顶部。
int search(Object element)
    返回对象在堆栈中的位置，以 1 为基数。

package stackandqueue;

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        //1. 创建一个栈st；
        Stack<Integer> st = new Stack<>();
        //2. Object push(Object element)
        showpush(st,12);
        showpush(st,45);
        showpush(st,90);
        //3. peek()查看栈顶的对象，不从栈中移除它；
        int p1 = st.peek();
        System.out.println("此时栈顶元素：" + p1);
        //4. pop() 移除栈顶对象，返回该对象的值；
        System.out.println("pop出一个元素出去" + st.pop());
        int p2 = st.peek();
        System.out.println("此时栈顶元素：" + p2);

        //5. empty() 是否为空
        if (!st.empty()) {
            System.out.println("当前栈不为空");
        } else {
            System.out.println("当前栈为空");
        }
    }

    private static void showpush(Stack<Integer> st, int a) {
        st.push(a);
        System.out.println("push(" + a + ")");
        System.out.println("stack: " + st);
    }
}

/*
push(12)
stack: [12]
push(45)
stack: [12, 45]
push(90)
stack: [12, 45, 90]
此时栈顶元素：90
pop出一个元素出去90
此时栈顶元素：45
当前栈不为空
* */

queue

队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。
LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

offer，add 区别：

一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。
这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。

poll，remove 区别：

remove() 和 poll() 方法都是从队列中删除第一个元素。remove() 的行为与 Collection 接口的版本相似，但是新的 poll() 方法在用空集合调用时不是抛出异常，只是返回 null。因此新的方法更适合容易出现异常条件的情况。

peek，element区别：

element() 和 peek() 用于在队列的头部查询元素。与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null。

package stackandqueue;

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        // 1. offer()
        queue.offer(2);
        queue.offer(4);
        queue.offer(5);
        queue.offer(6);
        queue.offer(9);
        System.out.println("queue: " + queue);
        // 2. poll() 返回第一个元素，并在队列中删除
        System.out.println(queue.poll());
        System.out.println("删除队首元素，queue: " + queue);

        // 3. peek() 返回第一个元素
        System.out.println(queue.peek());

        // 4. element() 返回第一个元素
        System.out.println(queue.element());
        System.out.println("queue: " + queue);
    }
}
/*
queue: [2, 4, 5, 6, 9]
2
删除队首元素，queue: [4, 5, 6, 9]
4
4
queue: [4, 5, 6, 9]
* */

deque

允许两头都进，两头都出，这种队列叫双端队列（Double Ended Queue），学名Deque。
Deque实现了一个双端队列（Double Ended Queue），它可以：

将元素添加到队尾或队首：addLast()/offerLast()/addFirst()/offerFirst()；
从队首／队尾获取元素并删除：removeFirst()/pollFirst()/removeLast()/pollLast()；
从队首／队尾获取元素但不删除：getFirst()/peekFirst()/getLast()/peekLast()；
注意：
总是调用xxxFirst()/xxxLast()以便与Queue的方法区分开；
避免把null添加到队列。

代码：

package stackandqueue;

import java.util.Deque;
import java.util.LinkedList;

public class DequeTest {
    public static void main(String[] args) {
        Deque<String> dq = new LinkedList<>();
        //1. 将元素添加到队尾或队首：addLast()/offerLast()/addFirst()/offerFirst()；
        dq.addFirst("baidu");
        dq.offerFirst("alibaba");
        dq.addLast("ithome");
        dq.offerLast("benjamin");
        System.out.println("dq: " + dq); //dq: [alibaba, baidu, ithome, benjamin]
        System.out.println("dq当前的状态是：不为空（" + dq.isEmpty() + "）");
        //2. 从队首／队尾获取元素但不删除：getFirst()/peekFirst()/getLast()/peekLast()；
        System.out.println(dq.getFirst()); //alibaba
        System.out.println(dq.peekFirst()); //alibaba
        System.out.println(dq.getLast()); //benjamin
        System.out.println(dq.peekLast()); //benjamin
        //3. 从队首／队尾获取元素并删除：removeFirst()/pollFirst()/removeLast()/pollLast()；
        System.out.println(dq.removeFirst());
        System.out.println("dq: " + dq); //dq: [baidu, ithome, benjamin]

        System.out.println(dq.pollFirst());
        System.out.println("dq: " + dq); //dq: [ithome, benjamin]

        System.out.println(dq.removeLast());
        System.out.println("dq: " + dq); //dq: [ithome]

        System.out.println(dq.pollLast());
        System.out.println("dq: " + dq); //dq: []

        System.out.println("dq当前的状态是：为空（" + dq.isEmpty() + "）");

    }
}

利用deque实现stack

涉及到的方法：
栈方法等效方法
push(e) push()/addFirst(e)
pop() pop()/removeFirst()
peek() peek()/peekFirst()

参考代码：

package stackandqueue;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        //1. 创建一个栈st；
        Stack<Integer> st = new Stack<>();
        //2. Object push(Object element)
        showpush(st,12);
        showpush(st,45);
        showpush(st,90);
        //3. peek()查看栈顶的对象，不从栈中移除它；
        int p1 = st.peek();
        System.out.println("此时栈顶元素：" + p1);
        //4. pop() 移除栈顶对象，返回该对象的值；
        System.out.println("pop出一个元素出去" + st.pop());
        int p2 = st.peek();
        System.out.println("此时栈顶元素：" + p2);

        //5. empty() 是否为空
        if (!st.empty()) {
            System.out.println("当前栈不为空");
        } else {
            System.out.println("当前栈为空");
        }

        System.out.println("========利用deque实现========");
        // 利用deque实现
        Deque<Integer> st2 = new LinkedList<>();

        showpush2(st2,12);
        showpush2(st2,45);
        showpush2(st2,90);
        //3. peek()查看栈顶的对象，不从栈中移除它；
        int sp2 = st2.peek();
        System.out.println("此时栈顶元素：" + sp2);
        //4. pop() 移除栈顶对象，返回该对象的值；
        System.out.println("pop出一个元素出去" + st2.pop());
        int sp3 = st2.peek();
        System.out.println("此时栈顶元素：" + sp3);

        //5. empty() 是否为空
        if (!st2.isEmpty()) {
            System.out.println("当前栈不为空");
        } else {
            System.out.println("当前栈为空");
        }
    }

    private static void showpush(Stack<Integer> st, int a) {
        st.push(a);
        System.out.println("push(" + a + ")");
        System.out.println("stack: " + st);
    }

    private static void showpush2(Deque<Integer> st, int a) {
        st.push(a);
        System.out.println("push(" + a + ")");
        System.out.println("stack: " + st);
    }
}

/*
push(12)
stack: [12]
push(45)
stack: [12, 45]
push(90)
stack: [12, 45, 90]
此时栈顶元素：90
pop出一个元素出去90
此时栈顶元素：45
当前栈不为空
* */

/*
*
========利用deque实现========
push(12)
stack: [12]
push(45)
stack: [45, 12]
push(90)
stack: [90, 45, 12]
此时栈顶元素：90
pop出一个元素出去90
此时栈顶元素：45
当前栈不为空
* */

利用deque实现queue

涉及到的方法：
队列方法等效方法
add(e) addLast(e)
remove() removeFirst()
element() getFirst()