Java集合之Map

一、常用实现类结构

• Map：双列数据：存储key-value键值对的数据
  • HashMap: 在作为Map的主要实现类：线程不安全，效率高；存储null的key和value
    • LinkedMap：保证在遍历map元素时，可以照添加的顺序实现遍历。
      • 原因：在原来的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行的效率高于HashMap。
    • TreeMap: 保证照添加的key-value 对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序，底层使用红黑树
    • Hashtable：作为古老实现类，线程是安全的，效率低；不能存储null的key和value
      • properties:常用类处理配置文件。key 和 value 都是 String 类型
• HashMap的底层：
  • 数组 + 链表 （JDK 7.0及之前）
  • 数组 + 链表 + 红黑树 （JDK 8.0）

二、存储结构的理解

1. Map中key：无序的、不可重复的，使用Set存储的key —》 key 所在的类要重写equals() 和 hashCode() () （以HashMap为例)
2. Map 中的value：无序的、可重复的，使用collection存储所在的类要重写equals()
3. 一个键值对：key - value构成一个Entry对象。
4. Map中的entry：无序的、不可重复的，使用Set存储所在的entry

图示：

三、常用方法

方法	描述
put(Object key, Object value)	添加
remove(Object key)	删除
put(Object key, Object value)	修改
get(Object key)	查询
size()	长度
keySet()/value()/entrySet()	遍历

① keySet()

public void test1(){
        /**
         *  Set keySet()：返回所有key构成的Set集合
         */
        HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        // Set keySet():返回所有的key构成的Set集合
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
}

② value()

 @Test
    public void test2(){
        /**
         * Collection values()：返回所有value构成的Collection集合
         */
        HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        Collection values = map.values();
        Iterator iterator = values.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
}

③ entrySet()

@Test
    public void test3(){
        /**
         * Set entrySet()：返回所有key-value对构成的Set集合
         */
        HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            Map.Entry entry = (Map.Entry) next;
            System.out.println(entry.getKey()+"-->"+entry.getValue());
        }
}

四、内存结构说明

1、HashMap 在JDK 7.0 中实现的原理

HashMap map = new HashMap();
	在实例化以后，底层创建了长度为16的一维数组Entry[] table.
	....可能已经执行多次put...
    map.put(key1， value1);
	首先，调用Key所在类的HashCode()计算Key1的哈希值，此哈希值经过某种算法计算以后，得到entry数组中的存放位置。
    如果此位置上的数据为空，此时Key1-value1添加成功。 -->   情况1
    如果位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表的形式存在））,比较Key1和已经存在的一个或多个的哈希值：
       ① 如果key1的哈希值与已经存在的数据的哈希值不相同，此时key1-value1添加成功。 --> 情况2
       ② 如果Key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(Key2)方法比较：
        	①如果equlas()返回false：此时key1-value1添加成功。-->情况3
        	②如果equals()返回true：使用value1替换value2.

补充：

• 关于情况2 和情况 3：此时key1-value1 和 原来的数据以链表的方式存储
• 在不断的添加过程中，会涉及的问题，当超出临界值（且要存放的位置非空）时，扩容。
• 默认的扩容方式：扩容为原来的2倍，并将原来的数组复制过来。

2、HashMap在JDK 8.0中的实现原理

HashMap在Jdk8中相较于jdk7在底层实现方面不同：

​ ① new HashMap(); 底层没创建一个长度为16的数组

​ ② jdk 8 底层数组是：Node[ ]， 而非Entry[ ]

​ ③ 首次调用put() 方法时，底层创建长度为16的数组

​ ④ jdk 7 底层结构是： 数组加链表。 jdk 8中底层结构： 数组 + 链表 + 红黑树。

​ <1> 当形成链表时，七上八下（jdk7: 新的元素指向旧的元素。jdk8: 旧的元素指向新的元素）

​ <2> 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前元素数组的长度 > 64 时，此时此索引位置上的所有数据改为使用红黑树存储。

3、HashMap底层典型属性说明

方法	描述
DEFAULT_INITIAL_CAPACITY	HashMap的默认容量，16
DEFAULT_LOAD_FACTOR	HashMap的默认加载因子：0.75
threshold	扩容的临界值，=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD	Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY	桶中的Node被树化时最小的hash表容量:64

4、LinkedHashMap的底层实现原理

​ LinkedMap底层使用的结构是与HashMap相同，因为LinkHashMap继承HashMap

​ 区别在于：LinkHashMap内部提供了Entry，替换HashMap中的Node

五、TreeMap的使用

​ 向TreeMap中添加key-value,要求key必须是由一个类创建的对象，因为要照key进行排序：自然排序、定制排序。

① 自然排序

public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                name.equals(user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User) o;
            if(this.name.equals(user.name)){
                return this.age - user.age;
            }
            return this.name.compareTo(user.name);
        }
        throw new RuntimeException("输入的值无法判断");
    }
}

	@Test
    public void test(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,78);
        map.put(u3,90);
        map.put(u4,67);

        // 元示图遍历
        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            Object next = iterator.next();
            Map.Entry e = (Map.Entry) next;
            System.out.println(e.getKey()+"-----"+e.getValue());
        }
    }

② 定制排序

 @Test
    public void test2(){
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User user1 = (User) o1;
                    User user2 = (User) o2;
                    return user1.getAge() - user2.getAge();
                }
                throw new RuntimeException("输入的数值错误!!!!");
            }
        };

        TreeMap map = new TreeMap(comparator);
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,78);
        map.put(u3,90);
        map.put(u4,67);


        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            Object next = iterator.next();
            Map.Entry e = (Map.Entry) next;
            System.out.println(e.getKey() +"--->" + e.getValue());
        }
    }

六、使用Properties读取配置文件

创建jdbc.properties文件

name=OY
password=123456

//Properties:常用里处理配置文件.key和value都是String类类型
public static void main(String[] args) {
    FileInputStream fis = null;
    try {
        Properties pro = new Properties();
        fis = new FileInputStream("jdbc.properties");
        //加载流对应的文件
        pro.load(fis);
        String name = pro.getProperty("name");
        String password = pro.getProperty("password");
        System.out.println("name:"+name+"password"+password);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
    }
}