Java35 队列Queue接口

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;
		}

	}

}