集合——Queue,Deque和Stack

最新推荐文章于 2024-07-12 22:29:10 发布

原创最新推荐文章于 2024-07-12 22:29:10 发布 · 368 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java学习笔记专栏收录该内容

6 篇文章

订阅专栏

本文介绍了Java中Queue、Deque和Stack的数据结构和使用。Queue是先进先出的队列，提供size()等方法，常见实现包括ArrayDeque、LinkedList等。PriorityQueue根据元素优先级出队。Deque是双端队列，可以两端进出，可以用于实现Stack。Stack后进先出，常用于方法调用栈模拟等场景。

Queue（队列接口）是一种先进先出（FIFO：First In First Out）的有序表，和List相比，List可以在任何位置添加删除元素，而Queue只能在队列末尾添加元素或者在队列头部取出元素；

在java的标准库中，Queue接口定义了以下几个方法：

获取队列长度：int size()

	boolean add(E)	boolean offer(E)
添加元素到队尾	`IllegalStateException` - 如果由于容量限制，此时无法添加该元素 `ClassCastException` - 如果指定元素的类阻止将其添加到此队列中 `NullPointerException` - 如果指定的元素为空，并且该队列不允许空元素 `IllegalArgumentException` - 如果此元素的某些属性阻止将其添加到此队列	`ClassCastException` - 如果指定元素的类阻止将其添加到此队列中 `NullPointerException` - 如果指定的元素为空，并且该队列不允许空元素 `IllegalArgumentException` - 如果此元素的某些属性阻止将其添加到此队列
	E remove()	E poll()
获取队首元素并从队列中删除	`NoSuchElementException` - 如果这个队列是空的	如果这个队列是空的，返回null
	E element()	E peek()
获取队首元素但并不删除	`NoSuchElementException` - 如果这个队列是空的	如果这个队列是空的，返回null

注意不要把null添加到队列中，否则poll()方法在返回null时，很难确定队列是空的，还是取到了null元素，具体参考jdk文档；

Queue的实现类

所有已知实现类：

AbstractQueue ， ArrayBlockingQueue ， ArrayDeque ， ConcurrentLinkedDeque ， ConcurrentLinkedQueue ， DelayQueue ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedList ， LinkedTransferQueue ， PriorityBlockingQueue ， PriorityQueue ， SynchronousQueue

LinkedList实现了List，Queue，Deque等其他接口，在使用的时候，总是用特定的接口来引用它，这是因为持有接口说明代码的抽象层次更高，而且接口本身定义的方法代表了特定的用途，这也是面向抽象编程的一个原则：尽量持有接口，而不是具体的实现类。

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

public class Demo01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Queue<String> que = new LinkedList<>();
		que.offer("apple");
		que.offer("pear");
		que.offer("banana");
		System.out.println(que.poll());
		System.out.println(que.peek());
		System.out.println(que.peek());
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
	}

}

/*运行结果
apple
pear
pear
pear
banana
null
*/

PriorityQueue

出队顺序和元素的优先级有关，要使用PriorityQueue，必须确定每个元素的优先级，这就涉及到比较排序，如果放入的是String类型的元素，那么会默认进行排序，因为放入PriorityQueue的元素必须实现Comparable接口，或者通过Comparator自定义排序算法，PriorityQueue会根据元素的排列顺序确定出队的优先级；

import java.util.PriorityQueue;
import java.util.Queue;

public class Demo01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Queue<String> que = new PriorityQueue<>();
		que.offer("apple");
		que.offer("pear");
		que.offer("banana");
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
	}

}
/*运行结果
apple
banana
pear
null
*/

import java.util.PriorityQueue;
import java.util.Queue;

public class Demo01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Queue<User> que = new PriorityQueue<>();
		que.offer(new User("Bob","A2"));
		que.offer(new User("Boss1","V1"));
		que.offer(new User("Alice","A1"));
		que.offer(new User("Boss2","V2"));
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
        System.out.println(que.poll());
	}

}

class User implements Comparable<User>{
	
	final String name;
	final String number;
	
	User(String name, String number){
		this.name = name;
		this.number = number;
	}
	
	public String toString() {
		return name+"/"+number;
	}

	@Override
	public int compareTo(User o) {
		if(this.number.charAt(0) == o.number.charAt(0)) {
			return this.number.compareTo(o.number);
		}
		else if(this.number.charAt(0)== 'V') {
			return -1;
		}else {
			return 1;
		}
	}
	
}
/*运行结果
Boss1/V1
Boss2/V2
Alice/A1
Bob/A2
null
*/

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Demo01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Queue<User> que = new PriorityQueue<>(new UserComparator());
		que.offer(new User("Bob","A2"));
		que.offer(new User("Boss1","V1"));
		que.offer(new User("Alice","A1"));
		que.offer(new User("Boss2","V2"));
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
		System.out.println(que.poll());
	}

}

class User{
	
	final String name;
	final String number;
	
	User(String name, String number){
		this.name = name;
		this.number = number;
	}
	
	public String toString() {
		return name+"/"+number;
	}
	
}

class UserComparator implements Comparator<User>{

	@Override
	public int compare(User o1, User o2) {
		// TODO 自动生成的方法存根
		if(o1.number.charAt(0) == o2.number.charAt(0)) {
			return o1.number.compareTo(o2.number);
		}
		else if(o1.number.charAt(0) == 'V') {
			return -1;
		}
		else {
			return 1;
		}
	}
	
}

Deque

允许两端进，两端出的双端队列（Double Ended Queue）：

既可以添加元素到队尾，也可以添加元素到队首
既可以从队首获取元素，也可以从队尾获取元素

实际上Deque接口继承了Queue接口：

public interface Deque<E> extends Queue<E>{

...

}

比较一下Queue和Deque出队和入队的方法：

虽然Deque可以调用offer()方法添加元素到队尾，但是还是推荐明确调用offerLast()方法，这样更加明确，其他方法同样如此。

Stack

栈（Stack）是一种后进先出（LIFO：Last In First Out）的数据结构，如果把队列的一端封死，只能不断的往Stack中压入（push）元素，最后进去的必须最早弹出来（pop）；

Stack只有入栈和出栈的操作：

元素入栈：E push(E item)

栈顶元素弹出：E pop()

取栈顶元素但并不弹出：E peek()

因为java有个遗留类的名字叫Stack，所以只能用Deque来模拟一个Stack, Deque接口及其实现提供了更完整和一致的LIFO堆栈操作集：

Deque<Integer> stack = new ArrayDeque<Integer>();

Stack在计算机中应用广泛：

JVM在处理java方法调用的时候就会通过栈这种数据结构维护方法调用的层次：

创建方法调用栈
每调用一个方法，将参数入栈，执行相应的方法
当方法返回时，返回值入栈，调用方法通过出栈操作获得方法返回值

对整数进行进制的转换就可以利用栈

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

public class MapStudy {
	public static void main(String[] args) {
		String hex = toHex(12500);
		System.out.println(hex);
	}
	
	static String toHex(int n) {
		Deque<Character> buff = new ArrayDeque<>();
		for(int i=n;i!=0;i=i/16) {
			int remainder = i%16;
			int ch;
			if(remainder>=10) {
				ch = 65+(remainder-10);
			}else {
				ch = 48+remainder;
			}
			buff.push(Character.valueOf((char)ch));
		}
		StringBuilder result = new StringBuilder(buff.size());
		while(buff.peek()!=null) {
			result.append(buff.pop());
		}
		return result.toString();
	}
}

上述代码，需要将十进制整数12500转换成十六进制，计算方法是：