Stack/Set/Map/Queue浅析

栈

“栈”通常是表示“后进先出”的容器。就好比在盘子里叠入披萨，最后放进去的总是在最上面。
ListkedList具有能直接实现栈的所有功能的方法，因此可以直接将LinkedList当作栈使用。
不过，有时候一个真正的“栈”更能把事情说明白：

import java.util.LinkedList;

public class Stack<T>{

private LinkedList<T> storage = new LinkedList<T>();
public void push(T v){
storage.addFirst(v);
}
public T peek(){
return storage.getFirst();
}
public T pop(){
return storage.removeFirst();
}
public boolean empty(){
return storage.isEmpty();
}
public String toString(){
return storage.toString();
}
}

这里使用泛型，引入了在栈的类定义中最简单的可行示例。T表示告诉编译器这是参数化的类型，实际类型会在使用时被替换。如果我们只需要栈的行为，那使用继承就不合适了，因为这样就会产生具有LinkedList的其他所有方法的类。

public static void main(String[] args) {
//创建具有泛型T的Stack类。并声明了T为String类型
Stack<String> stack = new Stack<String>();
for(String s : "My dog has fleas".split(" ")){
stack.push(s);
}
while (!stack.empty()) {
//pop()方法是移除栈顶元素，并且返回。
System.out.println(stack.pop() + " ");
}
}

Set

Set不保存重复元素。如果我们需要查询功能，那么用hashSet是很好的选择，因为它专门针对了查找进行优化。
Set和Collection有完全一样的接口。实际上Set就是Collection，只是行为不同。行为的不同是继承和多态的典型应用。Set是基于对象的值来确定归属的。

public static void main(String[] args) {
Random rand = new Random(47);
Set<Integer> intset = new HashSet<Integer>();
for(int i = 0; i < 10000; i++){
intset.add(rand.nextInt(30));
}
System.out.println(intset);
}
//out
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

在hashSet中插入了0-29的10000个随机数，但是实际结果只有0-29，并且是无序的。这里的无序指的是存入和取出的顺序不一致。因为考虑到速度原因，HashSet用到了散列。其顺序与TreeSet和LinkedHashSet都不同，因为他们的实现具有不同的元素存储方式。TreeSet将元素存储在红-黑树数据结构中，而HashSet是散列函数。LinkedHashSet也使用了散列，但是看起来它使用了链表来维护插入顺序。如果我们需要排序，可以用TreeSet来替换HashSet，默认安装字典排序，并且区分大小写。如果想用字母排序，可以向TreeSet构造器传入String.CASE_INSENTIVE_ORDER

public static void main(String[] args) {
String sort = "A B C J Y O M G M U O aa b c j y o m g m u o";
Set<String> words = new TreeSet<String>();
for(String s : sort.split(" ")){
words.add(s);
}
System.out.println("not set para:" + words);
Set<String> words2 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
for(String s : sort.split(" ")){
words2.add(s);
}
System.out.println("use set para:" + words2);
}
//out
not set para:[A, B, C, G, J, M, O, U, Y, a, b, c, g, j, m, o, u, y]
use set para:[A, aa, B, C, G, J, M, O, U, Y]

很明显String.CASE_INSENSITIVE_ORDER虽然是按照字符排序了，但是其实际含义是不区分大小写。也就是B和b只能在Set中存在一个了。

Map

将对象映射到其他对象的能力是一种解决编程问题的杀手锏。

public static void main(String[] args) {
Random rand = new Random(47);
Map<Integer, Integer> m = new HashMap<>();
for(int i = 0; i < 10000; i++){
int r = rand.nextInt(20);
Integer freq = m.get(r);
m.put(r, freq == null ? 1:freq+1);
}
System.out.println(m);
}
//out
{0=481, 1=502, 2=489, 3=508, 4=481, 5=503, 6=519, 7=471, 8=468, 9=549, 10=513, 11=531, 12=521, 13=506, 14=477, 15=497, 16=533, 17=509, 18=478, 19=464}

自动包装机制，将随机生成的int转换成了Integer类型，用生成的int类型去Map中找，是否有该key，如果没有会返回null，如果有则会返回对应的value值。为null的情况会赋值给freq为1，不为null就进行累加。在累加中，自动拆包又进行的操作，否则Integer不能进行累加的。

Map与数组和其他的Collection一样。可以很简单的扩展到多维结果，比如Map<Stirng,Map<Integer,String>>或者更复杂的数据结构。

//这句话表示，该变量petPeople的数据类型是Map,而Map中key是String，value是List。这个List的类型是未知但且继承String
public static Map<String,List<? extends String>> petPeople = new HashMap<>();
static{
petPeople.put("Dawn", Arrays.asList("Molly","Spot"));
petPeople.put("Kata", Arrays.asList("Shackleton","Elsie May","Margrett"));
petPeople.put("Marilyn", Arrays.asList("Louie aka Louis Snorkelstein Dupree",
"Stanford aka Srinky el Negro",
"Pinkola"));
petPeople.put("Luke", Arrays.asList("Fuzzy","Fizzy"));
petPeople.put("Isaac", Arrays.asList("Freckly"));
}
public static void main(String[] args) {
//keySet返回了所有key组成的Set
System.out.println("People: " + petPeople.keySet());
//values返回了所有对应的value，根据Set的默认排序
System.out.println("Pets: " + petPeople.values());
for (String string : petPeople.keySet()) {
System.out.println(string + " has:");
for (String s : petPeople.get(string)) {
System.out.println("   " + s);
}
}
}

Queue

队列是保持先进先出，和LinkedList相反。就像排队打饭一样，先排队的人，就能先打到饭，排除插队的情况。
队列在并发编程中特别重要，因为它们可以安全地将对象从一个任务传给另一个任务。
LinkedList提供了方法以支持队列的行为，并且它是想了Queue接口，因此LinkedList可以用做Queue的一种实现。通过将LinkedList向上转型为Queue。

public static void printQ(Queue queue){
while(queue.peek() != null){
System.out.print(queue.remove() + " ");
}
}
public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();
Random rand = new Random(47);
for (int i = 0; i < 10; i++) {
queue.offer(rand.nextInt(i+10));
}
printQ(queue);
}

offer()将一个元素插入到队列尾端。在将LinkedList转化为Queue后，LinkedList的方法会不能使用。当然我们可以将Queue又转成LinkedList。

PriorityQueue

PriorityQueue在Java SE5中被添加，是为了提供这种行为的一种自动实现。
当你在PriorityQueue上调用offer()方法来插入一个对象时，这个对象会在队列中被排序。默认的排序将使用对象在队列中的自然顺序，但是你可以通过提供自己的Comparator来修改这个顺序。PriorityQueue可以确保当你在调用Peel(),poll()和remove()时，获取的是最高优先级的元素。

public static void printQ(Queue queue){
while(queue.peek() != null){
System.out.print(queue.remove() + " ");
}
System.out.println();
}
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
Random rand = new Random(47);
for (int i = 0; i < 10; i++) {
//队列存值
priorityQueue.offer(rand.nextInt(i + 10));
}
//输出第一次删除被返回的值
PriorityQueueDemo.printQ(priorityQueue);
//构建ints的List容器。此种构建方式，不允许被add
List<Integer> ints = Arrays.asList(25,22,20,18,14,9,3,1,1,2,3,9,14,18,21,23,25);
//将此List给优先级队列
priorityQueue = new PriorityQueue<>(ints);
PriorityQueueDemo.printQ(priorityQueue);
priorityQueue = new PriorityQueue<>(ints.size(),Collections.reverseOrder());
priorityQueue.addAll(ints);
PriorityQueueDemo.printQ(priorityQueue);
}

由此可以看出，队列运行重复，数字小的优先级高（比字母高）。大写字母比小写字母优先级高。
Collections.reverseOrder()同样是在JAVA SE5中增加的反序Comparator。

下节会讲Collection和Iterator和Foreach和适配器方法惯用法