1. Java集合框架

集合

  • 集合、数组都是对多个数据进行存储操作的结构,简称Java容器。说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储,比如 .txt, .jpg, .avi, 数据库中…
  • 数组在存储多个数据方面的特点:
    • 一旦初始化以后,其长度就确定了。
    • 数组一旦定义好,其元素的类型也就确定了,我们也就只能操作指定类型的数据(包括多态性)。
  • 数组在存储多个数据方面的缺点:
    • 一旦初始化以后,其长度就不可修改。
    • 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
    • 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用。
    • 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。
  • Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。
  • JDK提供的集合API位于java.util包内。

Java集合框架

  • Collection接口:单列集合,用来存储一个一个的对象
    • List接口:存储有序的、可重复的数据。实现类:ArrayList、LinkedList、Vector
    • Set接口:存储无序的、不可重复的数据。实现类:HashSet、LinkedHashSet、TreeSet
  • Map接口:双列集合,用来存储一对具有映射关系”key - value “ 的数据。注:一个k不能对应不同的v,多个k可以对应同一个v。
    • 实现类:HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

image.png

2. Collection接口

包含三大类:set(集合)、queue(队列)、list(列表),常用的实现类有:ArrayList、LinkedList、HashSet、LinkedHashSet、ArrayBlockingQueue等。
image.png

  • Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。
  • JDK不提供此接口的任何直接实现,而是提供更具体的子接口Set、List的实现。
  • Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成 Object 类型处理;从 JDK 5.0 增加了泛型以后,Java 集合可以记住容器中对象的数据类型。
  • Collection 接口方法
    • add(Object obj) 添加
    • addAll(Collection coll) 添加
    • int size() 获取有效元素的个数
    • void clear() 清空集合
    • boolean isEmpty() 是否是空集合
    • boolean contains(Object obj):是否包含某个元素。是通过元素的equals方法来判断是否是同一个对象
    • boolean containsAll(Collection c):也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较
    • boolean remove(Object obj):删除。通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
    • boolean removeAll(Collection coll):取当前集合的差集
    • boolean retainAll(Collection c):取两个集合的交集。把交集的结果存在当前集合中,不影响c
    • boolean equals(Object obj):集合是否相等
    • Object[] toArray():转成对象数组
    • hashCode():获取集合对象的哈希值
    • iterator():遍历。返回迭代器对象,用于集合遍历
  • 向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals()。在判断时会调用obj对象所在类的equals(),若重写了equals(),方法则比较内容而不是地址,若未重写比较的是地址。

    2.1 Iterator迭代器接口

  • Iterator对象称为迭代器(设计模式的一种),主要用于遍历集合中的元素。Enumeration 接口是 Iterator 迭代器的古老版本。

  • Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
  • Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
  • 集合对象每次调用iterator() 方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
  • iterator.hasNext():判断当前指针是否还有下一个元素。在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
  • iterator.next():①指针下移②将下移以后集合位置上的元素返回
  • iterator.remove():

    • Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
    • 如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,再调用remove都会报IllegalStateException。
      1. Iterator iterator = coll.iterator();
      2. while(iterator.hasNext()){//hasNext():判断当前指针是否还有下一个元素
      3. Object obj = iter.next();//next():①指针下移 ②将下移以后集合位置上的元素返回
      4. if(obj.equals("Tom")){
      5. iter.remove();//Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
      6. }
      7. }

      2.2 foreach 循环遍历集合、数组元素

  • Java 5.0 提供了 foreach 循环迭代访问 Collection和数组,foreach还可以用来遍历数组。

  • 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
  • 遍历集合的底层调用Iterator完成操作。
  • for(要遍历的元素类型 遍历后自定义元素名称 : 要遍历的集合或数组名称){}

    2.3 Collection子接口一:List

  • List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。

  • List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
  • List接口方法:List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法。

    • void add(int index, Object ele):在index位置插入ele元素
    • boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
    • Object get(int index):获取指定index位置的元素
    • int indexOf(Object obj):返回obj在集合中首次出现的位置
    • int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
    • Object remove(int index):移除指定index位置的元素,并返回此元素
    • Object set(int index, Object ele):设置指定index位置的元素为ele
    • List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

      2.3.1 List实现类之一:ArrayList

  • ArrayList 是 List 接口的典型实现类、主要实现类

  • 本质上,ArrayList是对象引用的一个变长数组
  • ArrayList的JDK1.8之前与之后的实现区别:
    • JDK1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组。
  1. 创建ArrayList对象:ArrayList list = new ArrayList(); 空参构造器底层创建了长度是10的Object[]数组elementData
    2. 添加数据:list.add(123); //elementData[0] = new Integer(123); 如果添加导致底层数组容量不够则扩容。默认情况下扩容为原来的容量的1.5倍,同时需要将原数组中的数据复制到新的数组中。
    3. 建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity) //数组长度(元素个数)

    • JDK1.8:ArrayList像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再创建一个始容量为10的数组
  2. 创建ArrayList对象:ArrayList list = new ArrayList(); 空参构造器底层创建了Object[] elementData初始化为{},并没有创建长度为10的数组
    2. 添加数据:list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]。后续的添加和扩容操作与jdk 7 无异。

    • 小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
  • 线程不安全的,效率高;底层使用Object[] elementData存储。在线程安全方面,ArrayList可以使用synchronizedList(List list)返回线程安全的,来替代Vector。
  • Arrays.asList(…) 方法,返回值是一个固定长度的 List 集合,既不是 ArrayList 实例,也不是Vector 实例。Arrays类的静态方法:public static List asList(T… a)

    2.3.2 List实现类之二:LinkedList 双向链表

  • 对于频繁的插入、删除元素的操作,建议使用LinkedList类,效率比ArrayList高;

  • 底层使用双向链表存储(一个元素有三部分:前一个元素、核心、下一个元素)
  • 双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。Node除了保存数据,还定义了两个变量:prev变量记录前一个元素的位置,next变量记录下一个元素的位置。
  • LinkedList的源码分析:
  1. 创建LinkedList对象:LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性,默认值为null
    2. 添加数据:list.add(123); //将123封装到Node中,创建了Node对象。其中,Node的定义体现了LinkedList的双向链表的说法(双链表的节点)
  • 新增方法:

    • void addFirst(Object obj)
    • void addLast(Object obj)
    • Object getFirst()
    • Object getLast()
    • Object removeFirst()
    • Object removeLast()

      2.3.3 List实现类之三:Vector

  • 作为List接口的古老实现类,大多数操作与ArrayList相同,区别之处在于Vector是线程安全的,效率低。

  • jdk7和8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组,即底层使用Object[] elementData存储。在扩容方面,默认扩容为原来的数组长度的2倍。
  • 新增方法:

    • void addElement(Object obj)
    • void insertElementAt(Object obj,int index)
    • void setElementAt(Object obj,int index)
    • void removeElement(Object obj)
    • void removeAllElements()

      2.3.4 总结

  • 在各种list中,最好把ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList。在线程安全方面,ArrayList可以使用synchronizedList(List list)返回线程安全的,来替代Vector。Vector总是比ArrayList慢,所以尽量避免使用。

  • ArrayList、LinkedList、Vector三者的异同?同:三个类都是实现了List接口,存储数据的特点相同:存储有序的、可重复的数据。不同:见上
  • ArrayList和LinkedList的异同:二者都线程不安全,相对线程安全的Vector,执行效率高。此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。
  • ArrayList和Vector的区别:Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。Vector还有一个子类Stack。

    2.4 Collection子接口二:Set

  • Set:存储无序的、不可重复的数据。以HashSet为例说明:

    • 无序性:不等于随机性。存储的数据在底层数组中的位置并非按照添加的顺序放置,而是根据数据的哈希值决定。
    • 不可重复性:保证添加的元素按照equals()判断时,不能返回true。即:相同的元素只能添加一个。
  • 说明:
    • Set接口是Collection的子接口,set接口没有提供额外的方法。
    • Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。
    • Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。
    • 为了保证向Set中添加的元素是无序的、不可重复的,要求向Set(主要指HashSet、LinkedHashSet)中添加的数据,所在的类一定要重写hashCode()和equals(),重写的hashCode()和equals()尽可能保持一致性,以实现对象相等规则,即相等的对象必须具有相等的散列码。
  • 重写 hashCode() 方法的基本原则
    • 在程序运行时,同一个对象多次调用 hashCode() 方法应该返回相同的值
    • 当两个对象的 equals() 方法比较返回 true 时,这两个对象的 hashCode() 方法的返回值也应相等
    • 对象中用作 equals() 方法比较的属性 Field,都应该用来计算 hashCode 值
  • 重写 equals() 方法的基本原则
    • 当一个类有自己特有的“逻辑相等”概念时,需要重写equals()。当重写equals()的时候,一般都需要同时重写hashCode()
    • 根据一个类改写后的equals()方法,两个截然不同的实例有可能在逻辑上是相等的,但是根据hashCode()方法,它们仅仅是两个对象
    • 通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算
    • IDEA中可以直接alt+shift+s生成重写的equals()和hashCode()
  • 用Eclipse/IDEA复写hashCode方法,选择31这个数字:

    • 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。——减少冲突
    • 并且31只占用5bits,相乘造成数据溢出的概率较小
    • 31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。——提高算法效率
    • 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除。——减少冲突

      2.4.1 Set实现类之一:HashSet

  • HashSet作为Set接口的主要实现类,大多数时候使用 Set 集合时都使用这个实现类。

  • HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。
  • HashSet 具有以下特点:
    • 不能保证元素的排列顺序
    • HashSet 不是线程安全的,即线程不安全的
    • 可以存储null值,即集合元素可以是 null
    • 底层:数组+单向链表的结构。数组初始容量为16,当如果使用率超过0.75倍,即16*0.75=12,就会扩大容量为原来的2倍。扩容依次为32,64,128….
  • HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
  • 添加元素的过程:

    • 向HashSet 集合中添加元素a,首先会调用元素a 所在类的hashCode() 方法,计算得到元素a的hashCode 哈希值,
    • 接着根据此 hashCode 哈希值,通过某种散列函数计算出元素 a 在 HashSet 底层数组中的存储位置,即索引位置——无序性
    • 这个散列函数会与底层数组的长度相计算得到在数组中的下标,这种散列函数计算尽可能保证能均匀存储元素,越是散列分布,散列函数设计的越好
    • 判断数组此位置上是否已经有元素:——不可重复性
    • 如果此位置上没有其他元素,则元素a添加成功。 ——>情况1
    • 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hashCode哈希值:
    • 如果hashCode值不相同,则元素a添加成功(元素a与已经存在指定索引位置上数据以链表的方式存储)。——>情况2
    • 如果hashCode值相同,进而需要调用元素a所在类的equals()方法:a.equals(b)
    • equals()返回true,元素a添加失败
    • equals()返回false,则元素a添加成功(元素a与已经存在指定索引位置上数据以链表的方式存储)。——>情况3
    • 对于添加成功的情况2和情况3,元素a与已经存在指定索引位置上数据以链表的方式存储:jdk 8之前,元素a放到数组中,指向原来的元素;jdk 8以后,原来的元素在数组中,指向元素a。

      2.4.2 Set实现类之二:LinkedHashSet

  • LinkedHashSet 是 HashSet 的子类

  • LinkedHashSet 不允许集合元素重复
  • 底层是数组+双向链表。
  • LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
  • 在添加数据的同时,每个数据还维护了两个引用(一对双向链表),记录此数据的前一个数据和后一个数据。
  • 遍历其内部数据时,可以按照添加的顺序遍历(看似有序其实无序)
  • LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能,即对于频繁的遍历操作,LinkedHashSet效率高于HashSet。

    2.4.3 Set实现类之三:TreeSet

  • TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。特点:有序,查询速度比List快。

  • 向TreeSet中添加的数据,要求是相同类的对象。存入同一个类的对象,可以按照添加对象的指定属性,进行排序。
  • TreeSet底层使用树形结构存储数据:红黑树。TreeSet和TreeMap都采用红黑树的存储结构
  • TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet 采用自然排序
  • 新增的方法
    • Comparator comparator()
    • Object first()
    • Object last()
    • Object lower(Object e)
    • Object higher(Object e)
    • SortedSet subSet(fromElement, toElement)
    • SortedSet headSet(toElement)
    • SortedSet tailSet(fromElement)
  • 自然排序:实现Comparable接口,实现compareTo()方法
    • 自然排序中,比较两个对象是否相同的标准为:实现的compareTo()返回0,即两个对象相同,不再是equals()。
    • TreeSet空参构造器:按照自然排序。排序对象所在类实现Comparable接口,实现compareTo(Object obj)方法的方式。
    • TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列。
    • 把一个对象添加到 TreeSet 时,该对象所在的类必须实现 Comparable 接口,实现 compareTo(Object obj) 方法,两个对象通过该方法的返回值来比较大小。
    • 向 TreeSet 中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。
    • 因为只有相同类的两个实例才会比较大小,所以向 TreeSet 中添加的应该是同一个类的对象。
    • 对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值。
    • 当需要把一个对象放入 TreeSet 中,重写该对象对应的 equals() 方法时,应保证该方法与 compareTo()方法有一致的结果:如果两个对象通过equals()方法比较返回true,则通过compareTo()方法比较也应返回0。
    • Comparable接口的典型实现:
      • BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
      • Character:按字符的 unicode值来进行比较
      • Boolean:true 对应的包装类实例大于 false 对应的包装类实例
      • String:按字符串中字符的 unicode 值进行比较
      • Date、Time:后边的时间、日期比前面的时间、日期大
  • 定制排序:Comparator()

    • 定制排序中,比较两个对象是否相同的标准为:compare()返回0,即两个对象相同,不再是equals()。
    • TreeSet的自然排序要求元素所属的类实现Comparable接口,如果元素所属的类没有实现Comparable接口,或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序,则考虑使用定制排序。
    • 定制排序,通过Comparator接口来实现,需要实现compare(T o1,T o2)方法。
    • 利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。
    • 要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
    • 此时,仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
    • 使用定制排序判断两个元素相等的标准是:通过Comparator比较两个元素返回了0。
      1. @Override
      2. public int compareTo(Object o) {// 自然排序
      3. if(o instanceof User){
      4. User user = (User)o
      5. //return -this.name.compareTo(user.name);
      6. int compare = -this.name.compareTo(user.name); //姓名从大到小排列
      7. if(compare != 0){
      8. return compare;
      9. }else{
      10. return Integer.compare(this.age,user.age); //年龄从小到大排列
      11. }
      12. }else{
      13. throw new RuntimeException("输入的类型不匹配");
      14. }
      15. }

      3. Map接口

  • Map接口

    • Map与Collection并列存在。用于保存具有映射关系的数据:key-value
    • Map 中的 key 和 value 都可以是任何引用类型的数据
    • Map 中的 key 用Set来存放,不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法。常用String类作为Map的key
    • key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value
  • 常用方法
    • Object put(Object key,Object value):将指定key-value添加或修改到当前map对象中
    • void putAll(Map m):将m中的所有key-value对存放到当前map中
    • Object remove(Object key):移除指定key的key-value对,并返回value
    • void clear():清空当前map中的所有数据
    • 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():返回所有key构成的Set集合
    • Collection values():返回所有value构成的Collection集合
    • Set entrySet():返回所有key-value对构成的Set集合。映射关系,即每个key-value对的类型是Map.Entry类型,它是Map接口的内部接口

image.png

3.1 Map实现类之一:HashMap

1.概述

HashMap 根据键的 hashCode 值存储数据,大多数情况下可以直接定位到它的值,因而具有很快
的访问速度,但遍历顺序却是不确定的。 HashMap 最多只允许一条记录的键为 null,允许多条记
录的值为 null。HashMap 非线程安全,即任一时刻可以有多个线程同时写 HashMap,可能会导
致数据的不一致。如果需要满足线程安全,可以用 Collections 的 synchronizedMap 方法使
HashMap 具有线程安全的能力,或者使用 ConcurrentHashMap。我们用下面这张图来介绍
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。
  • 常用方法:map.getOrDefault(key,0):key有对应value就返回原来的value,没有返回0

    2. HashMap源码中的重要常量

  • DEFAULT_INITIAL_CAPACITY : HashMap的默认容量,16

  • MAXIMUM_CAPACITY: HashMap的最大支持容量,2^30
  • DEFAULT_LOAD_FACTOR:HashMap的默认加载因子或负载因子或填充因子或填充比,0.75
  • TREEIFY_THRESHOLD:吞吐临界值或阈值,Bucket中链表长度大于该默认值,转化为红黑树
  • UNTREEIFY_THRESHOLD:Bucket中红黑树存储的Node小于该默认值,转化为链表
  • MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量。当桶中Node的数量大到需要变红黑树时,若hash表容量小于MIN_TREEIFY_CAPACITY时,此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。
  • table:存储元素的数组,总是2的n次幂
  • entrySet:存储具体元素的集
  • size:HashMap中存储的键值对的数量
  • modCount:HashMap扩容和结构改变的次数
  • capacity:当前数组容量,始终保持 2^n,可以扩容,扩容后数组大小为当前的 2 倍
  • loadFactor:填充或负载因子,默认为 0.75
  • threshold:扩容的临界值或阈值,等于capacity * loadFactor

    3. JDK8之前HashMap的实现

    存储结构
    image.png
    image.png
    JDK8之前,HashMap的内部存储结构是数组+链表的结合(即为链地址法。HashMap 底层是一个数组,数组中每个元素是一个单向链表)。上图中,每个绿色的实体是嵌套类 Entry 的实例,Entry 包含四个属性:key, value, hash 值和用于单向链表的 next。
    初始化、实例化
    当实例化一个HashMap时,系统就会创建一个长度为initialCapacity的Entry[]数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置称为桶(bucket)。每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。每个bucket中存储一个元素,即一个Entry对象。每一个Entry对象可以带一个引用变量next,用于指向下一个元素,因此在一个bucket中有可能生成一个Entry链。而且新put添加的元素作为链表的head头节点(头插法)。
    添加元素的过程
    向HashMap中添加Entry1(key, value),需要首先计算Entry1中key的哈希值(根据key所在类的hashCode()计算得到),此哈希值经过处理以后,得到在底层Entry[]数组中要存储的位置i。如果位置i上没有元素,则Entry1直接添加成功;如果位置i上已经存在Entry2或还有链表存在的Entry3, Entry4,则需要通过循环的方法,依次比较Entry1中key和其他的Entry中key的hash值。如果彼此hash值都不同,则直接添加成功;如果hash值相同,继续比较二者是否equals。如果返回值为true,则使用Entry1的value去替换equals为true的Entry的value;如果遍历一遍以后,发现所有的equals返回都为false,则Entry1仍可添加成功。Entry1添加成功时,是作为链表的头节点指向原有的Entry元素。
    HashMap的扩容
    当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
    HashMap什么时候进行扩容
    数组扩容(这部分和JDK8之前相同)
    当HashMap中的元素个数(即数组中元素个数size)超过capacityloadFactor 时(capacity 数组容量是数组总长度length,而不是数组中元素的个数size,默认值DEFAULT_INITIAL_CAPACITY为16;loadFactor 负载因子的默认值DEFAULT_LOAD_FACTOR为0.75),即当HashMap中元素个数超过160.75=12(这个乘积就是threshold 吞吐临界值或扩容的阈值)时,就会进行数组的扩容,把数组的容量扩大一倍,即扩展为2*16=32,然后重新计算每个元素在数组中的位置,这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

    4. JDK8之后HashMap的实现

    存储结构
    image.png
    image.png
    JDK8及之后,HashMap的内部存储结构是数组+链表+红黑树的结合。查找的时候,根据 hash 值我们能够快速定位到数组的具体下标,但是之后的话,需要顺着链表一个个比较下去才能找到我们需要的,时间复杂度取决于链表的长度,为 O(n)。为了降低这部分的开销,在 JDK8 中,当链表中的元素超过了 8 个以后,会将链表转换为红黑树,在这些位置进行查找的时候可以降低时间复杂度为 O(logN)。
    初始化、实例化
    当实例化一个HashMap时,会初始化initialCapacity和loadFactor。在put添加第一对映射关系时,系统才会创建一个长度为initialCapacity的Node[]数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置称为桶(bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。每个bucket中存储一个元素,可能是一个Node对象,也可能是一个TreeNode对象(其中TreeNode继承了Node)。
    每一个Node对象可以带一个引用变量next,用于指向下一个元素,因此在一个bucket中有可能生成一个Node链;每一个TreeNode对象可以有两个叶子结点left和right,因此在一个bucket中有可能生成一个TreeNode树。而且新添加的元素作为链表的last尾节点或树的叶子结点(尾插法)。

扩容机制:什么时候、如何进行数组扩容和树形化

  1. 数组扩容(这部分和JDK8之前相同)

当HashMap中的元素个数(即数组中元素个数size)超过capacityloadFactor时(capacity 数组容量是数组总长度length,而不是数组中元素的个数size,默认值DEFAULT_INITIAL_CAPACITY为16;loadFactor 负载因子的默认值DEFAULT_LOAD_FACTOR为0.75),即当HashMap中元素个数超过160.75=12(这个乘积就是threshold 吞吐临界值或扩容的阈值)时,就会进行数组的扩容,把数组的容量扩大一倍,即扩展为 2*16=32,然后重新计算每个元素在数组中的位置,这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

  1. 树形化:链表->红黑树(这部分和JDK8之前不同)

当HashMap中的其中一个链的对象个数达到8个时,如果此时capacity没有达到64,那么HashMap会先扩容数组来解决,如果capacity已经达到了64,那么这个链会变成树,结点类型由Node类型变成TreeNode类型。当然,如果当映射关系被移除后,下次resize方法时判断出树的结点个数低于6个时,也会把树再转为链表。

关于映射关系的key是否可以修改
不要修改。映射关系存储到HashMap中会存储key的hash值,这样就不用在每次查找时重新计算每一个Entry或Node(TreeNode)的hash值了,因此如果已经put到Map中的映射关系,再修改key的属性,而这个属性又参与hashcode值的计算,那么会导致匹配不上。

负载因子值的大小,对HashMap有什么影响

  • 负载因子的大小决定了HashMap的数据密度。
  • 负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长,造成查询或插入时的比较次数增多,性能会下降。
  • 负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建议初始化预设大一点的空间。
  • 按照其他语言的参考及研究经验,会考虑将负载因子设置为0.7~0.75,此时平均检索长度接近于常数。

    5. HashMap的put流程

  1. 首次扩容:
    先判断数组是否为空,若数组为空则进行第一次resize();resize()不仅用来调整大小,还用来进行初始化配置
  2. 计算索引:
    通过hash算法,计算键值对在数组中的索引;
  3. 插入数据:
  • 如果当前位置元素为空,则直接插入数据;
  • 如果当前位置元素非空,且key已存在,则直接覆盖其value;
  • 如果当前位置元素非空,且key不存在,则将数据链到链表末端;
  • 若链表长度达到8,则将链表转换成红黑树,并将数据插入树中;
  1. 再次扩容
    如果数组中元素个数size超过threshold,则再次进行扩容操作。

    6. JDK7和8在HashMap的改进

  2. 存储结构:数组+链表 —> 数组+链表+红黑树;

  3. 创建数组的时间:1.7当实例化一个HashMap时,系统就会调用inflateTable()创建一个长度为initialCapacity的Entry[]数组;1.8当实例化一个HashMap时,会初始化initialCapacity和loadFactor。当首次调用put添加第一对映射关系时,系统才会直接调用resize()扩容创建一个长度为initialCapacity的Node[]数组;
  4. 数组元素类型:Entry类型(Entry链) —> Node类型或TreeNode类型(Node链或TreeNode树) ;
  5. 新添加的key-value对元素的位置:头插 —> 尾插;因此扩容时1.8会保持原链表的顺序,而1.7会颠倒链表的顺序,从而导致了1.7在多线程hashmap扩容时容易形成死循环的问题。而且1.8是在元素插入后检测是否需要扩容,而1.7是在元素插入前检测是否需要扩容;
  6. 哈希函数hash(Object key)的设计:1.7中hash函数对哈希值的计算直接使用key的hashCode值;而1.8中是使用key的hashCode值异或上key的hashCode进行无符号右移16位的结果,即(h = key.hashCode()) ^ (h >>> 16); 避免了只靠低位数据来计算哈希时导致的冲突,计算结果由高低位结合决定,使元素分布更均匀;
  7. 分散策略:1.7是通过更新hashSeed来修改hash值达到分散的目的;而1.8是扩容时通过hash&cap==0,即(e.hash & oldCap) == 0,将链表分散,无需改变hash值;
  8. 扩容策略:1.7中是只要不小于阈值就直接扩容2倍;而1.8的扩容策略会更优化。当数组指定索引位置的链表长度>8时,且HashMap数组的长度>64时,此索引位置上的所有key-value对使用红黑树进行存储。

    对于第5点的补充: 我们平常求余数怎么求,比如11%4,我们会通过11 / 4 = 2 ···3,商为2,剩余的就是余数3,那么同样对于二进制,11的二进制为1011,4是2的二次方,那么11除以4,相当于被除数11右移两位,商为1011右移两位为10就是2,被移掉的最后两位就是11余数为3。 换句话说,如果一个数除以2的N次方求余,那么我们就是要得到这个数最后N位二进制的值。 因为size为二的幂次方,size-1的二进制一定为111···11这种全是1的数,这样进行与操作就能提取到后N位,所以位运算取余公式是 hash & (size - 1) hash值其实是一个int类型,二进制位为32位,而HashMap的table数组初始化size为16,取余操作为hashCode & 15 ==> hashCode & 1111 。这将会存在一个巨大的问题,1111只会与hashCode的低四位进行与操作,也就是hashCode的高位其实并没有参与运算,会导很多hash值不同而高位有区别的数,最后算出来的索引都是一样的。 举个例子,我假设hashCode为1111110001,那么1111110001 & 1111 = 0001,高位发生变化时1011110001 & 1111 = 00011001110001 & 1111 = 0001,也就是说在高位发生变化时,你最后算出来的索引都一样了,这样就会导致很多数据都被放到一个数组里面了,造成性能退化。 为了避免这种情况,HashMap将高16位与低16位进行异或,这样可以保证高位的数据也参与到与运算中来,以增大索引的散列程度,让数据分布得更为均匀 (个人觉得很多博客说的减小哈希碰撞是错误的说法,因为hash碰撞指的是两个hashCode相同,这里显然不是) 为什么用异或,不用 & 或者 | 操作,因为异或可以保证两个数值的特性,&运算使得结果向1靠近, |运算使得结果向0靠近。

7. JDK1.8的HashMap的扩容策略

  1. 数组的初始容量为16,而容量是以2的次方扩充的,一是为了提高性能使用足够大的数组,二是为了能使用位运算代替取模预算(据说提升了5~8倍)。
  2. 数组是否需要扩充是通过负载因子判断的,如果当前元素个数为数组容量的0.75时,就会扩充数组。这个0.75就是默认的负载因子,可由构造器传入。我们也可以设置大于1的负载因子,这样数组就不会扩充,牺牲性能,节省内存。
  3. 为了解决碰撞,数组中的元素是单向链表类型。当链表长度到达一个阈值时(7或8),会将链表转换成红黑树提高性能。而当链表长度缩小到另一个阈值时(6),又会将红黑树转换回单向链表提高性能。

    对于第3点的补充: 检查链表长度转换成红黑树之前,还会先检测当前数组数组是否到达一个阈值(64),如果没有到达这个容量,会放弃转换,先去扩充数组。所以上面也说了链表长度的阈值是7或8,因为会有一次放弃转换的操作。

image.pngimage.png

8. 为什么HashMap是线程不安全的

  1. 多线程下扩容死循环。JDK1.7中的HashMap使用头插法插入元素,在多线程的环境下,扩容的时候有可能导致环形链表的出现,形成死循环。因此JDK1.8使用尾插法插入元素,在扩容时会保持链表元素原本的顺序,不会出现环形链表的问题。
  2. 多线程的put可能导致元素的丢失。多线程同时执行put操作,如果计算出来的索引位置是相同的,那会造成前一个key被后一个key覆盖,从而导致元素的丢失。此问题在JDK1.7和JDK1.8中都存在。
  3. put和get并发时,可能导致get为null。线程1执行put时,因为元素个数超出threshold而导致rehash,线程2此时执行get,有可能导致这个问题,此问题在JDK1.7和JDK1.8中都存在。

    9. HashMap和HashTable的区别

  4. 线程安全:Hashtable是一个线程安全的Map实现;但HashMap是线程不安全的Map实现,所以HashMap比Hashtable的性能高一点。

  5. key和value是否可null:Hashtable不允许使用null作为key和value,如果试图把null值放进Hashtable中,将会引发空指针异常;但HashMap可以使用null作为key或value。

    3.2 Map实现类之二:LinkedHashMap

  • LinkedHashMap 是 HashMap 的子类
  • 在HashMap存储结构的基础上,使用了一对双向链表来记录添加元素的顺序
  • 与LinkedHashSet类似,LinkedHashMap 可以维护 Map 的迭代顺序:迭代顺序与 Key-Value 对的插入顺序一致

    1. //HashMap中的内部类:Node
    2. static class Node<K,V> implements Map.Entry<K,V> {
    3. final int hash;
    4. final K key;
    5. V value;
    6. Node<K,V> next;
    7. }
    8. //LinkedHashMap中的内部类:Entry
    9. static class Entry<K,V> extends HashMap.Node<K,V> {
    10. Entry<K,V> before, after;
    11. Entry(int hash, K key, V value, Node<K,V> next) {
    12. super(hash, key, value, next);
    13. }
    14. }

    3.3 Map实现类之三:TreeMap

  • TreeMap存储 Key-Value 对时,需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。

  • TreeSet底层使用红黑树结构存储数据
  • TreeMap 的 Key 的排序:
    • 自然排序:TreeMap 的所有的 Key 必须实现 Comparable 接口,而且所有的 Key 应该是同一个类的对象,否则将会抛出 ClasssCastException。
    • 定制排序:创建 TreeMap 时,传入一个 Comparator 对象,该对象负责对TreeMap 中的所有 key 进行排序,此时不需要 Map 的 Key 实现Comparable 接口。
  • TreeMap判断两个key相等的标准:两个key通过compareTo()方法或compare()方法返回0。

    3.4 Map实现类之四:Hashtable

  • Hashtable是个古老的 Map 实现类,JDK1.0就提供了。不同于HashMap,Hashtable是线程安全的。

  • Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
  • 与HashMap不同,Hashtable 不允许使用 null 作为 key 和 value
  • 与HashMap一样,Hashtable 也不能保证其中 Key-Value 对的顺序
  • Hashtable判断两个key相等、两个value相等的标准,与HashMap一致

    3.5 Map实现类之五:Properties

  • Properties 类是 Hashtable 的子类,该对象用于处理属性文件,new-file-xx.prpperties。

  • 由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key 和 value 都是字符串类型
  • 存取数据时,建议使用setProperty(String key, String value)方法和getProperty(String key)方法
    1. Properties pros = new Properties();
    2. pros.load(new FileInputStream("jdbc.properties"));
    3. String user = pros.getProperty("user");
    4. System.out.println(user);

    3.6 Map实现类之六:ConcurrentHashMap

    1. 概述

    要避免 HashMap 的线程安全问题,有多个解决方法,比如改用 HashTable 或者 Collections.synchronizedMap() 方法。但是这两者都有一个问题,就是性能,无论读还是写,他们两个都会给整个集合加锁,导致同一时间的其他操作阻塞。

java.util.concurrent.ConcurrentHashMap 属于 JUC 包下的一个集合类,可以实现线程安全。它的优势在于兼顾性能和线程安全,一个线程进行写操作时,它会锁住一小部分,其他部分的读写不受影响,其他线程访问没上锁的地方不会被阻塞。

ConcurrentHashMap 和 HashMap 思路是差不多的,但因为它支持并发操作,所以要复杂一些。

2. JDK8之前的实现:Segment[]+HashEntry[]+链表

Segment
整个 ConcurrentHashMap 由多个 Segment 组合而成,Segment 代表段的意思,所以很多地方都会将其描述为分段锁。

Segment 本身就相当于一个 HashMap 对象。同 HashMap 一样,Segment 包含一个 HashEntry 数组,数组中的每一个 HashEntry 既是一个键值对,也是一个链表的头节点。

在 ConcurrentHashMap 集合中有 2 的 N 次方个 Segment 对象,共同保存在一个名为 segments 的Segment[] 数组当中。因此整个ConcurrentHashMap的结构如下。

结构
image.pngimage.png

image.png
可以说,ConcurrentHashMap 是一个二级哈希表。在一个总的哈希表下面,有若干个子哈希表。这样的二级结构,和数据库的水平拆分有些相似。

优势
采取了锁分段技术,每一个 Segment 就好比一个自治区,读写操作高度自治,Segment 之间互不影响。
Case1:不同 Segment 的并发写入【可以并发执行】
Case2:同一 Segment 的一写一读【可以并发执行】
Case3:同一 Segment 的并发写入【需要上锁】
由此可见,ConcurrentHashMap 当中每个 Segment 各自持有一把锁。在保证线程安全的同时降低了锁的粒度,让并发操作效率更高。

怎么做到线程安全的

  1. 底层采用分段的数组+链表实现
  2. 通过把整个 Map 分为N个 Segment,可以提供相同的线程安全,但是效率提升N倍,默认提升16倍。(读操作不加锁,由于 HashEntry 的 value 变量是 volatile 的,也能保证读取到最新的值。)
  3. Hashtable 的 synchronized 是针对整张 Hash 表的,即每次锁住整张表让线程独占,ConcurrentHashMap 允许多个修改操作并发进行,其关键在于使用了锁分离技术。
  4. 有些方法需要跨段,比如 size() 和 containsValue(),它们可能需要锁定整个表而不仅仅是某个段,这需要按顺序锁定所有段,操作完毕后,又按顺序释放所有段的锁。
  5. 扩容:段内扩容(段内元素超过该段对应 Entry 数组长度的75%触发扩容,不会对整个 Map 进行扩容),插入前检测是否需要扩容,避免无效扩容。

从类图可看出在存储结构中 ConcurrentHashMap 比 HashMap 多出了一个类 Segment,而 Segment 是一个可重入锁。ConcurrentHashMap 是使用了锁分段技术来保证线程安全的。

Segment 继承 ReentrantLock。简单理解就是,ConcurrentHashMap 是一个 Segment 数组,Segment 通过继承ReentrantLock 来进行加锁,所以每次需要加锁的操作锁住的是一个 segment,这样只要保证每个 Segment 是线程安全的,也就实现了全局的线程安全。

锁分段技术
首先将数据分成一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据仍能被其他线程访问。

ConcurrentHashMap 提供了与 Hashtable 和 SynchronizedMap 不同的锁机制。Hashtable 中采用的锁机制是一次锁住整个 hash 表,从而在同一时刻只能由一个线程对其进行操作;而 ConcurrentHashMap 中则是一次锁住一个段。

ConcurrentHashMap 默认将 hash 表分为16个段,诸如 get、put、remove 等常用操作只锁住当前需要用到的段。这样,原来只能一个线程进入,现在却能同时有16个写线程执行,并发性能的提升是显而易见的。

并行度
concurrencyLevel:并行级别、并发数、并发度、Segment 数。默认是 16,也就是说 ConcurrentHashMap 默认有 16 个 Segments,所以理论上,最多可以同时支持 16 个线程并发写,只要它们的操作分别分布在不同的 Segment 上。这个值可以在初始化的时候设置为其他值,但是一旦初始化以后,它是不可以扩容的。再具体到每个 Segment 内部,其实每个 Segment 很像之前介绍的 HashMap,不过它要保证线程安全,所以处理起来要麻烦些。

读写过程
Get方法:

  1. 为输入的 Key 做 Hash 运算,得到 hash 值(为了实现Segment均匀分布,进行了两次Hash)
  2. 通过 hash 值,定位到对应的 Segment 对象
  3. 再次通过 hash 值,定位到 Segment 当中数组的具体位置。

Put方法:

  1. 为输入的 Key 做 Hash 运算,得到 hash 值
  2. 通过 hash 值,定位到对应的 Segment 对象
  3. 获取可重入锁 ReentrantLock
  4. 再次通过 hash 值,定位到 Segment 当中数组的具体位置
  5. 插入或覆盖 HashEntry 对象
  6. 释放可重入锁 ReentrantLock

从步骤可以看出,ConcurrentHashMap 在读写时均需要二次定位。首先定位到 Segment,之后定位到 Segment 内的具体数组下标。

3. Java8及之后的实现:数组+链表+红黑树

JDK1.8 中 ConcurrentHashMap 的数据结构跟 JDK1.8 中 HashMap 的数据结构类似,都是数组+链表+红黑树,当链表长度大于8时,链表结构转为红黑树。

4. Java7和8区别

  1. 整体结构:
  • 1.7:Segment[] + HashEntry[] + 链表
  • 1.8:移除 Segment,数组 + 链表 + 红黑树,跟JDK 1.8 中 HashMap 结构类似
  1. 线程安全:1.8 中取消了 Segment 分段锁,采用 CAS + synchronized 来保证并发安全
  • 1.7:Segment 继承 ReentrantLock
  • 1.8:移除 Segment,使锁的粒度更小,Synchronized + CAS,synchronized 只锁定当前链表或红黑二叉树的首节点,只要节点 hash 不冲突,就不会产生并发,相比 JDK1.7 的 ConcurrentHashMap 效率又提升了 N 倍。
  1. put():
  • 1.7:先定位 Segment,再定位桶,put 全程加锁,没有获取锁的线程提前找桶的位置,并最多自旋 64 次获取锁,超过则挂起。
  • 1.8:由于移除了 Segment,类似 HashMap,可以直接定位到桶,拿到 first 节点后进行判断:①为空则 CAS 插入;②为 -1 则说明在扩容,则跟着一起扩容;③ else 则加锁这里会利用继承过来的锁的特性,在将数据插入指定的 HashEntry 位置时(尾插法),会通过继承 ReentrantLock 的 tryLock() 方法尝试去获取锁,如果获取成功就直接插入相应的位置,如果已经有线程获取该Segment的锁,那当前线程会以自旋的方式去继续的调用 tryLock() 方法去获取锁,超过指定次数就挂起,等待唤醒。
  1. get():基本类似,由于 value 声明为 volatile,保证了修改的可见性,因此不需要加锁。
  2. resize():
  • 1.7:跟 HashMap 步骤一样,只不过是搬到单线程中执行,避免了 HashMap 在 1.7 中扩容时死循环的问题,保证线程安全。
  • 1.8:支持并发扩容,HashMap 扩容在1.8中由头插改为尾插(为了避免死循环问题),ConcurrentHashmap 也是,迁移也是从尾部开始,扩容前在桶的头部放置一个 hash 值为 -1 的节点,这样别的线程访问时就能判断是否该桶已经被其他线程处理过了。
  1. size()
  • 1.7:很经典的思路:计算两次,如果不变则返回计算结果,若不一致,则锁住所有的 Segment 求和。
  • 1.8:用 baseCount 来存储当前的节点个数,这就设计到 baseCount 并发环境下修改的问题。

    4. Collections工具类

  • Collections 是一个操作 Set、List 和 Map 等集合的工具类;操作数组的工具类:Arrays;工具类:静态方法

  • Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
  • 排序操作:(均为static方法)
    • reverse(List):反转 List 中元素的顺序
    • shuffle(List):对 List 集合元素进行随机排序
    • sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
    • sort(List, Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
    • swap(List list, int i, int j):将指定 list 集合中的 i 处元素和 j 处元素进行交换
  • 查找、替换:(均为static方法)
    • 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 对象的所有旧值
  • 同步控制:Collections 类中提供了多个 synchronizedXxx() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题