1.概述
Queue接口是Collection接口下的子接口
队列Queue是一种经常使用的集合,线性表结构,遵循先入先出、后入后出的基本原则,一般来说,它只允许在集合的前端进行删除操作,而在集合的后端进行插入操作。
所以,Queue实际上是实现了一个先进先出(FIFO:First In First Out)的有序集合。在Java集合框架中, 通过一个Queue接口来进行队列集合的定义,LinkedList集合或者ArrayBlockingQueue,它们都实现了Queue接口。所以,我们可以理解为 LinkedList或ArrayBlockingQueue就是具体的队列实现类。
Queue和List的区别在于,List可以在任意位置添加和删除元素,而Queue只有两个操作:
1.把元素添加到队列末尾
2.从队列头部取出元素
例如:超市的收银台就是一个队列
2.无界队列、有界队列、优先队列
队列按照容量界限不同,可以分为:有界队列、无界队列、优先队列。
有界队列:有界限,容量受限制,常见实现类ArrayBlockingQueue,当集合内元素超出容量界限时,会抛出java.lang.IllegalStateException: Queue full异常;
Queue<String> queue = new ArrayBlockingQueue<String>(5); // 容量为5
queue.add("A1");
queue.add("A2");
queue.add("A3");
queue.add("A4");
queue.add("A5");
queue.add("A6"); // 第6个元素添加时,会抛出异常
有界队列
public class Demo01 {
public static void main(String[] args) {
// 有界队列
ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
// queue.add("A1");
// queue.add("A2");
// queue.add("A3");
// queue.add("A4");
// queue.add("A5");
System.out.println(queue);
// queue.add("A6");//java.lang.IllegalStateException: Queue full
// 队列满抛异常
// 添加元素出现异常Queue full
// queue.offer("A6");// 添加元素,如果失败,则返回false
System.out.println(queue);
// 删除元素,删除失败抛出异常
// queue.remove();
// System.out.println(queue);
// 删除元素,删除失败返回值为null
// queue.poll();
// System.out.println(queue);
// 获取队头元素,不出队,如果获取失败则抛出异常
String elementString = queue.element();
System.out.println(elementString);
System.out.println(queue);
// 获取队头元素,不出队,如果获取失败则返回null
String peekString = queue.peek();
System.out.println(peekString);
System.out.println(queue);
// 遍历有界队列
while (!queue.isEmpty()) {
String item = queue.poll();
System.out.println(item);
}
}
}
无界队列:无界限,容量无限制,常见实现类LinkedList;
Queue<String> queue = new LinkedList<String>(); // 无需设置容量
queue.add("A1");
queue.add("A2");
queue.add("A3");
queue.add("A4");
queue.add("A5");
queue.add("A6");
// ... 添加元素,容量不受任何限制
无界队列
public class Demo02 {
public static void main(String[] args) {
// 无界队列
Queue<String> queue = new LinkedList<String>();
// 入队:添加元素到队列的尾部
queue.add("A1");
queue.offer("A2");
queue.offer("A3");
queue.offer("A4");
System.out.println("队列中存在的元素:" + queue);
// 取出队头元素并删除,失败会抛异常
// String removeString = queue.remove();
// System.out.println(removeString);
// System.out.println("队列中存在的元素:" + queue);
// 取出队头元素并删除,失败返回null
// String pollString = queue.poll();
// System.out.println(pollString);
// System.out.println("队列中存在的元素:" + queue);
// 取出队头元素但是不删除,失败会抛异常
// String elementString = queue.element();
// System.out.println(elementString);
// System.out.println("队列中存在的元素:" + queue);
// 取出队头元素但是不删除,失败返回null
String peekString = queue.peek();
System.out.println(peekString);
System.out.println("队列中存在的元素:" + queue);
}
}
优先队列
public class Demo03 {
public static void main(String[] args) {
// 优先队列
Queue<String> queue = new PriorityQueue<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int num1 = Integer.parseInt(o1.substring(1));
int num2 = Integer.parseInt(o2.substring(1));
return num1 - num2;
}
});
// 优先队列入队是无序的,队头存储的元素是队列中的最大值或最小值
queue.offer("S9");
queue.offer("S2");
queue.offer("S6");
queue.offer("S1");
queue.offer("S8");
queue.offer("S5");
System.out.println(queue);
while (!queue.isEmpty()) {
System.out.println(queue.remove());
}
}
}
3.常见方法
在 Java 的标准类库中,队列接口Queue定义了以下几个方法:
● int size():获取队列长度;
● boolean add(E)/boolean offer(E):添加元素到队尾;
● E remove()/E poll():获取队首元素并从队列中删除;
● E element()/E peek():获取队首元素但并不从队列中删除;
注意:添加、删除、获取队列元素的操作,总是有两个方法,这是因为在添加或获取元素失败时,这两个方法的行为是不同的。我们用一个表格总结如下:
throw Exception 返回false或null 添加元素到队尾
add(E e)
boolean offer(E e)
取队首元素并删除
E remove() E poll() 取队首元素但不删除
E element()
E peek()
3.1添加元素到队尾
假设我们有一个队列,对它做一个添加操作,如果调用add()方法,当添加失败时(可能超过了队列的容量),它会抛出异常:
Queue<String> q = ...
try {
q.add("Apple");
System.out.println("添加成功");
} catch(IllegalStateException e) {
System.out.println("添加失败");
}
如果我们调用offer()方法来添加元素,当添加失败时,它不会抛异常,而是返回false:
Queue<String> q = ...
if (q.offer("Apple")) {
System.out.println("添加成功");
} else {
System.out.println("添加失败");
}
3.2取队首元素并删除
当我们需要从Queue中取出队首元素时,如果当前Queue是一个空队列,调用remove()方法,它会抛出异常:
Queue<String> q = ...
try {
String s = q.remove();
System.out.println("获取成功");
} catch(IllegalStateException e) {
System.out.println("获取失败");
}
如果我们调用poll()方法来取出队首元素,当获取失败时,它不会抛异常,而是返回null:
Queue<String> q = ...
String s = q.poll();
if (s != null) {
System.out.println("获取成功");
} else {
System.out.println("获取失败");
}
因此,两套方法可以根据需要来选择使用。
注意:不要把null添加到队列中,否则poll()方法返回null时,很难确定是取到了null元素还是队列为空。
3.3poll( )和peek( )的区别
调用poll()方法,会获取队首元素,并且将获取到的队首元素从队列中删除:
public class Main {
public static void main(String[] args) {
Queue<String> q = new LinkedList<>();
// 添加3个元素到队列:
q.offer("apple");
q.offer("pear");
q.offer("banana");
// 从队列取出元素:
System.out.println(q.poll()); // apple
System.out.println(q.poll()); // pear
System.out.println(q.poll()); // banana
System.out.println(q.poll()); // null,因为队列是空的
}
}
调用peek()方法,因为获取队首元素时,并不会从队列中删除这个元素,所以可以反复获取:
public class Main {
public static void main(String[] args) {
Queue<String> q = new LinkedList<>();
// 添加3个元素到队列:
q.offer("apple");
q.offer("pear");
q.offer("banana");
// 队首永远都是apple,因为peek()不会删除它:
System.out.println(q.peek()); // apple
System.out.println(q.peek()); // apple
System.out.println(q.peek()); // apple
}
}
从上面的代码中,我们还可以发现,LinkedList既实现了List接口,又实现了Queue接口。所以,在使用的时候,如果我们把它当作List,就定义List的引用;如果我们把它当作Queue,就定义Queue的引用:始终按照面向抽象编程的原则编写代码,可以大大提高代码的质量。
// 这是一个List:
List<String> list = new LinkedList<>();
// 这是一个Queue:
Queue<String> queue = new LinkedList<>();
//有界队列
ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
// 无界队列
Queue<String> queue = new LinkedList<String>();
// 优先队列
Queue<String> queue = new PriorityQueue<String>(这里需要写Comparator匿名内部类来声明排序规则);
//例如:
Queue<String> queue = new PriorityQueue<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int num1 = Integer.parseInt(o1.substring(1));
int num2 = Integer.parseInt(o2.substring(1));
return num1 - num2;
}
});
3.4遍历队列
遍历队列时,通过poll()方法不断获取并删除队头元素,同时判断队列状态是否为空。注意:不能使用peek()方法,否则会造成死循环。
while(!queue.isEmpty()) {
String item = queue.poll();
System.out.println(item);
}
String item = null;
while(( item = queue.poll()) != null) {
System.out.println(item);
}
4.优先队列
public class Demo04 {
public static void main(String[] args) {
Queue<User> queue = new PriorityQueue<User>();
queue.offer(new User("爪爪", "A1"));
queue.offer(new User("图图", "V1"));
queue.offer(new User("大熊猫本猫", "V2"));
queue.offer(new User("漫画家王者", "V3"));
queue.offer(new User("奥利奥", "A2"));
queue.offer(new User("倦倦", "A4"));
queue.offer(new User("饼饼", "A3"));
while (!queue.isEmpty()) {
System.out.println(queue.poll());
}
}
}
public class User implements Comparable<User> {
private String name;
public String number;
public User(String name, String number) {
super();
this.name = name;
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public String toString() {
return "User [name=" + name + ", number=" + number + "]";
}
@Override
public int compareTo(User o) {
// 首字母相同
if (this.number.charAt(0) == o.number.charAt(0)) {
int num1 = Integer.parseInt(this.number.substring(1));
int num2 = Integer.parseInt(o.number.substring(1));
return num1 - num2;
}
// 首字母不同
if (this.number.charAt(0) == 'V') {
return -1;
} else if (this.number.charAt(0) == 'A') {
return 1;
} else {
return 0;
}
}
}