JAVA中栈（Stack）和队列的（Queue）应用

一、java.util.Stack 类

java.util.Stack 类继承自 Vector 类，因此它是一个同步的数据结构。下面是一些常用的 Stack 类的方法：

1. 构造方法:

   • Stack(): 创建一个空栈。

2. 基本操作:

   • void push(E item): 将一个元素压入栈顶。
   • E pop(): 移除栈顶元素并返回它。
   • E peek(): 返回栈顶元素但不移除它。
   • boolean isEmpty(): 判断栈是否为空。
   • int search(Object o): 返回对象在栈中的位置，从栈底开始计数，如果对象不在栈中，则返回负值。

3. 其他方法:

   • int size(): 返回栈中元素的数量。
   • String toString(): 返回栈的字符串表示。

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        
        stack.push("one");
        stack.push("two");
        stack.push("three");
        
        System.out.println("Top element: " + stack.peek()); // 输出 "three"
        System.out.println("Popped element: " + stack.pop()); // 输出 "three"
        System.out.println("New top element: " + stack.peek()); // 输出 "two"
        System.out.println("Stack size: " + stack.size()); // 输出 2
        
        while (!stack.empty()) {
            System.out.println(stack.pop());
        }
    }
}

 

二、java.util.Queue 接口

Queue 接口的主要方法包括：

1. 添加元素:

   • boolean add(E e): 添加指定元素到队列的尾部。如果队列满了，可能会抛出 IllegalStateException。
   • boolean offer(E e): 添加指定元素到队列的尾部。如果队列满了，返回 false 而不是抛出异常。

2. 移除元素:

   • E remove(): 移除并返回队列头部的元素。如果队列为空，可能会抛出 NoSuchElementException。
   • E poll(): 移除并返回队列头部的元素。如果队列为空，返回 null。

3. 访问元素:

   • E element(): 返回队列头部的元素，但不移除它。如果队列为空，可能会抛出 NoSuchElementException。
   • E peek(): 返回队列头部的元素，但不移除它。如果队列为空，返回 null。

4. 队列状态:

   • int size(): 返回队列中元素的数量。
   • boolean isEmpty(): 判断队列是否为空。
   • boolean contains(Object o): 判断队列是否包含指定元素。
   • Iterator<E> iterator(): 返回队列的迭代器。

补充说明： 

offer，add 区别：

一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。

这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。

poll，remove 区别：

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

peek，element区别：

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

实现类

Queue 接口的常见实现类包括 LinkedList, ArrayDeque, 和 PriorityQueue 等。

LinkedList

LinkedList 可以实现 Queue 接口，它是一个双向链表，可以高效地在两端添加和移除元素。

ArrayDeque

ArrayDeque 是一个基于数组的双端队列实现，它可以作为队列使用，并且在两端添加和移除元素都非常高效。

PriorityQueue

PriorityQueue 是一个基于优先堆的无界队列，它总是返回最小的元素（如果使用自然排序）或由 Comparator 定义的最小元素。

import java.util.Queue;
import java.util.ArrayDeque;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new ArrayDeque<>();

        // 添加元素
        queue.offer("one");
        queue.offer("two");
        queue.offer("three");

        // 查看队列头部元素
        System.out.println("Head element: " + queue.peek()); // 输出 "one"

        // 移除队列头部元素
        System.out.println("Removed element: " + queue.poll()); // 输出 "one"

        // 再次查看队列头部元素
        System.out.println("New head element: " + queue.peek()); // 输出 "two"

        // 遍历队列中的所有元素
        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }
}

 

 三、java.util.Deque 接口

Deque 是双端队列（Double Ended Queue）的缩写，它支持在其两端添加和删除元素。java.util.Deque 接口提供了一种灵活的方式来实现栈的功能。

1. 基本操作:

   • void addFirst(E e): 将指定元素插入此列表的前端。
   • void addLast(E e): 将指定元素插入此列表的末尾。
   • E removeFirst(): 移除此列表的第一个元素，并返回该元素。
   • E removeLast(): 移除此列表的最后一个元素，并返回该元素。
   • E getFirst(): 获取但不移除此列表的第一个元素。
   • E getLast(): 获取但不移除此列表的最后一个元素。
   • boolean isEmpty(): 返回此列表是否为空。
   • int size(): 返回此列表中的元素数量。

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        
        deque.addFirst("one");
        deque.addFirst("two");
        deque.addFirst("three");
        
        System.out.println("Top element: " + deque.getFirst()); // 输出 "three"
        System.out.println("Popped element: " + deque.removeFirst()); // 输出 "three"
        System.out.println("New top element: " + deque.getFirst()); // 输出 "two"
        System.out.println("Deque size: " + deque.size()); // 输出 2
        
        while (!deque.isEmpty()) {
            System.out.println(deque.removeFirst());
        }
    }
}