Map接口实现类HashMap，Hashtable

1. HashMap底层机制
   1. 扩容机制[和HashSet相同]
   2. HashMap底层维护了Node类型的数组table，默认为null
   3. 当创建对象时，将加载因子(loadfactor)初始化为0.75.
   4. 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key和准备加入的key是否相等，如果相等，则直接替换val；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
   5. 第1次添加，则需要扩容table容量16，临界值（threshold）为12（16*0.75）
   6. 以后再扩容，则需要扩容table容量为原来的2倍（32），临界值为原来的2倍，即24，依次类推
   7. 在java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD（默认是8），并且table的大小>=MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树）
2. HashMap原码
   1. 注意各执行情况所走的代码不一样

      package com.jshedu.map_;
      
      import java.util.HashMap;
      
      /**
       * @author 韩顺平
       * @version 1.0
       */
      @SuppressWarnings({"all"})
      public class HashMapSource1 {
          public static void main(String[] args) {
              HashMap map = new HashMap();
              map.put("java", 10);//ok,debug会先进行装箱，
              //因为你加入了一个基本类型数10，
              /*
              public static Integer valueOf(int i) {
                  if (i >= IntegerCache.low && i <= IntegerCache.high)
                       return IntegerCache.cache[i + (-IntegerCache.low)];
                  return new Integer(i);
              }//装箱操作，返回包装类，基本数据类型的封装
               */
      
              map.put("php", 10);//ok
              map.put("java", 20);//替换value
      
              System.out.println("map=" + map);//
      
              /*老韩解读HashMap的源码+图解
              1. 执行构造器 new HashMap()
                 初始化加载因子 loadfactor = 0.75
                 HashMap$Node[] table = null
              2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)
                  public V put(K key, V value) {//K = "java" value = 10
                      return putVal(hash(key), key, value, false, true);
                  }
               3. 执行 putVal
               final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                         boolean evict) {
                      Node[] tab; Node p; int n, i;//辅助变量
                      //如果底层的table 数组为null, 或者 length =0 , 就扩容到16
                      if ((tab = table) == null || (n = tab.length) == 0)
                          n = (tab = resize()).length;
      
                      //取出hash值对应的table的索引位置的Node, 如果为null, 就直接把加入的k-v
                      //, 创建成一个 Node ,加入该位置即可
                      //扩容的时候是先创建一个Node数组，再遍历原先的数组将元素存入新数组，                
                      //newTab[e.hash&(newCap-1)]=e,所以存放索引的位置可能会改变
      
                      if ((p = tab[i = (n - 1) & hash]) == null)
                          tab[i] = newNode(hash, key, value, null);//
                      else {
                          Node e; K k;//辅助变量
                      // 如果table的索引位置的key的hash相同和新的key的hash值相同，
                       // 并 满足(table现有的结点的key和准备添加的  key  是同一个对象  || equals返回真)
                       // 就认为不能加入新的k-v
                          if (p.hash == hash &&
                              ((k = p.key) == key || (key != null && key.equals(k))))
                              e = p;
                          else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理
                              e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
                          else {
                              //如果找到的结点，后面是链表，就循环比较
                              for (int binCount = 0; ; ++binCount) {//死循环
                                  if ((e = p.next) == null) {//如果整个链表，没有和他相同,就加到该链表的最后
                                      p.next = newNode(hash, key, value, null);
                                      //加入后，判断当前链表的个数，是否已经到8个，到8个，后
                                      //就调用 treeifyBin 方法进行红黑树的转换
                                      if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                          treeifyBin(tab, hash);//树化
                                      break;
                                  }
                                  if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value
                                      ((k = e.key) == key || (key != null && key.equals(k))))
                                      break;
                                  p = e;
                              }
                          }
                          if (e != null) { // existing mapping for key
                              V oldValue = e.value;
                              if (!onlyIfAbsent || oldValue == null)
                                  e.value = value; //替换，key对应value
                              afterNodeAccess(e);
                              return oldValue;//如果从这出去是没有增加Node，只是把value更改了
                          }
                      }
                      ++modCount;//每增加一个Node ,就size++
                      if (++size > threshold[12-24-48])//如size > 临界值，就扩容
                          resize();//扩容函数
                      afterNodeInsertion(evict);
                      return null;
                  }
      
                    5. 关于树化(转成红黑树)
                    //如果table 为null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
                    //否则才会真正的树化 -> 剪枝
                    final void treeifyBin(Node[] tab, int hash) {
                      int n, index; Node e;
                      if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                          resize();
      
                  }
               */
      
      
          }
      }
      

      封装，table是否为空，返回同一个数组地址是否key值相同，相同替换value值。不同加在尾部，没有足够的空间扩容。

3. Map接口的实现类--Hashtable

   1. 存放的元素是键值对：即K-V

   2. Hashtable的键和值都不能为null，否则会抛出NullPointException

   3. hashTable使用方法基本上和HashMap一样

   4. hashTable是线程安全的（synchronized），hashMap是线程不安全的

   5. 底层有数组Hashtable$Entry[]初始化大小为11

   6. 临界值threshold 8=11*0.75

   7. 扩容：按照自己的扩容机制来进行即可addEntry（），rehash（），

4. Hashtable和HashMap对比

   1. 	版本	线程安全（同步）	效率	允许null键null值
      HashMap	1.2	不安全	高	可以
      Hashtable	1.0	安全	较低	不可以

5. java中Map方法为什么要装箱：HashMap 中的元素实际上是对象，一些常见的基本类型可以使它的包装类来代替。

6. Map接口实现类--Properties

   1. Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据

   2. 他的使用特点和Hashtable类型

   3. Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改。

   4. 说明：xxx.properties文件通常作为配置文件，这个知识点在IO流举例

   5. package com.hspedu.map_;
      
      import java.util.Properties;
      
      /**
       * @author 韩顺平
       * @version 1.0
       */
      @SuppressWarnings({"all"})
      public class Properties_ {
          public static void main(String[] args) {
      
              //老韩解读
              //1. Properties 继承  Hashtable
              //2. 可以通过 k-v 存放数据，当然key 和 value 不能为 null
              //增加
              Properties properties = new Properties();
              //properties.put(null, "abc");//抛出 空指针异常
              //properties.put("abc", null); //抛出 空指针异常
              properties.put("john", 100);//k-v
              properties.put("lucy", 100);
              properties.put("lic", 100);
              properties.put("lic", 88);//如果有相同的key ， value被替换
      
              System.out.println("properties=" + properties);
      
              //通过k 获取对应值
              System.out.println(properties.get("lic"));//88
      
              //删除
              properties.remove("lic");
              System.out.println("properties=" + properties);
      
              //修改
              properties.put("john", "约翰");
              System.out.println("properties=" + properties);
      
              
      
      
          }
      }
      

      Properties基本方法

7. 开发中如何选择集合实现类

   1. 先判断存储的类型（一组对象【单列】或一组键值对【双列】）

   2. 一组对象【单列】：Collection接口

      1. 允许重复：List（按照添加顺序）

         1. 增删多：LinkedList【底层维护了一个双向链表】

         2. 改查多：ArrayList【底层维护Object类型的可变数组】

      2. 不允许重复Set

         1. 无序：HashSet【底层是HashMap，维护了一个哈希表即（数组+链表+红黑树）】

         2. 排序：TreeSet【】

         3. 插入和取出顺序一致：LinkedHashSet，维护数组+双向链表

   3. 一组键值对【双列】：Map

      1. 键无序：HashMap【底层是：哈希表，jdk8：数组+链表+红黑树】

      2. 键排序：TreeMap

      3. 键插入和取出顺序一致：LinkedHashMap

      4. 读取文件：Properties

8. TreeSet

   1. package com.jshedu.Set_;
      
      import java.util.Comparator;
      import java.util.TreeSet;
      
      /**
       * @author 韩顺平
       * @version 1.0
       */
      @SuppressWarnings({"all"})
      public class TreeSet_ {
          public static void main(String[] args) {
      
              //老韩解读
              //1. 当我们使用无参构造器，创建TreeSet时，仍然是无序的
              //2. 老师希望添加的元素，按照字符串大小来排序
              //3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
              //   并指定排序规则
              //4. 简单看看源码
              //老韩解读
              /*
              1. 构造器把传入的比较器对象，赋给了 TreeSet的底层的 TreeMap的属性this.comparator
      
               public TreeMap(Comparator comparator) {
                      this.comparator = comparator;
                  }
               2. 在 调用 treeSet.add("tom"), 在底层会执行到
      
                   if (cpr != null) {//cpr 就是我们的匿名内部类(对象)
                      do {
                          parent = t;
                          //动态绑定到我们的匿名内部类(对象)compare
                          cmp = cpr.compare(key, t.key);
                          if (cmp < 0)
                              t = t.left;
                          else if (cmp > 0)
                              t = t.right;
                          else //如果相等，即返回0,这个Key就没有加入
                              return t.setValue(value);
                      } while (t != null);
                  }
               */
      
      //        TreeSet treeSet = new TreeSet();
              TreeSet treeSet = new TreeSet(new Comparator() {
                  @Override
                  public int compare(Object o1, Object o2) {
                      //下面 调用String的 compareTo方法进行字符串大小比较
      
                      //return ((String) o2).compareTo((String) o1);
                      //如果老韩要求加入的元素，按照长度大小排序
                      return ((String) o1).length() - ((String) o2).length();
                  }
              });
              //添加数据.
              treeSet.add("jack");
              treeSet.add("tom");//3
              treeSet.add("sp");
              treeSet.add("a");
              treeSet.add("abc");//3，abc就不会加入了因为你设置的规则
              //按照长度大小排序,长度相等就相当于相同的元素，tom也是3
      
      
              System.out.println("treeSet=" + treeSet);
      
      
      
      
          }
      }
      

      顺序需要程序员自己设定

9. TreeMap

   package com.jshedu.map_;
   
   import java.util.Comparator;
   import java.util.TreeMap;
   
   /**
    * @author 韩顺平
    * @version 1.0
    */
   @SuppressWarnings({"all"})
   public class TreeMap_ {
       public static void main(String[] args) {
   
           //使用默认的构造器，创建TreeMap, 是无序的(也没有排序)
           /*
               老韩要求：按照传入的 k(String) 的大小进行排序
            */
   //        TreeMap treeMap = new TreeMap();
           TreeMap treeMap = new TreeMap(new Comparator() {
               @Override
               public int compare(Object o1, Object o2) {
                   //按照传入的 k(String) 的大小进行排序
   
                   //return ((String) o2).compareTo((String) o1);
                   //按照K(String) 的长度大小排序
                   return ((String) o2).length() - ((String) o1).length();
               }
           });
           treeMap.put("jack", "杰克");
           treeMap.put("tom", "汤姆");
           treeMap.put("kristina", "克瑞斯提诺");
           treeMap.put("smith", "斯密斯");
           treeMap.put("hsp", "韩顺平");//hsp进入不了，但韩顺平把汤姆替换掉了
   
           System.out.println("treemap=" + treeMap);
   
           /*
   
               老韩解读源码：
               1. 构造器. 把传入的实现了 Comparator接口的匿名内部类(对象)，传给给TreeMap的comparator
                public TreeMap(Comparator comparator) {
                   this.comparator = comparator;
               }
               2. 调用put方法
               2.1 第一次添加, 把k-v 封装到 Entry对象，放入root
               Entry t = root;
               if (t == null) {
                   compare(key, key); // type (and possibly null) check
   
                   root = new Entry<>(key, value, null);
                   size = 1;
                   modCount++;
                   return null;
               }
               2.2 以后添加
               Comparator cpr = comparator;
               if (cpr != null) {
                   do { //遍历所有的key , 给当前key找到适当位置
                       parent = t;
                       cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare
                       if (cmp < 0)
                           t = t.left;
                       else if (cmp > 0)
                           t = t.right;
                       else  //如果遍历过程中，发现准备添加Key 和当前已有的Key 相等，就不添加
                           return t.setValue(value);
                   } while (t != null);
               }
            */
   
       }
   }
   

   第一次添加和第二次添加不一样

10. Collection工具类

    1. package com.jshedu.collection;
       
       import java.util.*;
       
       /**
        * @author 韩顺平
        * @version 1.0
        */
       @SuppressWarnings({"all"})
       public class Collections_ {
           public static void main(String[] args) {
       
               //创建ArrayList 集合，用于测试.
               List list = new ArrayList();
               list.add("tom");
               list.add("smith");
               list.add("king");
               list.add("milan");
               list.add("tom");
       
       
       //        reverse(List)：反转 List 中元素的顺序
               Collections.reverse(list);
               System.out.println("list=" + list);
       //        shuffle(List)：对 List 集合元素进行随机排序
       //        for (int i = 0; i < 5; i++) {
       //            Collections.shuffle(list);
       //            System.out.println("list=" + list);
       //        }
       
       //        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
               Collections.sort(list);
               System.out.println("自然排序后");
               System.out.println("list=" + list);
       //        sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
               //我们希望按照 字符串的长度大小排序
               Collections.sort(list, new Comparator() {
                   @Override
                   public int compare(Object o1, Object o2) {
                       //可以加入校验代码.
                       return ((String) o2).length() - ((String) o1).length();
                   }
               });
               System.out.println("字符串长度大小排序=" + list);
       //        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
       
               //比如
               Collections.swap(list, 0, 1);
               System.out.println("交换后的情况");
               System.out.println("list=" + list);
       
               //Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
               System.out.println("自然顺序最大元素=" + Collections.max(list));
               //Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
               //比如，我们要返回长度最大的元素
               Object maxObject = Collections.max(list, new Comparator() {
                   @Override
                   public int compare(Object o1, Object o2) {
                       return ((String)o1).length() - ((String)o2).length();
                   }
               });
               System.out.println("长度最大的元素=" + maxObject);
       
       
               //Object min(Collection)
               //Object min(Collection，Comparator)
               //上面的两个方法，参考max即可
       
               //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
               System.out.println("tom出现的次数=" + Collections.frequency(list, "tom"));
       
               //void copy(List dest,List src)：将src中的内容复制到dest中
       
               ArrayList dest = new ArrayList();
               //为了完成一个完整拷贝，我们需要先给dest 赋值，大小和list.size()一样
               for(int i = 0; i < list.size(); i++) {
                   dest.add("");
               }
               System.out.println("dest="+dest);
               //拷贝
               Collections.copy(dest, list);
               System.out.println("dest=" + dest);
       
               //boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
               //如果list中，有tom 就替换成 汤姆
               Collections.replaceAll(list, "tom", "汤姆");
               System.out.println("list替换后=" + list);
       
               
           }
       }