java课堂笔记------Map,队列,栈

 * java.util.Map
 * Map看起来像是一个多行两列的表格
 * 每条记录分为两部分:key，value
 * 其中在一个Map中key是不允许重复的。(equals比较)
 *
 * 常用的实现类:java.util.HashMap(散列算法实现)
 * TreeMap(二叉树实现)

        Map<String,Integer> map
            = new HashMap<String,Integer>();

         * V put(K k,V v)
         * 将给定的key与value存入到Map中。
         * 由于Map中key不允许重复，所以会出现两种情况:
         * 1:存入的key在Map中还不存在，那么直接将这对
         *   key-value存入Map，返回值为NULL
         * 2:存入的key在Map中已经存在，那么会将对应的
         *   value替换原来这个key对应的value，并将被
         *   替换的value值返回。  

        map.put("语文", 98);
        map.put("数学", 97);
        map.put("英语", 95);
        map.put("物理", 92);
        map.put("化学", 96);

         * 存入顺序与内部顺序不一致
      map.put("化学", 99);

         * V get(K k)
         * 根据给定的key去获取对应的value
         * 若当前Map中不含有给定的key，则返回值为NULL
         Integer num = map.get("数学");

         * V remove(K k)
         * 将给定的key对应的这一对内容从Map中删除
         * 并将对应的value返回。
         num = map.remove("化学");
         System.out.println("删除的value:"+num);

         * boolean containsKey(K k)
         * 查看当前Map是否包含给定的key
         * 包含的判断是依据key的equals比较的结果
        boolean containsKey = map.containsKey("语文");

 * 遍历Map
 * 遍历Map有三种方式:
 * 1:遍历所有的key
 * 2:遍历每一组键值对
 * 3:遍历所有的value(相对不常用)

         * LinkedHashMap
         * 内部使用一个LinkedList维护顺序，可以做到
         * 遍历的时候与put的顺序一致。若不需要顺序，
         * 通常不使用该类。

         *  遍历所有的key:
         *  Set<K> keySet()
         *  该方法会将所有的key存入一个Set集合后返回，所以遍历该集合就相当于遍历到所有的key了
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println("key:"+key);
        }

         * 遍历每一组键值对
         * Set<Entry> entrySet()
         * Entry是Map的内部类，每一个实例表示一组键值对
         * 其中包含两个属性，key,value.
         * 将每一组键值对(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);
        }

         * Collection<V> values()
         * 将当前Map中所有的value值存入一个集合后返回

        Collection<Integer> values = map.values();
        for(Integer value : values){
            System.out.println("value:"+value);
        }

 * 该类用于练习重写equals与hashcode的注意事项
 * 当我们使用自定义类型的实例作为HashMap中key的值
 * 时，这个类的equals与hashcode的结果直接影响着
 * HashMap查询的效率
 * 要避免一件事的产生:
 * hashcode值一样，但是equals比较不为true!这会
 * 严重影响HashMap效率
 * JAVA API文档中对于两个方法的重写有着要求:
 * 当我们重写一个类的equals方法时就应当连同重写
 * hashcode方法。
 * 还应同时满足:
 * 当两个对象equals比较为true时，hashcode返回的
 * 值应当相等。反过来不强制，但最好也不同，否则影响
 * HashMap性能。
 * hashcode方法返回的应该是一个稳定的值，意思是说:
 * 当确定equals方法比较结果的属性值没有发生改变的
 * 前提下，多次调用hashcode方法返回的值应当相同。
 * 

public class Cell {
    private int row;
    private int col;
    public Cell(int row, int col) {
        super();
        this.row = row;
        this.col = col;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + col;
        result = prime * result + row;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Cell other = (Cell) obj;
        if (col != other.col)
            return false;
        if (row != other.row)
            return false;
        return true;
    }

}

 * 队列
 * 保存一组元素，但是对于存取有要求，必须遵循先进先出原则

        Queue<String> queue = new LinkedList<String>();

         * boolean offer(E e)
         * 向队列末尾追加一个元素
        queue.offer("one");
        queue.offer("two");
        queue.offer("three");
        queue.offer("four");

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

         * E peek()
         * 同样可以获取队首元素，但是与poll不同的是
         * 并不会将该元素从队列中删除。
        str = queue.peek();
        System.out.println(str);

 * 栈:存储一组元素，存取必须遵循先进后出原则
 * 通常用来实现具有"后退"功能的地方。

         * Deque是Queue的子接口。
         * 双端队列的特点是，队列的两端都可以进出元素。
         * 若我们只调用一侧的进出方法，就形成了栈结构

        Deque<String> stack = new LinkedList<String>();

         * void push(E e)
         * 将元素"压入"栈中，入栈操作。新入栈的元素
         * 会在栈顶(栈中第一个元素)

        stack.push("one");
        stack.push("two");
        stack.push("three");
        stack.push("four");

         * E pop()
         * 出栈操作，获取栈顶元素，获取后该元素
         * 就从栈中被删除了

        String str = stack.pop();
        System.out.println(str);

         * 同样可以使用peek引用栈顶元素，而不做出栈操作
        str = stack.peek();
        System.out.println(str);