Java SE核心API（6） —— 队列、栈、查找表

版权声明：本文为博主原创文章，遵循GPL开源协议精神，转载请注明出处。 https://blog.csdn.net/Robot__Man/article/details/79276049

一、队列

　　队列（Queue）是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。
　　队列遵循先进先出（FIFO First Input First Output）的原则。
　　JDK中提供了Queue接口，同时使得LinkedList实现了该接口（选择LinkedList实现Queue的原因在于Queue经常要进行添加和删除的操作，而LinkedList在这方面效率较高。）
　　Queue接口中主要方法如下：
　　boolean offer(E e); —— 将一个对象添加至队尾，如果添加成功则返回true。
　　E poll(); —— 从队首删除并返回一个元素。
　　E peek(); —— 返回队首的元素（但并不删除）。

package day05;

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

/**
 * 队列
 * 队列也可以存放一组元素，但是存取元素必须遵循：先进先出原则。
 * @author xxx
 */
public class QueueDemo {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>(); 

        /*
         *boolean offer(E e)
         *入队操作，向队尾追加一个新元素。
         */
        queue.offer("one");
        queue.offer("two");
        queue.offer("three");
        queue.offer("four");
        System.out.println(queue);

        /*
         * E poll()
         * 出队操作，从队首获取元素，获取后该元素就从队列中被删除了。
         */
        String str = queue.poll();
        System.out.println(str);
        System.out.println(queue);

        /*
         * E peek()
         * 引用队首元素，但是不做出队操作
         */
        str = queue.peek();
        System.out.println(str);
        System.out.println(queue);

        /*
         * 注意：queue.size()是会变的，随着取出的元素的个数越来越多，size的值会越来越小。
         * 所以，这里要倒着遍历，正着的话则不会遍历完。
         */
        /*for (int i = queue.size();i > 0;i--) {
            str = queue.poll();
            System.out.println("元素："+str);
        }*/

        while (queue.size() > 0) {
            str = queue.poll();
            System.out.println("元素："+str);
        }
    }
}

---

二、栈

　　Deque是Queue的子接口，定义了所谓“双端队列”，即从队列的两端分别可以入队（offer）和出队（poll），LinkedList实现了该接口。
　　如果将Deque限制为只能从一端入队和出队，则可实现“栈”（stack）的数据结构，对于栈而言，入栈称之为push，出栈称之为pop。
　　栈遵循先进后出（FILO First Input Last Output）的原则。

package day05;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 栈，存储一组元素，但是存取元素必须遵循先进后出原则。
 * 通常为了实现后退这类功能时会使用栈。
 * @author xxx
 *
 */
public class StackDemo {
    public static void main(String[] args) {
        Deque<String> stack = new LinkedList<String>();

        /*
         * void push(E e)
         * 入栈操作，最后入栈的元素在栈顶（第一个元素的位置）
         */
        stack.push("one");
        stack.push("two");
        stack.push("three");
        stack.push("four");
        System.out.println(stack);

        /*
         * 出栈操作
         * E pop()
         */
        String str = stack.pop();
        System.out.println(str);
        System.out.println(stack);

        str = stack.peek();
        System.out.println(str);
        System.out.println(stack);

        while (stack.size() > 0) {
            str = stack.pop();
            System.out.println(str);
        }
        System.out.println(stack);
    }
}

---

三、查找表

　　Map接口定义的集合又称查找表，用于存储所谓“Key-Value”映射对。Key可以看成是Value的索引，作为Key的对象在集合中不可以重复。
　　根据内部数据结构的不同，Map接口有多种实现类，其中常用的有内部为hash表实现的HashMap和内部为排序二叉树实现的TreeMap。

2.1、Map的基本操作

package day05;

import java.util.HashMap;
import java.util.Map;

/**
 * java.util.Map
 * Map看起来像是一个多行两列的表格。以key-value对的形式存放元素。
 * 在Map中key不允许重复（重复是依靠key的equals判断）
 * 常用的实现类为：HashMap
 * @author xxx
 *
 */
public class MapDemo1 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

        /*
         * V put(K k,V v)
         * 将给定的key-value对存入Map。
         * 由于Map要求key不允许重复，所以使用Map已有的key存入一个新的value时的操作是
         * 替换value，那么返回值为该key原来对应的value。若是一个新的key，则返回值为null。
         */
        Integer value = map.put("语文", 99);
        System.out.println("old:"+value);
        map.put("数学", 99);
        map.put("英语", 90);
        map.put("物理", 98);
        map.put("化学", 96);

        value = map.put("语文", 98);
        System.out.println(map);
        System.out.println("old:"+value);

        /*
         * V get(K k)
         * 根据给定的key获取对应的value，若当前Map中没有
         * 给定的key，则返回值为null。
         */
        value = map.get("数学");
        System.out.println("数学："+value);
        value = map.get("体育");
        System.out.println("体育："+value);

        /*
         * V remove(K k)
         * 删除给定的key所对应的key-value对。
         * 返回值为被删除的key-value对中的value值。
         */
        System.out.println("删除数学");
        value = map.remove("数学");
        System.out.println(map);
        System.out.println("old:"+value);
    }
}

　　Map接口中定义了判断某个key是否在Map中存在的方法：boolean containsKey(Object key)。若Map中包含给定的key则返回true，否则返回false。

2.2、Map的遍历

package day05;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 遍历Map
 * 遍历Map有三种方式：
 * 遍历所有的key
 * 遍历所有的key-value对
 * 遍历所有的value（相对不常用）
 * @author xxx
 *
 */
public class MapDemo2 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("语文", 99);
        map.put("数学", 98);
        map.put("英语", 96);
        map.put("物理", 95);
        map.put("化学", 92);
        System.out.println(map);

        /*
         * 遍历所有的key
         * Set<K> keyset()
         * 该方法会将当前Map中所有的key存入一个Set集合后返回。那么遍历该集合就等于遍历
         * 了所有的key
         */
        Set<String> keySet = map.keySet();
        for (String key:keySet) {
            System.out.println("key:"+key);
        }

        /*
         * 遍历每一组键值对
         * Map中每一组键值对都是由Map的内部类：
         * java.util.Map.Entry的一个实例表示的。
         * Entry有两个方法：getKey,getValue,可以分别获取这一组键值对中的key与value。
         * 
         * Set<Entry> entrySet
         * 该方法会将Map中每一组键值对（Entry实例）
         * 存入一个Set集合后返回。
         */
        Set<Entry<String,Integer>> entrySet = map.entrySet();
        for (Entry<String,Integer> e:entrySet) {
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key+":"+value);
        }

        /*
         * 遍历所有的value
         * Collection values()
         * 该方法会将当前Map中所有的value存入一个集合后返回。
         */
        Collection<Integer> values = map.values();
        for (Integer value:values) {
            System.out.println("value:"+value);
        }
    }
}

2.3、equals方法和hashcode方法的重写

　　一般情况下，可以用Eclipse自动生成equals方法和hashcode方法的重写。

package day05;
/**
 * 当一个类的实例作为HashMap的key时，它的equals方法与hashcode方法的重写
 * 直接影响着散列表（HashMap）的查询性能。
 * 在API文档中Object对这两个方法的重写做了说明：
 * 当我们重写一个类的equals方法时，就应当连同重写hashcode方法。
 * 这两个方法重写应当遵循：
 * 1、一致性，当两个对象equals比较为true时，hashcode方法返回的数字必须相等。反过来虽然不是必须的，
 * 但也应当遵循，否则在hashMap中会形成链表影响查询性能。所以两个对象hashcode值相同，equals比较
 * 也应当为true。
 * 2、稳定性：hashcode方法多次调用后返回的数字应当相同，不应是一个变化的值，除非参与equals比较的属性值发生了改变。
 * @author xxx
 *
 */
public class Key {
    private int x;
    private int y;

    public Key(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Key other = (Key) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }
}

2.4、装载因子及HashMap优化

• Capacity：容量，hash表里bucket（桶）的数量，也就是散列数组的大小。
• Initial capacity：初始容量，创建hash表时，初始bucket的数量，默认构建容量是16，也可以使用特定容量。
• Size：大小，当前散列表中存储数据的数量。
• Load factor：加载因子，默认值0.75（就是75%），当向散列表增加数据时如果size/capacity的值大于Load factor则发生扩容并且重新散列（rehash）。
• 性能优化：加载因子较小时，散列查找性能会提高，同时也浪费了散列桶空间容量。0.75是性能和空间相对平衡结果。在创建散列表时指定合理容量，减少rehash提高性能。