十一(二)、集合之Map

一、Map的实现类的结构

  Map:双列数据，存储key--value对的数据 -----类似于高中的函数 y = f(x)

使用Set存储所有的key，key所在的类要重写equals()和hashCode()的方法；（以HashMap为例说的）

  1、HashMap:

• 作为Map的主要实现类；线程不安全，可以存储null的key和value；

• HashMap的底层：数组+链表（jdk7及之前）

     数组+链表+红黑树（jdk8）

• 子类：LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历；

　　　a、原因是：在原有的hashmap底层结构基础上，添加了一堆指针，指向前一个和后一个元素

　　　b、对于频繁的遍历操作，此类执行效率更高；

测试代码：

@Test
    public void test() {
        Map hashMap = new HashMap();
        hashMap.put(null, null);
        hashMap.put(123, "AA");
        hashMap.put(456, "BB");
        hashMap.put(789, "CC");
        System.out.println(hashMap);
        
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        linkedHashMap.put(null, null);
        linkedHashMap.put(123, "AA");
        linkedHashMap.put(456, "BB");
        linkedHashMap.put(789, "CC");
        System.out.println(linkedHashMap);
        
        Hashtable hashtable = new Hashtable();
//        hashtable.put(null, null);//会报错哦
        
    }

这里的

System.out.println(hashMap)，无序输出；

System.out.println(linkedHashMap);按插入属性输出

  2、TreeMap：

• 保证按照添加的key value 对进行排序，实现排序遍历；（需要向tree添加 key-value ,要求key必须是同一个类的对象）
• 此时使用考虑key的自然排序和定制排序；
• 底层使用红黑树；

  3、Hashtable：

• 作为古老的实现类；线程安全;不可以存储null的key和value；
• 子类：Properties:常用来处理配置文件； key&value 都是Strin

  4.思维导图：

  脑图查看地址https://www.cnblogs.com/lixiuming521125/p/14626222.html

回到顶部

二、Map结构的理解

  1、Map中的key:无序的、不可重复的：

　　　　使用Set存储所有的key，key所在的类要重写equals()和hashCode()的方法；（以HashMap为例说的）

  2、Map中的value:无序的可重复的；

  　　使用Collection存储所有值；所在类需要重写equals()方法；

  3、一个key-value 构成了一个Entry对象

  4、Map中的Entry：无序的、不可重复的，使用Set存储所有的entry；

  

回到顶部

三、HashMap底层实现原理：（以jdk7说明）

1、实现原理：

 HashMap map = new HashMap();//在实例化以后，底层创建了长度为16的一维数组Entry[] table；

  ...//可能已经指向过多次put

  map.put(key1,value1);

  首先：调用key1所在类的hashCode()计算key1的哈希值；此哈希值经过某种算法计算后，得到在Entry数组中的存放位置；

  　　如果此位置上的数据为空；此时key1,value1的添加成功；--------情况1

  　　如果此位置上的数据不为空，（意味着此位置存在或一个或多个数据（以链表形式存在））

  　　　　比较key1和已经存在的一个或者多个数据的哈希值

  　　　　 如果key1和已经存在的一个或多个数据的哈希值不同，则此时key1,value1的添加成功；--------情况2

  　　　　 如果key1和已经存在的某个数据(key2-value2)的哈希值相同，则调用key1所在类的equals方法，

  若果返回true，则value1替换

  若返回false，则key1,value1的添加成功；--------情况3

  对于添加成功的情况2和情况3而言，key1-value1与已经存在指定位置上索引位置上数据以链表形式存储；

  

  在不断添加的过程中，会涉及到扩容问题；默认的扩容方式：当超出临界值且存放位置不为空，扩容为原来容量的2倍，并且将原来的数据复制过来；

  

  jdk8,相较于jdk7;

  1.new HashMap()底层没有创建一个长度为16的数组

  2.jdk8底层的数组是：Node[] 而非Entry[];

  3.首次调用put方法，底层创建长度为16的数组；

  4.jdk7底层结构只有：数组+链表，jdk8中底层结构：数组+链表+红黑树

  当数组的某一个索引位置上的元素以及链表形式存在的数据个数》8且当数组的长度>64时，

  此索引位置上的说有数据改为红黑树存储；

  2、各常量说明：

•   DEFAULT_INITIAL_CAPACITY:HashMap的默认容量16；
•   DEFAULT_LOAD_FACTOR;HashMap默认的加载因子：0.75
•   threshold:扩容的临界值：DEFAULT_LOAD_FACTORDEFAULT_INITIAL_CAPACITY  0.7516 = 12
•   TREEIFY_THRESHOLD:桶中链表长度大于该默认值，转换为红黑树：8
•   MIN_TREEIFY_CAPACITY:桶中的node被树话最小的hash表容量：64

回到顶部

四、linkedHashMap的底层实现原理

• 对于频繁的添加查找元素，可以使用linkedHashMap;  
• 可以按插入顺序输出；

  源码中：没有put 方法，因为继承了HashMap；

  public class LinkedHashMap<K,V>

    extends HashMap<K,V>

    implements Map<K,V> 

    

所以这里的put还是HashMap的put方法

linkedHashMap重写了    newNode

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {

        LinkedHashMap.Entry<K,V> p =

            new LinkedHashMap.Entry<K,V>(hash, key, value, e);

        linkNodeLast(p);

        return p;

    }

 

  static class Entry<K,V> extends HashMap.Node<K,V> {

        Entry<K,V> before, after;//这里能够记录添加元素的先后顺序；

        Entry(int hash, K key, V value, Node<K,V> next) {

            super(hash, key, value, next);

        }

    }

  

回到顶部

五、Map的常用方法：

  1.添加 删除 修改操作

1.   Object put(Object key,Object value);将指定的key-value（添加、修改）到当前map对象中；
2.   void putAll(Map m),将m中所有的 key-value对放入当前map中
3.   Object remove(Object key),移除指定的key-value对，并返回value;
4.   void clear();清空当前map中的所有数据

  2、元素查询的操作

1.   Object get(Object key):获取指定key 对应的value
2.   boolean containsKey(Object key),是否包含指定的key
3.   boolean containsValue(Object value):是否包含指定的value；
4.   int size():返回map中key-value对的个数；
5.   boolean isEmpty():判断当前map是否为空；
6.   boolean equals(Object obj):判断当前map和参数对象obj是否相等 

  3.元素操作的方法：

1.   Set keySet();返回左右可以构成的Set集合
2.   Collection values();返回所有values构成的Collection集合；
3.   Set entrySet():随会所有key-value对构成的Set集合；

   总结常用方法：

•    添加:put(Object key,Object value)
•    删除：remove(Object key)
•    修改：put(Object key,Object value)
•    查询：get(Object key)
•    遍历：keySet();
•    长度 size()
•    遍历 

   key-value 的遍历：entrySet()的遍历 or keySet()+get(Object key)来遍历

   key的遍历：keySet()

   value的遍历：values();

这里需要注意的是values()是由Collection存放，如果想取出所有值，建议遍历，将每个ele add到List<Ele>中

常用方法测试：

/**
     *1.添加 删除 修改操作
     * Object put(Object key,Object value);将指定的key-value（添加、修改）到当前map对象中；
     * void putAll(Map m),将m中所有的 key-value对放入当前map中
     * Object remove(Object key),移除指定的key-value对，并返回value;
     * void clear();清空当前map中的所有数据 
     * 2、元素查询的操作
     * Object get(Object key):获取指定key 对应的value
     * boolean containsKey(Object key),是否包含指定的key
     * boolean containsValue(Object value):是否包含指定的value；
     * int size():返回map中key-value对的个数；
     * boolean isEmpty():判断当前map是否为空；
     * boolean equals(Object obj):判断当前map和参数对象obj是否相等；
     *  Set keySet();返回左右可以构成的Set集合
     * Collection values();返回所有values构成的Collection集合；
     * Set entrySet():随会所有key-value对构成的Set集合；
     * 
     */
    @Test
    public void test1() {
        Map hashMap = new HashMap();
        //Object put(Object key,Object value)来添加元素
        hashMap.put(null, null);
        hashMap.put(123, "AA");
        hashMap.put(456, "BB");
        hashMap.put(789, "CC");
        System.out.println("hashMap:"+hashMap);
        // void putAll(Map m),将m中所有的 key-value对放入当前map中
        Map newHashMap = new HashMap();
        newHashMap.putAll(hashMap);
        System.out.println("newHashMap:"+newHashMap);//所有hashMap中的数据放入了newHashMap中；
        
        System.out.println("newHashMap的equals方法:"+newHashMap.equals(hashMap));
        
        hashMap.remove(123);
        System.out.println("hashMap的remove方法:"+hashMap);
        
        hashMap.clear();//
        System.out.println("hashMap的clear方法:"+hashMap);//{},而不是null
        
        Object obj = newHashMap.get(123);
        System.out.println("newHashMap的get方法:"+obj);
        
        boolean flag1 = newHashMap.containsKey("AA");
        System.out.println("newHashMap的containsKey方法:"+flag1);
        
        boolean flag2 = newHashMap.containsValue("AA");
        System.out.println("newHashMap的containsValue方法:"+flag2);
        
        System.out.println("newHashMap的size方法:"+newHashMap.size());
        
        System.out.println("newHashMap的isEmpty方法:"+newHashMap.isEmpty());//就是判断size()是否为0
        
        System.out.println("newHashMap的keySet方法:"+newHashMap.keySet());
        //遍历所有的key
        Set keySet = newHashMap.keySet();
        Iterator iterator = keySet.iterator();
        while(iterator.hasNext()) {
            System.out.println("遍历所有的key:"+iterator.next());
        }
        
        System.out.println("newHashMap的values方法:"+newHashMap.values());
        //遍历所有的values
        Collection values = newHashMap.values();
        Iterator iterator2 = values.iterator();
        while(iterator2.hasNext()) {
            System.out.println("遍历所有的values:"+iterator2.next());
        }
        
        System.out.println("newHashMap的entrySet方法:"+newHashMap.entrySet());
        //遍历所有的entrySet
        Set entrySet = newHashMap.entrySet();
        Iterator iterator3 = entrySet.iterator();
        while(iterator3.hasNext()) {
            Entry entry = (Entry) iterator3.next();
            System.out.println(entry.getKey()+"--->"+entry.getValue());//输出键值对；
        }
        
        //输出键值对
        Set keySet1 = newHashMap.keySet();
        Iterator iterator4 = keySet.iterator();
        while(iterator4.hasNext()) {
            Object key = iterator4.next();
            System.out.println(key+"--->"+newHashMap.get(key));//输出键值对；
        }
        
    }

 

回到顶部

六、TreeMap中的排序：

1.    需要向tree添加 key-value ,要求key必须是同一个类的对象
2.    因为要按照key 排序（自然排序、定制排序）

测试代码：

//定制排序
    @Test
    public void test2() {
        Comparator com = new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                if(o1.getAge()-o2.getAge()>=0) {
                    return 1;
                }
                return -1;
            }
        };
        TreeMap treeMap = new TreeMap(com);
        treeMap.put( new Person("joy",30), new Object());
        treeMap.put(new Person("tom",31), new Object());
        treeMap.put(new Person("lucy",18), new Object());
        treeMap.comparator();
        Iterator iterator = treeMap.keySet().iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
    }
    
    //自然排序；
    @Test
    public void test3() {
        TreeMap treeMap = new TreeMap();
        treeMap.put( new Person("joy",30), new Object());
        treeMap.put(new Person("tom",31), new Object());
        treeMap.put(new Person("lucy",18), new Object());
        Iterator iterator = treeMap.keySet().iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
    }

附：

package collection;

public class Person implements Comparable {

    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;//这里使用31为了减少冲突、提高算法效率
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Object o) {
        Person person = (Person)o;
        if(this.age>person.age) {
            return -1;
        }else {
            return 1;
        }
        
    }
    
    
}

回到顶部

七、Properties

  Properties类是Hashtable的子类，该对象用于处理属性文件

•   由于属性文件里的key、value都是字符串类型，所以Properties中里的key和value都是字符串类型
•   存取数据时，建议使用 setProperty(String key,String value)和 getProperty(String key)

  测试代码：

//Properties用来处理配置文件，key和value都是字符串类型
    @Test
    public void test4() throws Exception {
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream(new File("testproperties.properties"));//文件：testproperties.properties
        prop.load(fis);//加载对应流文件
        String name = prop.getProperty("name");
        String value = prop.getProperty("password");
        System.out.println("name:"+name);
        System.out.println("value:"+value);
    }

name=tom
password=123456