Map接口实现类HashMap，Hashtable

文章列表

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），就会进行树化（红黑树）

HashMap原码

注意各执行情况所走的代码不一样

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);//okmap.put("java", 20);//替换valueSystem.out.println("map=" + map);///*老韩解读HashMap的源码+图解1. 执行构造器 new HashMap()初始化加载因子 loadfactor = 0.75HashMap$Node[] table = null2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)public V put(K key, V value) {//K = "java" value = 10return putVal(hash(key), key, value, false, true);}3. 执行 putValfinal V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;//辅助变量//如果底层的table 数组为null, 或者 length =0 , 就扩容到16if ((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<K,V> e; K k;//辅助变量// 如果table的索引位置的key的hash相同和新的key的hash值相同，// 并 满足(table现有的结点的key和准备添加的  key  是同一个对象  || equals返回真)// 就认为不能加入新的k-vif (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理e = ((TreeNode<K,V>)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 1sttreeifyBin(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 keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value; //替换，key对应valueafterNodeAccess(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<K,V>[] tab, int hash) {int n, index; Node<K,V> e;if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();}*/}
}

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

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（），
Hashtable和HashMap对比
1. 版本线程安全（同步）效率允许null键null值
  
  HashMap 1.2 不安全高可以
  
  Hashtable 1.0 安全较低不可以
java中Map方法为什么要装箱：HashMap 中的元素实际上是对象，一些常见的基本类型可以使它的包装类来代替。

Map接口实现类--Properties

Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据
他的使用特点和Hashtable类型
Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改。
说明：xxx.properties文件通常作为配置文件，这个知识点在IO流举例

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-vproperties.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基本方法

开发中如何选择集合实现类
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

TreeSet

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.comparatorpublic TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;}2. 在 调用 treeSet.add("tom"), 在底层会执行到if (cpr != null) {//cpr 就是我们的匿名内部类(对象)do {parent = t;//动态绑定到我们的匿名内部类(对象)comparecmp = 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() {@Overridepublic 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");//3treeSet.add("sp");treeSet.add("a");treeSet.add("abc");//3，abc就不会加入了因为你设置的规则//按照长度大小排序,长度相等就相当于相同的元素，tom也是3System.out.println("treeSet=" + treeSet);}
}

顺序需要程序员自己设定

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() {@Overridepublic 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的comparatorpublic TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;}2. 调用put方法2.1 第一次添加, 把k-v 封装到 Entry对象，放入rootEntry<K,V> t = root;if (t == null) {compare(key, key); // type (and possibly null) checkroot = new Entry<>(key, value, null);size = 1;modCount++;return null;}2.2 以后添加Comparator<? super K> cpr = comparator;if (cpr != null) {do { //遍历所有的key , 给当前key找到适当位置parent = t;cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compareif (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;else  //如果遍历过程中，发现准备添加Key 和当前已有的Key 相等，就不添加return t.setValue(value);} while (t != null);}*/}
}

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

Collection工具类

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() {@Overridepublic 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() {@Overridepublic 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);}
}

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

Map接口实现类HashMap，Hashtable

相关问题

公告