day11-Map接口、HashMap和LinkedHashMap底层实现原理、Map常用方法、TreeMap、Hashtable、Properties、Collections、Enumeration

1.Map接口

 

 Map 与 Collection 并列存在。用于保存具有 映射关系 的数据 :key-value

 Map 中的 key 和 value 都可以是任何引用类型的数据

 Map 中的 key 用 Set 来存放， 不允许重复 ，即同一个 Map 对象所对应的类，须重写hashCode() 和 equals() 方法

 常用 String 类作为 Map 的“键”

 key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value

 Map 接口的常用实现类： HashMap 、 TreeMap 、 LinkedHashMap 和Properties。其中， HashMap 是 Map 接口使用频率最高的实现类

 * 一、Map的实现类的结构：
 *  |----Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y = f(x)
 *         |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
 *              |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
 *                      原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
 *                      对于频繁的遍历操作，此类执行效率高于HashMap。
 *         |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
 *                      底层使用红黑树
 *         |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
 *              |----Properties:常用来处理配置文件。key和value都是String类型
 *
 *
 *      HashMap的底层：数组+链表  （jdk7及之前）
 *                    数组+链表+红黑树 （jdk 8）
 *
 *  面试题：
 *  1. HashMap的底层实现原理？
 *  2. HashMap 和 Hashtable的异同？
 *  3. CurrentHashMap 与 Hashtable的异同？（暂时不讲）
 *
 */
————————————————
版权声明：本文为优快云博主「lsqstudy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/PorkBird/article/details/113727330

  /**
   *  二、Map结构的理解：
   *    Map中的key:无序的、不可重复的，使用Set存储所有的key  ---> key所在的类要重写equals()和hashCode() （以HashMap为例）
   *    Map中的value:无序的、可重复的，使用Collection存储所有的value --->value所在的类要重写equals()
   *    一个键值对：key-value构成了一个Entry对象。
   *    Map中的entry:无序的、不可重复的，使用Set存储所有的entry
   *
   */   

---

2.HashMap

HashMap是 Map 接口使用频率最高的实现类。

 允许使用 null 键和 null 值，与 HashSet 一样，不保证映射的顺序。

 所有的key构成的集合是Set:无序的、不可重复的 。所以， key 所在的类要重写：equals()和 hashCode()

 所有的value构成的集合是Collection:无序的、可以重复的 。所以， value 所在的类要重写：equals()

 一个 key-value 构成一个 entry

 所有的entry构成的集合是Set:无序的、不可重复的

 HashMap 判断两个 key 相等的标准 是：两个 key 通过 equals() 方法返回 true ，hashCode 值也相等。

 HashMap 判断两个 value 相等的标准 是：两个 value 通过 equals() 方法返回 true 。

HashMap的底层实现原理：

JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)

JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

 

 

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
*/
 

6.4.1、HashMap在JDK7中的底层实现原理

6.4.2、HashMap在JDK8中的底层实现原理

6.7、LinkedHashMap的底层实现原理（了解） 

https://blog.youkuaiyun.com/PorkBird/article/details/113727330

6.8、Map中的常用方法 、链接同上

6.10、TreeMap两种添加方式的使用（自然排序、定制排序）

6.12、Hashtable

6.13、Properties处理属性文件

---

3.Collections--是collection、Map的工具类

 Collections 是一个操作 Set、List 和 Map 等集合的工具类

 Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

 排序操作 ： （均为 static 方法）

 reverse(List) ： 反转 List 中元素的顺序

 shuffle(List) ： 对 List 集合元素进行随机排序

 sort(List) ： 根据元素的自然顺序对指定 List 集合元素按升序排序

 sort(List ， Comparator) ： 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

 swap(List ， int ， int) ： 将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找、替换

 Object max(Collection) ： 根据元素的自然顺序，返回给定集合中的最大元素

 Object max(Collection ， Comparator) ： 根据 Comparator 指定的顺序，返回给定集合中的最大元素

 Object min(Collection)

 Object min(Collection ， Comparator)

 int frequency(Collection ， Object) ： 返回指定集合中指定元素的出现次数

 void copy(List dest,List src) ：将 src 中的内容复制到 dest 中

 boolean replaceAll(List list ， Object oldVal ， Object newVal) ： 使用新值替换List 对象的所有旧值

//排序操作：（均为static方法）
//  reverse(List)：反转 List 中元素的顺序
//  shuffle(List)：对 List 集合元素进行随机排序
//  sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
//  sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
//  swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
//
    @Test
    public void Test(){
        List list = new ArrayList();
        list.add(123);
        list.add(234);
        list.add(2);
        list.add(3);

        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        System.out.println("***************");
        Collections.sort(list, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Integer && o2 instanceof Integer){
                    Integer i1 = (Integer) o1;
                    Integer i2 = (Integer) o2;

                    return -Integer.compare(i1,i2);
                }else {
                    throw new RuntimeException("输入的类型不正确");
                }
            }
        });
        System.out.println(list);

        Collections.swap(list,1,2);
        System.out.println(list);
    }

    //查找、替换
//  Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
//  Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
//  Object min(Collection)
//  Object min(Collection，Comparator)
//  int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
//  void copy(List dest,List src)：将src中的内容复制到dest中
//  boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值
    @Test
    public void Test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(234);
        list.add(2);
        list.add(3);
        list.add(3);

        List list1 = new ArrayList();
        list1.add(999);

        Object obj = Collections.max(list);
        System.out.println(obj);
        obj = Collections.min(list);
        System.out.println(obj);
        System.out.println("*****************");

        System.out.println(Collections.frequency(list,3));

        Collections.copy(list,list1);
        System.out.println(list);

        Collections.replaceAll(list,3,88);
        System.out.println(list);
        System.out.println("++++++++++++++");

        /**
         * Collections 类中提供了多个 synchronizedXxx() 方法，
         * 该方法可使将指定集合包装成线程同步的集合，从而可以解决
         * 多线程并发访问集合时的线程安全问题
         */
        //返回的list2即为线程安全的List
        List list2 = Collections.synchronizedList(list);
        System.out.println(list2);
    }

 7.2、补充：Enumeration(了解！！！)

十三：集合_lsqstudy的博客-优快云博客