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
2. Collection接口
包含三大类:set(集合)、queue(队列)、list(列表),常用的实现类有:ArrayList、LinkedList、HashSet、LinkedHashSet、ArrayBlockingQueue等。
- 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。
Iterator iterator = coll.iterator();
while(iterator.hasNext()){//hasNext():判断当前指针是否还有下一个元素
Object obj = iter.next();//next():①指针下移 ②将下移以后集合位置上的元素返回
if(obj.equals("Tom")){
iter.remove();//Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
}
}
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的数组。
创建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的数组
创建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的源码分析:
- 创建LinkedList对象:LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性,默认值为null
2. 添加数据:list.add(123); //将123封装到Node中,创建了Node对象。其中,Node的定义体现了LinkedList的双向链表的说法(双链表的节点)
新增方法:
作为List接口的古老实现类,大多数操作与ArrayList相同,区别之处在于Vector是线程安全的,效率低。
- jdk7和8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组,即底层使用Object[] elementData存储。在扩容方面,默认扩容为原来的数组长度的2倍。
新增方法:
在各种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这个数字:
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。
@Override
public int compareTo(Object o) {// 自然排序
if(o instanceof User){
User user = (User)o
//return -this.name.compareTo(user.name);
int compare = -this.name.compareTo(user.name); //姓名从大到小排列
if(compare != 0){
return compare;
}else{
return Integer.compare(this.age,user.age); //年龄从小到大排列
}
}else{
throw new RuntimeException("输入的类型不匹配");
}
}
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接口的内部接口
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的实现
存储结构
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的实现
存储结构
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尾节点或树的叶子结点(尾插法)。
扩容机制:什么时候、如何进行数组扩容和树形化
- 数组扩容
(这部分和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的性能。
- 树形化:链表->红黑树
(这部分和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流程
- 首次扩容:
先判断数组是否为空,若数组为空则进行第一次resize();resize()不仅用来调整大小,还用来进行初始化配置 - 计算索引:
通过hash算法,计算键值对在数组中的索引; - 插入数据:
- 如果当前位置元素为空,则直接插入数据;
- 如果当前位置元素非空,且key已存在,则直接覆盖其value;
- 如果当前位置元素非空,且key不存在,则将数据链到链表末端;
- 若链表长度达到8,则将链表转换成红黑树,并将数据插入树中;
再次扩容
如果数组中元素个数size超过threshold,则再次进行扩容操作。6. JDK7和8在HashMap的改进
存储结构:数组+链表 —> 数组+链表+红黑树;
- 创建数组的时间:1.7当实例化一个HashMap时,系统就会调用inflateTable()创建一个长度为initialCapacity的Entry[]数组;1.8当实例化一个HashMap时,会初始化initialCapacity和loadFactor。当首次调用put添加第一对映射关系时,系统才会直接调用resize()扩容创建一个长度为initialCapacity的Node[]数组;
- 数组元素类型:Entry类型(Entry链) —> Node类型或TreeNode类型(Node链或TreeNode树) ;
- 新添加的key-value对元素的位置:头插 —> 尾插;因此扩容时1.8会保持原链表的顺序,而1.7会颠倒链表的顺序,从而导致了1.7在多线程hashmap扩容时容易形成死循环的问题。而且1.8是在元素插入后检测是否需要扩容,而1.7是在元素插入前检测是否需要扩容;
- 哈希函数hash(Object key)的设计:1.7中hash函数对哈希值的计算直接使用key的hashCode值;而1.8中是使用key的hashCode值异或上key的hashCode进行无符号右移16位的结果,即(h = key.hashCode()) ^ (h >>> 16); 避免了只靠低位数据来计算哈希时导致的冲突,计算结果由高低位结合决定,使元素分布更均匀;
- 分散策略:1.7是通过更新hashSeed来修改hash值达到分散的目的;而1.8是扩容时通过hash&cap==0,即(e.hash & oldCap) == 0,将链表分散,无需改变hash值;
- 扩容策略: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 = 0001
,1001110001 & 1111 = 0001
,也就是说在高位发生变化时,你最后算出来的索引都一样了,这样就会导致很多数据都被放到一个数组里面了,造成性能退化。 为了避免这种情况,HashMap将高16位与低16位进行异或,这样可以保证高位的数据也参与到与运算中来,以增大索引的散列程度,让数据分布得更为均匀 (个人觉得很多博客说的减小哈希碰撞是错误的说法,因为hash碰撞指的是两个hashCode相同,这里显然不是) 为什么用异或,不用 & 或者 | 操作,因为异或可以保证两个数值的特性,&运算使得结果向1靠近, |运算使得结果向0靠近。
7. JDK1.8的HashMap的扩容策略
- 数组的初始容量为16,而容量是以2的次方扩充的,一是为了提高性能使用足够大的数组,二是为了能使用位运算代替取模预算(据说提升了5~8倍)。
- 数组是否需要扩充是通过负载因子判断的,如果当前元素个数为数组容量的0.75时,就会扩充数组。这个0.75就是默认的负载因子,可由构造器传入。我们也可以设置大于1的负载因子,这样数组就不会扩充,牺牲性能,节省内存。
- 为了解决碰撞,数组中的元素是单向链表类型。当链表长度到达一个阈值时(7或8),会将链表转换成红黑树提高性能。而当链表长度缩小到另一个阈值时(6),又会将红黑树转换回单向链表提高性能。
对于第3点的补充: 检查链表长度转换成红黑树之前,还会先检测当前数组数组是否到达一个阈值(64),如果没有到达这个容量,会放弃转换,先去扩充数组。所以上面也说了链表长度的阈值是7或8,因为会有一次放弃转换的操作。
8. 为什么HashMap是线程不安全的
- 多线程下扩容死循环。JDK1.7中的HashMap使用头插法插入元素,在多线程的环境下,扩容的时候有可能导致环形链表的出现,形成死循环。因此JDK1.8使用尾插法插入元素,在扩容时会保持链表元素原本的顺序,不会出现环形链表的问题。
- 多线程的put可能导致元素的丢失。多线程同时执行put操作,如果计算出来的索引位置是相同的,那会造成前一个key被后一个key覆盖,从而导致元素的丢失。此问题在JDK1.7和JDK1.8中都存在。
put和get并发时,可能导致get为null。线程1执行put时,因为元素个数超出threshold而导致rehash,线程2此时执行get,有可能导致这个问题,此问题在JDK1.7和JDK1.8中都存在。
9. HashMap和HashTable的区别
线程安全:Hashtable是一个线程安全的Map实现;但HashMap是线程不安全的Map实现,所以HashMap比Hashtable的性能高一点。
- 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 对的插入顺序一致
//HashMap中的内部类:Node
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
//LinkedHashMap中的内部类:Entry
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);
}
}
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)方法
Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
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的结构如下。
结构
可以说,ConcurrentHashMap 是一个二级哈希表。在一个总的哈希表下面,有若干个子哈希表。这样的二级结构,和数据库的水平拆分有些相似。
优势
采取了锁分段技术,每一个 Segment 就好比一个自治区,读写操作高度自治,Segment 之间互不影响。
Case1:不同 Segment 的并发写入【可以并发执行】
Case2:同一 Segment 的一写一读【可以并发执行】
Case3:同一 Segment 的并发写入【需要上锁】
由此可见,ConcurrentHashMap 当中每个 Segment 各自持有一把锁。在保证线程安全的同时降低了锁的粒度,让并发操作效率更高。
怎么做到线程安全的
- 底层采用分段的数组+链表实现
- 通过把整个 Map 分为N个 Segment,可以提供相同的线程安全,但是效率提升N倍,默认提升16倍。(读操作不加锁,由于 HashEntry 的 value 变量是 volatile 的,也能保证读取到最新的值。)
- Hashtable 的 synchronized 是针对整张 Hash 表的,即每次锁住整张表让线程独占,ConcurrentHashMap 允许多个修改操作并发进行,其关键在于使用了锁分离技术。
- 有些方法需要跨段,比如 size() 和 containsValue(),它们可能需要锁定整个表而不仅仅是某个段,这需要按顺序锁定所有段,操作完毕后,又按顺序释放所有段的锁。
- 扩容:段内扩容(段内元素超过该段对应 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方法:
- 为输入的 Key 做 Hash 运算,得到 hash 值(为了实现Segment均匀分布,进行了两次Hash)
- 通过 hash 值,定位到对应的 Segment 对象
- 再次通过 hash 值,定位到 Segment 当中数组的具体位置。
Put方法:
- 为输入的 Key 做 Hash 运算,得到 hash 值
- 通过 hash 值,定位到对应的 Segment 对象
- 获取可重入锁 ReentrantLock
- 再次通过 hash 值,定位到 Segment 当中数组的具体位置
- 插入或覆盖 HashEntry 对象
- 释放可重入锁 ReentrantLock
从步骤可以看出,ConcurrentHashMap 在读写时均需要二次定位。首先定位到 Segment,之后定位到 Segment 内的具体数组下标。
3. Java8及之后的实现:数组+链表+红黑树
JDK1.8 中 ConcurrentHashMap 的数据结构跟 JDK1.8 中 HashMap 的数据结构类似,都是数组+链表+红黑树,当链表长度大于8时,链表结构转为红黑树。
4. Java7和8区别
- 整体结构:
- 1.7:Segment[] + HashEntry[] + 链表
- 1.8:移除 Segment,数组 + 链表 + 红黑树,跟JDK 1.8 中 HashMap 结构类似
- 线程安全:1.8 中取消了 Segment 分段锁,采用 CAS + synchronized 来保证并发安全
- 1.7:Segment 继承 ReentrantLock
- 1.8:移除 Segment,使锁的粒度更小,Synchronized + CAS,synchronized 只锁定当前链表或红黑二叉树的首节点,只要节点 hash 不冲突,就不会产生并发,相比 JDK1.7 的 ConcurrentHashMap 效率又提升了 N 倍。
- put():
- 1.7:先定位 Segment,再定位桶,put 全程加锁,没有获取锁的线程提前找桶的位置,并最多自旋 64 次获取锁,超过则挂起。
- 1.8:由于移除了 Segment,类似 HashMap,可以直接定位到桶,拿到 first 节点后进行判断:①为空则 CAS 插入;②为 -1 则说明在扩容,则跟着一起扩容;③ else 则加锁这里会利用继承过来的锁的特性,在将数据插入指定的 HashEntry 位置时(尾插法),会通过继承 ReentrantLock 的 tryLock() 方法尝试去获取锁,如果获取成功就直接插入相应的位置,如果已经有线程获取该Segment的锁,那当前线程会以自旋的方式去继续的调用 tryLock() 方法去获取锁,超过指定次数就挂起,等待唤醒。
- get():基本类似,由于 value 声明为 volatile,保证了修改的可见性,因此不需要加锁。
- resize():
- 1.7:跟 HashMap 步骤一样,只不过是搬到单线程中执行,避免了 HashMap 在 1.7 中扩容时死循环的问题,保证线程安全。
- 1.8:支持并发扩容,HashMap 扩容在1.8中由头插改为尾插(为了避免死循环问题),ConcurrentHashmap 也是,迁移也是从尾部开始,扩容前在桶的头部放置一个 hash 值为 -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() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题