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 {
    }
}