3分钟了解Java中Stack,Queue,Deque常用方法
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()
参考代码：
package stackandqueue;
import java.util.Deque;
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);
System.out.println("====使用deque使用queue===");
Deque<Integer> deque = new LinkedList<>();
deque.addLast(2);
deque.addLast(4);
deque.addLast(5);
deque.addLast(6);
deque.addLast(9);
System.out.println("deque实现的队列：" + deque);
System.out.println("删除队首元素：" + deque.pollFirst());
System.out.println("此时队列：" + deque);
System.out.println("获取当前队列的首元素：" + deque.peekFirst());
System.out.println("此时队列：" + deque);
System.out.println("判断此时队列是否为空：" + deque.isEmpty());
}
}
/*
queue: [2, 4, 5, 6, 9]
删除队首元素: 2
此时queue: [4, 5, 6, 9]
4
4
queue: [4, 5, 6, 9]
====使用deque使用queue===
deque实现的队列：[2, 4, 5, 6, 9]
删除队首元素：2
此时队列：[4, 5, 6, 9]
获取当前队列的首元素：4
此时队列：[4, 5, 6, 9]
判断此时队列是否为空：false
Process finished with exit code 0
* */
