精选文章 集合类面试题

集合类面试题

作者:IT _ dancer 时间: 2021-02-05 09:44:33
IT _ dancer 2021-02-05 09:44:33
【摘要】集合类面试题 
1.Java集合框架是什么?说出一些集合框架的优点? 
  
每种编程语言中都有集合,最初的Java版本包含几种集合类:Vector、Stack、HashTable和Array。随着集合的广泛使用,Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类,Java已经经历了很久。它还包括在Java并发包中,阻塞接口以及它们的实现。...

集合类面试题

1.Java集合框架是什么?说出一些集合框架的优点?

 

每种编程语言中都有集合,最初的Java版本包含几种集合类:Vector、Stack、HashTable和Array。随着集合的广泛使用,Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类,Java已经经历了很久。它还包括在Java并发包中,阻塞接口以及它们的实现。

 

集合框架的部分优点如下:

 

(1)使用核心集合类降低开发成本,而非实现我们自己的集合类。

 

(2)随着使用经过严格测试的集合框架类,代码质量会得到提高。

 

(3)通过使用JDK附带的集合类,可以降低代码维护成本。

 

(4)复用性和可操作性。(省钱、省事、)

 

  1. 集合框架中的泛型有什么优点?

功能、代码、运行

 

Java1.5引入了泛型,所有的集合接口和实现都大量地使用它。(因为集合接口和实现使用,所以存在泛型)

 

(功能:)泛型允许我们为集合提供一个可以容纳的对象类型,因此,如果你添加其它类型的任何元素,它会在编译时报错。这避免了在运行时出现ClassCastException(类型转换异常,即JVM在检测到两个类型间转换不兼容时引发的运行时异常),因为你将会在编译时得到报错信息。

泛型也使得代码整洁,我们不需要使用显式转换和instanceOf(判断对象是否属于某个类型)操作符。它也给运行时带来好处,因为不会产生类型检查的字节码指令。

 

 

 

3.Java集合框架的基础接口有哪些?

 

Collection为集合层级的根接口。一个集合代表一组对象,这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。

 

Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模,被用来代表集合,就如一副牌。

 

List是一个有序集合,可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。

 

Map是一个将key映射到value的对象.一个Map不能包含重复的key:每个key最多只能映射一个value。

 

一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。

 

4.为何Collection不从Cloneable和Serializable接口继承?

 

Collection接口指定一组对象,对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如,一些如List的Collection实现允许重复的元素,而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而,把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。

 

当与具体实现打交道的时候,克隆或序列化的语义和含义才发挥作用。所以,具体实现应该决定如何对它进行克隆或序列化,或它是否可以被克隆或序列化。

 

在所有的实现中授权克隆和序列化,最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。

 

 

5.Iterator是什么?

 

Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。

 

6.Enumeration和Iterator接口的区别?

 

 

Enumeration(枚举类)的速度是Iterator的两倍,也使用更少的内存。Enumeration是非常基础的,也满足了基础的需要。但是,与Enumeration相比,Iterator更加安全,因为当一个集合正在被遍历的时候,它会阻止其它线程去修改集合。

 

迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素,而Enumeration不能做到。为了使它的功能更加清晰,迭代器方法名已经经过改善。

7.Iterater和ListIterator之间有什么区别?

Iterator (迭代器) 是一个接口,它的作用就是遍历容器中的所有元素。

ListIterator(迭代器)是一个更加强大的Iterator的子类型。

(1)我们可以使用Iterator来遍历Set和List集合,而ListIterator只能遍历List。

 

(2)Iterator只可以向前遍历,而ListIterator可以双向遍历。

 

(3)ListIterator从Iterator接口继承,然后添加了一些额外的功能,比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

 

8.遍历一个List有哪些不同的方式?

 

List strList = new ArrayList<>();

//使用for-each循环

for(String obj : strList){

  System.out.println(obj);

}

//using iterator

Iterator it = strList.iterator();

while(it.hasNext()){

  String obj = it.next();

  System.out.println(obj);

}

使用迭代器更加线程安全,因为它可以确保,在当前遍历的集合元素被更改的时候,它会抛出ConcurrentModificationException。

 

9.通过迭代器fail-fast属性,你明白了什么?

 

每次我们尝试获取下一个元素的时候,Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动,它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的(ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外)。

 

10.fail-fast与fail-safe有什么区别?

 

①Iterator的fail-fast属性与当前的集合共同起作用,因此它不会受到集合中任何改动的影响。Java.util包中的所有集合类都被设计为fail-fast的,而java.util.concurrent中的集合类都为fail-safe的。

 

②Fail-fast迭代器抛出ConcurrentModificationException,而fail-safe迭代器从不抛出ConcurrentModificationException。

 

11.在迭代一个集合的时候,如何避免ConcurrentModificationException?

 

在遍历一个集合的时候,我们可以使用并发集合类来避免ConcurrentModificationException,比如使用CopyOnWriteArrayList,而不是ArrayList。

12.在Java中,HashMap是如何工作的?

 

HashMap在Map.Entry静态内部类实现中存储key-value对。HashMap使用哈希算法,在put和get方法中,它使用hashCode()和equals()方法。当我们通过传递key-value对调用put方法的时候,HashMap使用Key hashCode()和哈希算法来找出存储key-value对的索引。Entry存储在LinkedList中,所以如果存在entry,它使用equals()方法来检查传递的key是否已经存在,如果存在,它会覆盖value,如果不存在,它会创建一个新的entry然后保存。当我们通过传递key调用get方法时,它再次使用hashCode()来找到数组中的索引,然后使用equals()方法找出正确的Entry,然后返回它的值。下面的图片解释了详细内容。

 

其它关于HashMap比较重要的问题是容量、负荷系数和阀值调整。HashMap默认的初始容量是32,负荷系数是0.75。阀值是为负荷系数乘以容量,无论何时我们尝试添加一个entry,如果map的大小比阀值大的时候,HashMap会对map的内容进行重新哈希,且使用更大的容量。容量总是2的幂,所以如果你知道你需要存储大量的key-value对,比如缓存从数据库里面拉取的数据,使用正确的容量和负荷系数对HashMap进行初始化是个不错的做法。

 

13.hashCode()和equals()方法有何重要性?

 

HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。当我们试着从HashMap中获取值的时候,这些方法也会被用到。如果这些方法没有被正确地实现,在这种情况下,两个不同Key也许会产生相同的hashCode()和equals()输出,HashMap将会认为它们是相同的,然后覆盖它们,而非把它们存储到不同的地方。同样的,所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复,所以正确实现它们非常重要。equals()和hashCode()的实现应该遵循以下规则:

 

(1)如果o1.equals(o2),那么o1.hashCode() == o2.hashCode()总是为true的。

 

(2)如果o1.hashCode() == o2.hashCode(),并不意味着o1.equals(o2)会为true。

 

14.我们能否使用任何类作为Map的key?

 

我们可以使用任何类作为Map的key,然而在使用它们之前,需要考虑以下几点:

 

(1)如果类重写了equals()方法,它也应该重写hashCode()方法。

 

(2)类的所有实例需要遵循与equals()和hashCode()相关的规则。请参考之前提到的这些规则。

 

(3)如果一个类没有使用equals(),你不应该在hashCode()中使用它。

 

(4)用户自定义key类的最佳实践是使之为不可变的,这样,hashCode()值可以被缓存起来,拥有更好的性能。不可变的类也可以确保hashCode()和equals()在未来不会改变,这样就会解决与可变相关的问题了。

 

比如,我有一个类MyKey,在HashMap中使用它。

 

//传递给MyKey的name参数被用于equals()和hashCode()中

MyKey key = new MyKey('Pankaj'); //assume hashCode=1234

myHashMap.put(key, 'Value');

// 以下的代码会改变key的hashCode()和equals()值

key.setName('Amit'); //assume new hashCode=7890

//下面会返回null,因为HashMap会尝试查找存储同样索引的key,而key已被改变了,匹配失败,返回null

myHashMap.get(new MyKey('Pankaj'));

那就是为何String和Integer被作为HashMap的key大量使用。

 

15.Map接口提供了哪些不同的集合视图?

 

Map接口提供三个集合视图:

 

(1)Set keyset():返回map中包含的所有key的一个Set视图。集合是受map支持的,map的变化会在集合中反映出来,反之亦然。当一个迭代器正在遍历一个集合时,若map被修改了(除迭代器自身的移除操作以外),迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除,从map中移除对应的映射。它不支持add和addAll操作。

 

(2)Collection values():返回一个map中包含的所有value的一个Collection视图。这个collection受map支持的,map的变化会在collection中反映出来,反之亦然。当一个迭代器正在遍历一个collection时,若map被修改了(除迭代器自身的移除操作以外),迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除,从map中移除对应的映射。它不支持add和addAll操作。

 

(3)Set> entrySet():返回一个map钟包含的所有映射的一个集合视图。这个集合受map支持的,map的变化会在collection中反映出来,反之亦然。当一个迭代器正在遍历一个集合时,若map被修改了(除迭代器自身的移除操作,以及对迭代器返回的entry进行setValue外),迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除,从map中移除对应的映射。它不支持add和addAll操作。

 

16.HashMap和HashTable有何不同?

 

(1)HashMap允许key和value为null,而HashTable不允许。

 

(2)HashTable是同步的,而HashMap不是。所以HashMap适合单线程环境,HashTable适合多线程环境。

 

(3)在Java1.4中引入了LinkedHashMap,HashMap的一个子类,假如你想要遍历顺序,你很容易从HashMap转向LinkedHashMap,但是HashTable不是这样的,它的顺序是不可预知的。

 

(4)HashMap提供对key的Set进行遍历,因此它是fail-fast的,但HashTable提供对key的Enumeration进行遍历,它不支持fail-fast。

 

(5)HashTable被认为是个遗留的类,如果你寻求在迭代的时候修改Map,你应该使用CocurrentHashMap。

 

17.如何决定选用HashMap还是TreeMap?

 

对于在Map中插入、删除和定位元素这类操作,HashMap是最好的选择。然而,假如你需要对一个有序的key集合进行遍历,TreeMap是更好的选择。基于你的collection的大小,也许向HashMap中添加元素会更快,将map换为TreeMap进行有序key的遍历。

 

18.ArrayList和Vector有何异同点?

 

ArrayList和Vector在很多时候都很类似。

 

(1)两者都是基于索引的,内部由一个数组支持。

 

(2)两者维护插入的顺序,我们可以根据插入顺序来获取元素。

 

(3)ArrayList和Vector的迭代器实现都是fail-fast的。

 

(4)ArrayList和Vector两者允许null值,也可以使用索引值对元素进行随机访问。

 

以下是ArrayList和Vector的不同点。

 

(1)Vector是同步的,而ArrayList不是。然而,如果你寻求在迭代的时候对列表进行改变,你应该使用CopyOnWriteArrayList。

 

(2)ArrayList比Vector快,它因为有同步,不会过载。

 

(3)ArrayList更加通用,因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

 

19.Array和ArrayList有何区别?什么时候更适合用Array?

 

Array可以容纳基本类型和对象,而ArrayList只能容纳对象。

 

Array是指定大小的,而ArrayList大小是固定的。

 

Array没有提供ArrayList那么多功能,比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择,但也有些时候Array比较好用。

 

(1)如果列表的大小已经指定,大部分情况下是存储和遍历它们。

 

(2)对于遍历基本数据类型,尽管Collections使用自动装箱来减轻编码任务,在指定大小的基本类型的列表上工作也会变得很慢。

 

(3)如果你要使用多维数组,使用[][]比List<>>更容易。<>

 

20.ArrayList和LinkedList有何区别?

 

ArrayList和LinkedList两者都实现了List接口,但是它们之间有些不同。

 

(1)ArrayList是由Array所支持的基于一个索引的数据结构,所以它提供对元素的随机访问,复杂度为O(1),但LinkedList存储一系列的节点数据,每个节点都与前一个和下一个节点相连接。所以,尽管有使用索引获取元素的方法,内部实现是从起始点开始遍历,遍历到索引的节点然后返回元素,时间复杂度为O(n),比ArrayList要慢。

 

(2)与ArrayList相比,在LinkedList中插入、添加和删除一个元素会更快,因为在一个元素被插入到中间的时候,不会涉及改变数组的大小,或更新索引。

 

(3)LinkedList比ArrayList消耗更多的内存,因为LinkedList中的每个节点存储了前后节点的引用。

 

 

21.EnumSet是什么?

 

java.util.EnumSet是使用枚举类型的集合实现。当集合创建时,枚举集合中的所有元素必须来自单个指定的枚举类型,可以是显示的或隐示的。EnumSet是不同步的,不允许值为null的元素。它也提供了一些有用的方法,比如copyOf(Collection c)、of(E first,E…rest)和complementOf(EnumSet s)。

 

22.哪些集合类是线程安全的?

 

Vector、HashTable、Properties和Stack是同步类,所以它们是线程安全的,可以在多线程环境下使用。Java1.5并发API包括一些集合类,允许迭代时修改,因为它们都工作在集合的克隆上,所以它们在多线程环境中是安全的。

 

23.并发集合类是什么?

 

Java1.5并发包(java.util.concurrent)包含线程安全集合类,允许在迭代时修改集合。迭代器被设计为fail-fast的,会抛出ConcurrentModificationException。一部分类为:CopyOnWriteArrayList、 ConcurrentHashMap、CopyOnWriteArraySet。

 

24.BlockingQueue是什么?

 

Java.util.concurrent.BlockingQueue是一个队列,在进行检索或移除一个元素的时候,它会等待队列变为非空;当在添加一个元素时,它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分,主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间,或消费者有可用的对象,因为它都在BlockingQueue的实现类中被处理了。Java提供了集中BlockingQueue的实现,比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。

 

25.队列和栈是什么,列出它们的区别?

 

栈和队列两者都被用来预存储数据。java.util.Queue是一个接口,它的实现类在Java并发包中。队列允许先进先出(FIFO)检索元素,但并非总是这样。Deque接口允许从两端检索元素。

 

栈与队列很相似,但它允许对元素进行后进先出(LIFO)进行检索。

 

Stack是一个扩展自Vector的类,而Queue是一个接口。

 

26.Collections类是什么?

 

Java.util.Collections是一个工具类仅包含静态方法,它们操作或返回集合。它包含操作集合的多态算法,返回一个由指定集合支持的新集合和其它一些内容。这个类包含集合框架算法的方法,比如折半搜索、排序、混编和逆序等。

 

27.Comparable和Comparator接口是什么?

 

如果我们想使用Array或Collection的排序方法时,需要在自定义类里实现Java提供Comparable接口。Comparable接口有compareTo(T OBJ)方法,它被排序方法所使用。我们应该重写这个方法,如果“this”对象比传递的对象参数更小、相等或更大时,它返回一个负整数、0或正整数。但是,在大多数实际情况下,我们想根据不同参数进行排序。比如,作为一个CEO,我想对雇员基于薪资进行排序,一个HR想基于年龄对他们进行排序。这就是我们需要使用Comparator接口的情景,因为Comparable.compareTo(Object o)方法实现只能基于一个字段进行排序,我们不能根据对象排序的需要选择字段。Comparator接口的compare(Object o1, Object o2)方法的实现需要传递两个对象参数,若第一个参数比第二个小,返回负整数;若第一个等于第二个,返回0;若第一个比第二个大,返回正整数。

 

27.Comparable和Comparator接口有何区别?

 

Comparable和Comparator接口被用来对对象集合或者数组进行排序。Comparable接口被用来提供对象的自然排序,我们可以使用它来提供基于单个逻辑的排序。

 

Comparator接口被用来提供不同的排序算法,我们可以选择需要使用的Comparator来对给定的对象集合进行排序。

 

28.我们如何对一组对象进行排序?

 

如果我们需要对一个对象数组进行排序,我们可以使用Arrays.sort()方法。如果我们需要排序一个对象列表,我们可以使用Collection.sort()方法。两个类都有用于自然排序(使用Comparable)或基于标准的排序(使用Comparator)的重载方法sort()。Collections内部使用数组排序方法,所有它们两者都有相同的性能,只是Collections需要花时间将列表转换为数组。

 

29.HashMap怎样解决hash冲突?

在Java编程语言中,最基本的结构就是两种,一种是数组,一种是模拟指针(引用),所有的数据结构都可以用这两个基本结构构造,HashMap也一样。

当程序试图将多个 key-value 放入 HashMap 中时,以如下代码片段为例:HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。当程序执行 map.put(String,Obect)方法 时,系统将调用String的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法,都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后,系统会根据该 hashCode 值来决定该元素的存储位置。

1.put()方法冲突

源码如下:

 

hash值冲突是发生在put()时,从源码可以看出,hash值是通过hash(key.hashCode())来获取的,当put的元素越来越多时,难免或出现不同的key产生相同的hash值问题,也即是hash冲突,当拿到一个hash值,通过indexFor(hash, table.length)获取数组下标,先查询是否存在该hash值,若不存在,则直接以Entry的方式存放在数组中,若存在,则再对比key是否相同,若hash值和key都相同,则替换value,若hash值相同,key不相同,则形成一个单链表,将hash值相同,key不同的元素以Entry的方式存放在链表中,这样就解决了hash冲突,这种方法叫做分离链表法,与之类似的方法还有一种叫做 开放定址法,开放定址法师采用线性探测(从相同hash值开始,继续寻找下一个可用的槽位)hashMap是数组,长度虽然可以扩大,但用线性探测法去查询槽位查不到时怎么办?因此hashMap采用了分离链表法。

2.get()方法冲突
源码如下:

 

有了上面存储时的hash算法作为基础,理解起来这段代码就很容易了。从上面的源代码中可以看出:从HashMap中get元素时,首先计算key的hashCode,找到数组中对应位置的某一元素,然后通过key的equals方法在对应位置的链表中找到需要的元素。

  当hashMap没出现hash冲突时,没有形成单向链表,get方法能够直接定位到元素,但是,出现冲突后,形成了单向链表,bucket里存放的不再是一个entry对象,而是一个entry对象链,系统只能顺序的遍历每个entry直到找到想要搜索的entry为止,这时,问题就来了,如果恰好要搜索的entry位于该entry链的最末端,那循环必须要进行到最后一步才能找到元素,此时涉及到一个负载因子的概念,hashMap默认的负载因子为0.75,这是考虑到存储空间查询时间上成本的一个折中值,增大负载因子,可以减少hash表(就是那个entry数组)所占用的内空间,但会增加查询数据的时间开销,而查询是最频繁的操作(put()和get()都用到查询);减小负载因子,会提高查询时间,但会增加hash表所占的内存空间。

  结合负载因子的定义公式可知,threshold就是在此loadFactor和capacity对应下允许的最大元素数目,超过这个数目就重新resize,以降低实际的负载因子。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时, resize后的HashMap容量是容量的两倍:

3.hashMap数组扩容

 当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,数组扩容这个操作也会出现在ArrayList中,这是一个常用的操作,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。

   那么HashMap什么时候进行扩容呢?当HashMap中的元素个数超过数组大小*loadFactor时,就会进行数组扩容,loadFactor的默认值为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小为16,那么当HashMap中元素个数超过16*0.75=12的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,扩容是需要进行数组复制的,复制数组是非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

30. 说一下 HashMap 的底层结构

HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元,每一个Entry包含一个key-value键值对。整体结构图:

 

HashMap由数组+链表组成的。

数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的,如果定位到的数组位置不含链表(当前entry的next指向null),那么对于查找,添加等操作很快,仅需一次寻址即可;如果定位到的数组包含链表,对于添加操作,其时间复杂度为O(n),首先遍历链表,存在即覆盖,否则新增;对于查找操作来讲,仍需遍历链表,然后通过key对象的equals方法逐一比对查找。所以,性能考虑,HashMap中的链表出现越少,性能才会越好。

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

 

 

我们都知道HashMap是线程不安全的,在多线程环境中不建议使用,但是其线程不安全主要体现在什么地方呢,本文将对该问题进行解密。

1.jdk1.7中的HashMap

在jdk1.8中对HashMap做了很多优化,这里先分析在jdk1.7中的问题,相信大家都知道在jdk1.7多线程环境下HashMap容易出现死循环,这里我们先用代码来模拟出现死循环的情况:

public class HashMapTest {

public static void main(String[] args) {
HashMapThread thread0 = new HashMapThread();
HashMapThread thread1 = new HashMapThread();
HashMapThread thread2 = new HashMapThread();
HashMapThread thread3 = new HashMapThread();
HashMapThread thread4 = new HashMapThread();
thread0.start();
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}

class HashMapThread extends Thread {
private static AtomicInteger ai = new AtomicInteger();
private static Map map = new HashMap<>();

@Override
public void run() {
while (ai.get() < 1000000) {
map.put(ai.get(), ai.get());
ai.incrementAndGet();
}
}
}

上述代码比较简单,就是开多个线程不断进行put操作,并且HashMap与AtomicInteger都是全局共享的。在多运行几次该代码后,出现如下死循环情形:

 

其中有几次还会出现数组越界的情况:

 

这里我们着重分析为什么会出现死循环的情况,通过jps和jstack命名查看死循环情况,结果如下:

 

从堆栈信息中可以看到出现死循环的位置,通过该信息可明确知道死循环发生在HashMap的扩容函数中,根源在transfer函数中,jdk1.7中HashMap的transfer函数如下:

void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry e : table) {
while(null != e) {
Entry next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}

总结下该函数的主要作用:

在对table进行扩容到newTable后,需要将原来数据转移到newTable中,注意10-12行代码,这里可以看出在转移元素的过程中,使用的是头插法,也就是链表的顺序会翻转,这里也是形成死循环的关键点。

下面进行详细分析。

1.1 扩容造成死循环分析过程

前提条件:

这里假设

  1. hash算法为简单的用key mod链表的大小。
  2. 最开始hash表size=2,key=3,7,5,则都在table[1]中。
  3. 然后进行resize,使size变成4。

未resize前的数据结构如下:

 

如果在单线程环境下,最后的结果如下:

 

这里的转移过程,不再进行详述,只要理解transfer函数在做什么,其转移过程以及如何对链表进行反转应该不难。

然后在多线程环境下,假设有两个线程A和B都在进行put操作。线程A在执行到transfer函数中第11行代码处挂起,因为该函数在这里分析的地位非常重要,因此再次贴出来。 

此时线程A中运行结果如下:

 

线程A挂起后,此时线程B正常执行,并完成resize操作,结果如下:

 

这里需要特别注意的点:由于线程B已经执行完毕,根据Java内存模型,现在newTable和table中的Entry都是主存中最新值:7.next=3,3.next=null。

此时切换到线程A上,在线程A挂起时内存中值如下:e=3,next=7,newTable[3]=null,代码执行过程如下:

newTable[3]=e ----> newTable[3]=3
e=next ----> e=7

此时结果如下:

 

继续循环:

e=7
next=e.next ----> next=3【从主存中取值】
e.next=newTable[3----> e.next=3【从主存中取值】
newTable[3]=e ----> newTable[3]=7
e=next ----> e=3

结果如下:

 

再次进行循环:

e=3
next=e.next ----> next=null
e.next=newTable[3] ----> e.next=7 即:3.next=7
newTable[3]=e ----> newTable[3]=3
e=next ----> e=null

注意此次循环:e.next=7,而在上次循环中7.next=3,出现环形链表,并且此时e=null循环结束。

结果如下:

 

在后续操作中只要涉及轮询hashmap的数据结构,就会在这里发生死循环,造成悲剧。

1.2 扩容造成数据丢失分析过程

遵照上述分析过程,初始时

 

线程A和线程B进行put操作,同样线程A挂起:

 

此时线程A的运行结果如下:

 

此时线程B已获得CPU时间片,并完成resize操作:

 

同样注意由于线程B执行完成,newTable和table都为最新值:5.next=null。

此时切换到线程A,在线程A挂起时:e=7,next=5,newTable[3]=null。

执行newtable[i]=e,就将7放在了table[3]的位置,此时next=5。接着进行下一次循环:

e=5
next=e.next ----> next=null,从主存中取值
e.next=newTable[1----> e.next=5,从主存中取值
newTable[1]=e ----> newTable[1]=5
e=next ----> e=null

将5放置在table[1]位置,此时e=null循环结束,3元素丢失,并形成环形链表。并在后续操作hashmap时造成死循环。

 

2.jdk1.8中HashMap

在jdk1.8中对HashMap进行了优化,在发生hash碰撞,不再采用头插法方式,而是直接插入链表尾部,因此不会出现环形链表的情况,但是在多线程的情况下仍然不安全,这里我们看jdk1.8中HashMap的put操作源码:

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null// 如果没有hash碰撞则直接插入元素
tab[i] = newNode(hash, key, valuenull);
else {
Node e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
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, valuenull);
if (binCount >= TREEIFY_THRESHOLD - 1// -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

这是jdk1.8中HashMap中put操作的主函数, 注意第6行代码,如果没有hash碰撞则会直接插入元素。如果线程A和线程B同时进行put操作,刚好这两条不同的数据hash值一样,并且该位置数据为null,所以这线程A、B都会进入第6行代码中。

假设一种情况,线程A进入后还未进行数据插入时挂起,而线程B正常执行,从而正常插入数据,然后线程A获取CPU时间片,此时线程A不用再进行hash判断了,问题出现:线程A会把线程B插入的数据给覆盖,发生线程不安全。

总结

首先HashMap是线程不安全的,其主要体现:

  1. 在jdk1.7中,在多线程环境下,扩容时会造成环形链或数据丢失。
  2. 在jdk1.8中,在多线程环境下,会发生数据覆盖的情况。

32. 说一下 HashSet 的实现原理?

1. HashSet是基于HashMap实现的,默认构造函数是构建一个初始容量为16,负载因子为0.75 的HashMap。封装了一个 HashMap 对象来存储所有的集合元素,所有放入 HashSet 中的集合元素实际上由 HashMap 的 key 来保存,而 HashMap 的 value 则存储了一个 PRESENT,它是一个静态的 Object 对象。

2. 当我们试图把某个类的对象当成 HashMap的 key,或试图将这个类的对象放入 HashSet 中保存时,重写该类的equals(Object obj)方法和 hashCode() 方法很重要,而且这两个方法的返回值必须保持一致:当该类的两个的 hashCode() 返回值相同时,它们通过 equals() 方法比较也应该返回 true。通常来说,所有参与计算 hashCode() 返回值的关键属性,都应该用于作为 equals() 比较的标准。

3. HashSet的其他操作都是基于HashMap的。

33. List、Set、Map 之间的区别是什么?

List(列表)

List的元素以线性方式存储,可以存放重复对象,List主要有以下两个实现类:

1.ArrayList: 长度可变的数组,可以对元素进行随机的访问,向ArrayList中插入与删除元素的速度慢。JDK8中ArrayList扩容的实现是通过grow()方法里使用语句newCapacity = oldCapacity + (oldCapacity >> 1)(即1.5倍扩容)计算容量,然后调用Arrays.copyof()方法进行对原数组进行复制。

2. LinkedList: 采用链表数据结构,插入和删除速度快,但访问速度慢。

 

Set(集合)

Set中的对象不按特定(HashCode)的方式排序,并且没有重复对象,Set主要有以下两个实现类:

1.HashSet:HashSet按照哈希算法来存取集合中的对象,存取速度比较快。当HashSet中的元素个数超过数组大小*loadFactor(默认值为0.75)时,就会进行近似两倍扩容(newCapacity = (oldCapacity << 1) + 1)。

2.TreeSet:TreeSet实现了SortedSet接口,能够对集合中的对象进行排序。

 

Map(映射)

Map是一种把键对象和值对象映射的集合,它的每一个元素都包含一个键对象和值对象。Map主要有以下实现类:

1. HashMap:HashMap基于散列表实现,其插入和查询的开销是固定的,可以通过构造器设置容量和负载因子来调整容器的性能。

2. LinkedHashMap:类似于HashMap,但是迭代遍历它时,取得的顺序是其插入次序,或者是最近最少使用(LRU)的次序。

3. TreeMap:TreeMap基于红黑树实现。查看时,它们会被排序。TreeMap是唯一的带有subMap()方法的Map,subMap()可以返回一个子树。

 

 

勿删,copyright占位
分享文章到微博
分享文章到朋友圈

上一篇:Verilog-AMS数据类型---wreal

下一篇:程序执行原理(科普)

您可能感兴趣

  • delphi class of 类引用

    Type  TControlCls = Class of TControl;function CreateComponent(ControlCls: TControlCls): TControl;begin  result:=ControlCls.Create(Form1);  ...

  • C#局域网聊天软件 适合公司内部聊天 类qq旺旺 可实时监控桌面 商用

    安装环境:服务器window2000/2003  数据库SQL2005/2008  微软net framework 2.0 EM企业通是基于.net 2.0框架C#语言编写的即时消息软件(服务器和客户端)。支持上百万用户的连接,数据库采用SQL Server 2005及以上版本。客户端采用TCP协议连接服务器,文件传输和音视频采用UDP...

  • SpringBoot学习15:springboot异常处理方式5(通过实现HandlerExceptionResolver类)

    修改异常处理方式4中的全局异常处理controller package com.bjsxt.exception; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configurati...

  • System.Data 命名空间里类的摘要(未完)

    DataSet:表示数据在内存中的缓存。DataSet 可以当作 在内存里 数据库。线程安全 :该类型对于多线程读操作是安全的。您必须使任何写操作同步。 DataView  :表示用于排序、筛选、搜索、编辑和导航的 DataTable 的可绑定数据的自定义视图。 DataView 的一个主要功能是允许数据与 Windows ...

  • Python中新式类 经典类的区别(即类是否继承object)

    首先什么是新式类 经典类呢: #新式类是指继承object的类 class A(object): ........... #经典类是指没有继承object的类 class A: ...........

  • DispatcherServlet的六种配置方式------Spring MVC核心配置类

    DispatcherServlet的六种配置方式,适用于直接使用Spring MVC框架,而不是Spring Boot集成 Spring MVC 和其他许多WEB框架类似,Spring MVC也是围绕前端控制器模式设...

  • 【opencart3源码分析】税收类tax.php

    <?php namespace Cart; /** * 税收类 * @package Cart */ final class Tax { private $tax_rates = array(); // 注册配置类和数据库类 public function __construct($registry) { $this->conf...

  • Java集合(一、HashMap)

    参考:https://juejin.im/post/5b5bf507f265da0fa42ce89e   要点总结 1.HashMap内部数据元素(Map.Entry<key,value>)的存储采用的是数组+链表+红黑树(JDK8新增)的形式存储的,并且存储顺序是无序的,如图一所示,数组上每个节点所存在的元素的个数是不一定的;实现 M...

CSDN

CSDN

中国开发者社区CSDN (Chinese Software Developer Network) 创立于1999年,致力为中国开发者提供知识传播、在线学习、职业发展等全生命周期服务。

华为云40多款云服务产品0元试用活动

免费套餐,马上领取!
集合类面试题介绍:华为云为您免费提供集合类面试题在博客、论坛、帮助中心等栏目的相关文章,同时还可以通过 站内搜索 查询更多集合类面试题的相关内容。| 移动地址: 集合类面试题 | 写博客