Map，equals，hashCode，遍历Map，装载因子，HashMap，LinkedHashMap

//MapDemo-----------------------
package day081702;

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

/**
 * Map像多行2列的表格（key - value）
 *key不允许重复（指equals为true）
 */
public class MapDemo {

    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        /**
         *  V put(K k, V v)
         *  若key不存在，则添加新内容，返回null
         *  若key已存在，则替换value,返回被替换的value值
         */
        map.put("数学", 90);
        map.put("语文", 93);
        map.put("物理", 94);
        map.put("化学", 96);
        System.out.println(map.put("英语", 97));//null
        System.out.println(map.put("英语", 100));//97
        System.out.println(map);//{物理=94, 语文=93, 英语=100, 数学=90, 化学=96}
        /**
         * V get(K k)
         * 用key取得value
         * 若key不存在，获取值为null
         */
        System.out.println(map.get("语文"));//93
        System.out.println(map.get("历史"));//null
        /**
         * 尽量避免使用基本类型，因为会自动拆箱
         * 若get()返回null,久违引发空指针异常
         */
        Integer num = map.get("历史");
        //int num2 = num.intValue();
        //System.out.println(num2);//报错：  java.lang.NullPointerException
        System.out.println(num);//null

        /**
         * boolean containsKey(K k)
         * 判断是否含有给定的key
         * 是否含有根据equals判断
         */
        System.out.println(map.containsKey("数学"));
        System.out.println(map.containsValue(101));//判断是否含有给定的value
        /**
         * V remove(K k)
         * 删除元素，返回值为删除的value
         * 如果没有对应的key，则返回null
         */
        System.out.println(map);//{物理=94, 语文=93, 英语=100, 数学=90, 化学=96}
        num = map.remove("物理");
        System.out.println(num);//94
        System.out.println(map);//{语文=93, 英语=100, 数学=90, 化学=96}

    }

}
//Point------------------------------------
package day081702;
/**
 * 重写equals方法时应该同时重写hashCode方法
 * 重写规则：
 * 若两个equals方法比较为true，那么hashCode返回的数字必须相同
 * 反之则必须不同，但是也应该尽量避免，即：两个对象若equals比较结果为false，
 * 他们的hashCode方法返回值尽量不同，否则影响HashMap的性能
 * hashCode方法在当前对象内容没有发生改变的前提下对此调用当前返回相同的数字
 * 
 */
public class Point {
    private int x;
    private int y;

    public Point() {

    }

    public Point(int x, int y) {
        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 String toString() {
        return "Point [x=" + x + ", 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;
        Point other = (Point) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }


}
//MapDemo2（equals，hashCode）-------------------------------
package day081702;

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

/**
 * 使用HashMap时应注意：
 * 作为key有以下要求：
 * 1：首先当这个key重写了equals方法，
 * 那么重写hashCode的要求必须满足
 * 2:作为key的对象，不建议轻易改变
 * 
 * 备注：1、如果两个对象相同，那么它们的hashCode值一定要相同；2、如果两个对象的hashCode相同，它们并不一定相同 
 */
public class MapDemo2 {

    public static void main(String[] args) {
        Map<Point,Integer> map = new HashMap<Point,Integer>();
        Point p = new Point(1,2);
        map.put(p, 100);
        System.out.println(p.hashCode());//994
        System.out.println(map.hashCode());//902
        System.out.println(map.get(p));//取得value值100

        p.setX(2);

        System.out.println(p.hashCode());//1025
        System.out.println(map.hashCode());//1125
        System.out.println(map.get(p));//key已经改变，结果为null


        p.setX(1);//恢复x的值
        System.out.println(p.hashCode());//994
        System.out.println(map.hashCode());//902
        System.out.println(map.get(p));//取得value值100
    }

}
//遍历Map，装载因子，HashMap，LinkedHashMap---------------------------
package day081702;

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

public class MapDemo3 {

    public static void main(String[] args) {
        /**
         * Map初始容量为16
         * 数据量为总容量的四分之三最合适
         * 装载因子：假设知道要装75万条数据，可以事先指定容量为100万，以防止不停扩容
         * Map<Point,Integer> map = new HashMap<Point，Integer>(1000000);
         * 
         * LinkedHashMap保证顺序，但是一般使用HashMap很少关心顺序
         * Map<String,Integer> map = new LinkedHashMap<String，Integer>();
         */
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("数学", 90);
        map.put("语文", 99);
        map.put("物理", 85);
        map.put("化学", 78);
        map.put("英语", 92);
        map.put("体育", 65);
        map.put("生物", 78);
        /**
         * 遍历所有的key
         * Set<k> keySet()
         * 存入Set
         */
        Set<String> keySet = map.keySet();
        for(String str:keySet){
            System.out.print(" "+ str);
        }

        System.out.println();

        Iterator<String> it = keySet.iterator();
        while(it.hasNext()){
            System.out.print(" "+ it.next());
        }

        System.out.println();
        /**
         * 遍历键值对
         * Set<Entry> entrySet()
         * 该方法将每组key-value存入一个Entry实例中，
         * 并将这些Entry存入一个Set集合并返回
         * 我们只需要遍历该集合，拿到一个Entry实例
         * 并获取其中的key和value
         */
        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<Integer> values = map.values();
        for(Integer value : values){
            System.out.println(value);
        }
    }

}