88366

java集合总结

<h2>1.Java集合简介</h2>

1.1集合的来源

  在学习了数组之后,我们发现有些Question是数组不能解决的,比如数组的长度是固定的、只能存储同一种类型、操作数据的方法不能满足需求,当你的需求有变化之后,就不再适合了,所以就推出了集合。

  集合类存放于 Java.util 包中,主要有 3 种:set(集)、list(列表包含 Queue)和 map(映射)。

1.2集合架构图

1.3常见的数据结构

 A:栈 先进后出

 B:队列 先进先出

   C:数组 查询快,增删慢

   D:链表 查询慢,增删快

<h2>二.集合的使用</h2>

1.集合

  接口Collection 

    接口 List(可重复的,有序)   

  add(Object o)
               add(int index,Object o)
               addAll(List list)
              remove(Object o)
              remove(int index)
              get(int index)
              clear()
              contains(Object o)
              isEmpty()
      实现类 ArrayList   同上
         LinkedList
             addFirst(Object o)
             addLast(Obejct o)
             getFirst()
             getLast()
             removeFirst()
                                     removeLast()

  接口 Set
    唯一,无序的
    实现类HashSet 

        


          TreeSert  

<table class="memberSummary" style="height: 448px; border-color: #9bb14d; border-width: 0px; width: 522px; border-style: solid;" summary="Method Summary table, listing methods, and an explanation" border="0" cellspacing="0" cellpadding="3"><tbody><tr id="i0" class="altColor"><td class="colFirst">boolean</td> <td class="colLast">add(E e) 将指定的元素添加到此集合(如果尚未存在)。 </td> </tr><tr id="i1" class="rowColor"><td class="colFirst">boolean</td> <td class="colLast">addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合中。 </td> </tr><tr id="i3" class="rowColor"><td class="colFirst">void</td> <td class="colLast">clear() 从此集合中删除所有元素。 </td> </tr><tr id="i4" class="altColor"><td class="colFirst">Object</td> <td class="colLast">clone() 返回此 TreeSet实例的浅拷贝。 </td> </tr><tr id="i5" class="rowColor"><td class="colFirst">Comparator<? super E></td> <td class="colLast">comparator() 返回用于对该集合中的元素进行排序的比较器,或<tt>null,</tt>如果此集合使用其元素的natural ordering 。 </td> </tr><tr id="i6" class="altColor"><td class="colFirst">boolean</td> <td class="colLast">contains(Object o) 如果此集合包含指定的元素,则返回 true 。 </td> </tr><tr id="i14" class="altColor"><td class="colFirst">boolean</td> <td class="colLast">isEmpty() 如果此集合不包含元素,则返回 true 。 </td> </tr><tr id="i18" class="altColor"><td class="colFirst">E</td> <td class="colLast">pollFirst() 检索并删除第一个(最低)元素,或返回 null如果该集合为空。 </td> </tr><tr id="i19" class="rowColor"><td class="colFirst">E</td> <td class="colLast">pollLast() 检索并删除最后一个(最高)元素,如果此集合为空,则返回 null 。 </td> </tr><tr id="i20" class="altColor"><td class="colFirst">boolean</td> <td class="colLast">remove(Object o) 如果存在,则从该集合中删除指定的元素。  </td> </tr></tbody></table>

  接口Map
    HashMap put(Object key,Object value)
      get(Object key)
      remove(Object key)
      keySet() 键的集合
      Set entraySet() 键值对的集合
      getKey()获取键
      getValue()获取值

2.迭代器

 所有的新技术都是为了解决Question而生的。。以前for循环遍历不同的集合时需要用不同的方法来遍历,需要关心集合的底层使用的数据结构,而引入了迭代器就可以不用关心这些。。。

  迭代器是Iterator接口:该接口中有三个核心方法 ,维护指针可以向下移动(next),移动到指定位置后,取出当前位置的元素(next),以及重置指针操作remove。

  Question1:为什么一定要去实现Iterable这个接口呢? 为什么不直接实现Iterator接口呢?    答:看一下JDK中的集合类,比如List一族或者Set一族, 都是实现了Iterable接口,但并不直接实现Iterator接口,而是通过内部类实现呢。 我觉得是这样,因为Iterator接口的核心方next()或者hasNext()是依赖于迭代器的具体迭代集合来的。如果Collection直接实现Iterator接口,势必导致集合子类ArrayList,LinkedList,hashset对象中包含以前Collection接口的一样的数据结构,而现实是ArrayList是基于数组,LinkedList是基于链表的两种完全不一样的数据结构。所有具体迭代器实例是各自集合类内部实现Iterator接口来实现。并通过集合类实现iterable接口来想外提供这个接口。

  Question2:为什么数组和集合可以使用for循环进行迭代遍历?

<em id="__mceDel" style="color: #494949; font-family: -apple-system, BlinkMacSystemFont, 'PingFang SC', Helvetica, Tahoma, Arial, 'Hiragino Sans GB', 'Microsoft YaHei', 微软雅黑, sans-serif; font-size: 14.6667px; white-space: pre-wrap;"> 解析:所有的数组和集合都实现了Iterable接口,Iterable接口中只有一个方法,iterator方法返回值类型是Iterator类型,我们将思路转到Iterator,我们发现该接口三个方法。hasNext,next和remove,最主要的是hasNext和next。他们在底层帮我们去维护的可以被迭代数组或者集合的迭代策略。</em>

fail-fast机制?

  https://blog.csdn.net/chenssy/article/details/38151189

3.Collections

  Collection和Coolections的区别?

     1、Collection是集合类的上级接口,继承与他有关的接口主要有List和Set

<em id="__mceDel">     2、Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作</em>

Collections的主要方法有:混排(Shuffling)、反转(Reverse)、替换所有的元素(fill)、拷贝(copy)、返回Collections中最小元素(min)、返回Collections中最大元素(max)、返回指定源列表中最后一次出现指定目标列表的起始位置(lastIndexOfSubList)、返回指定源列表中第一次出现指定目标列表的起始位置(IndexOfSubList)、根据指定的距离循环移动指定列表中的元素(Rotate)

4.遍历集合

<h2>三.集合的底层原理</h2>

https://blog.csdn.net/qq_25868207/article/details/55259978

<h2>四.总结</h2>

ArrayList:

<ul><li>底层实现是数组</li> <li>ArrayList的默认初始化容量是10,每次扩容时候增加原先容量的一半,也就是变为原来的1.5倍</li> <li>在增删时候,需要数组的拷贝复制(navite 方法由C/C++实现)</li> </ul>

LinkedList:

<ul><li>底层实现是双向链表[双向链表方便实现往前遍历]</li> </ul>

Vector:

<ul><li>底层是数组,现在已少用,被ArrayList替代,原因有两个: <ul><li>Vector所有方法都是同步,有性能损失。</li> <li>Vector初始length是10 超过length时 以100%比率增长,相比于ArrayList更多消耗内存。</li> <li>参考资料:https://www.zhihu.com/question/31948523/answer/113357347</li> </ul></li> </ul>

总的来说:查询多用ArrayList,增删多用LinkedList。

ArrayList增删慢不是绝对的(在数量大的情况下,已测试):

<ul><li>如果增加元素一直是使用add()(增加到末尾)的话,那是ArrayList要快</li> <li>一直删除末尾的元素也是ArrayList要快【不用复制移动位置】</li> <li>至于如果删除的是中间的位置的话,还是ArrayList要快!</li> <li><em id="__mceDel">但一般来说:增删多还是用LinkedList,因为上面的情况是极端的~</em></li> </ul><h2>五 集合面试题</h2> <h2>1)说说常见的集合有哪些吧?</h2>

答:Map接口和Collection接口是所有集合框架的父接口:

<ol><li>Collection接口的子接口包括:Set接口和List接口</li> <li>Map接口的实现类主要有:HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等</li> <li>Set接口的实现类主要有:HashSet、TreeSet、LinkedHashSet等</li> <li>List接口的实现类主要有:ArrayList、LinkedList、Stack以及Vector等</li> </ol><hr /><h2>2)HashMap与HashTable的区别?</h2>

答:

<ol><li>

HashMap没有考虑同步,是线程不安全的;Hashtable使用了synchronized关键字,是线程安全的;

</li> <li>

HashMap允许K/V都为null;后者K/V都不允许为null;

</li> <li>

HashMap继承自AbstractMap类;而Hashtable继承自Dictionary类;

</li> </ol><hr /><h2>3)HashMap的put方法的具体流程?</h2> <blockquote>

图引用自:https://blog.csdn.net/u011240877/article/details/53358305

</blockquote>

答:下面先来分析一下源码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i; // 1.如果table为空或者长度为0,即没有元素,那么使用resize()方法扩容 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 2.计算插入存储的数组索引i,此处计算方法同 1.7 中的indexFor()方法 // 如果数组为空,即不存在Hash冲突,则直接插入数组 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // 3.插入时,如果发生Hash冲突,则依次往下判断 else { HashMap.Node<K,V> e; K k; // a.判断table[i]的元素的key是否与需要插入的key一样,若相同则直接用新的value覆盖掉旧的value // 判断原则equals() - 所以需要当key的对象重写该方法 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; // b.继续判断:需要插入的数据结构是红黑树还是链表 // 如果是红黑树,则直接在树中插入 or 更新键值对 else if (p instanceof HashMap.TreeNode) e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 如果是链表,则在链表中插入 or 更新键值对 else { // i .遍历table[i],判断key是否已存在:采用equals对比当前遍历结点的key与需要插入数据的key // 如果存在相同的,则直接覆盖 // ii.遍历完毕后任务发现上述情况,则直接在链表尾部插入数据 // 插入完成后判断链表长度是否 > 8:若是,则把链表转换成红黑树 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); 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; } } // 对于i 情况的后续操作:发现key已存在,直接用新value覆盖旧value&返回旧value if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; // 插入成功后,判断实际存在的键值对数量size > 最大容量 // 如果大于则进行扩容 if (++size > threshold) resize(); // 插入成功时会调用的方法(默认实现为空) afterNodeInsertion(evict); return null; }

图片简单总结为:

    <hr /><h2>4)HashMap的扩容操作是怎么实现的?</h2>

答:通过分析源码我们知道了HashMap通过resize()方法进行扩容或者初始化的操作,下面是对源码进行的一些简单分析:

/** * 该函数有2中使用情况:1.初始化哈希表;2.当前数组容量过小,需要扩容 */ final Node<K,V>[] resize() { Node<K,V>[] oldTab = table;// 扩容前的数组(当前数组) int oldCap = (oldTab == null) ? 0 : oldTab.length;// 扩容前的数组容量(数组长度) int oldThr = threshold;// 扩容前数组的阈值 int newCap, newThr = 0; if (oldCap > 0) { // 针对情况2:若扩容前的数组容量超过最大值,则不再扩容 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } // 针对情况2:若没有超过最大值,就扩容为原来的2倍(左移1位) else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } // 针对情况1:初始化哈希表(采用指定或者使用默认值的方式) else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 计算新的resize上限 if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; if (oldTab != null) { // 把每一个bucket都移动到新的bucket中去 for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; } <hr /><h2>5)HashMap是怎么解决哈希冲突的?</h2> <blockquote>

参考资料:https://juejin.im/post/5ab99afff265da23a2291dee

</blockquote>

答:在解决这个Question之前,我们首先需要知道什么是哈希冲突,而在了解哈希冲突之前我们还要知道什么是哈希才行;

<h3>什么是哈希?</h3>

Hash,一般翻译为“散列”,也有直接音译为“哈希”的,这就是把任意长度的输入通过散列算法,变换成固定长度的输出,该输出就是散列值(哈希值);这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

所有散列函数都有如下一个基本特性:根据同一散列函数计算出的散列值如果不同,那么输入值肯定也不同。但是,根据同一散列函数计算出的散列值如果相同,输入值不一定相同。

<h3>什么是哈希冲突?</h3>

当两个不同的输入值,根据同一散列函数计算出相同的散列值的现象,我们就把它叫做碰撞(哈希碰撞)。

<h3>HashMap的数据结构</h3>

在Java中,保存数据有两种比较简单的数据结构:数组和链表。数组的特点是:寻址容易,插入和删除困难;链表的特点是:寻址困难,但插入和删除容易;所以我们将数组和链表结合在一起,发挥两者各自的优势,使用一种叫做链地址法的方式可以解决哈希冲突:

   

这样我们就可以将拥有相同哈希值的对象组织成一个链表放在hash值所对应的bucket下,但相比于hashCode返回的int类型,我们HashMap初始的容量大小DEFAULT_INITIAL_CAPACITY = 1 << 4(即2的四次方16)要远小于int类型的范围,所以我们如果只是单纯的用hashCode取余来获取对应的bucket这将会大大增加哈希碰撞的概率,并且最坏情况下还会将HashMap变成一个单链表,所以我们还需要对hashCode作一定的优化

<h3>hash()函数</h3>

上面提到的Question,主要是因为如果使用hashCode取余,那么相当于参与运算的只有hashCode的低位,高位是没有起到任何作用的,所以我们的思路就是让hashCode取值出的高位也参与运算,进一步降低hash碰撞的概率,使得数据分布更平均,我们把这样的操作称为扰动,在JDK 1.8中的hash()函数如下:

static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 与自己右移16位进行异或运算(高低位异或) }

这比在JDK 1.7中,更为简洁,相比在1.7中的4次位运算,5次异或运算(9次扰动),在1.8中,只进行了1次位运算和1次异或运算(2次扰动);

<h3>JDK1.8新增红黑树</h3>    

通过上面的链地址法(使用散列表)扰动函数我们成功让我们的数据分布更平均,哈希碰撞减少,但是当我们的HashMap中存在大量数据时,加入我们某个bucket下对应的链表有n个元素,那么遍历时间复杂度就为O(n),为了针对这个Question,JDK1.8在HashMap中新增了红黑树的数据结构,进一步使得遍历复杂度降低至O(logn);

<h3>总结</h3>

简单总结一下HashMap是使用了哪些方法来有效解决哈希冲突的:

1. 使用链地址法(使用散列表)来链接拥有相同hash值的数据;
2. 使用2次扰动函数(hash函数)来降低哈希冲突的概率,使得数据分布更平均;
3. 引入红黑树进一步降低遍历的时间复杂度,使得遍历更快;

<hr /><h2>6)HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标?</h2>

答:hashCode()方法返回的是int整数类型,其范围为-(2 ^ 31)~(2 ^ 31 - 1),约有40亿个映射空间,而HashMap的容量范围是在16(初始化默认值)~2 ^ 30,HashMap通常情况下是取不到最大值的,并且设备上也难以提供这么多的存储空间,从而导致通过hashCode()计算出的哈希值可能不在数组大小范围内,进而无法匹配存储位置;

面试官:那怎么解决呢?

答:

<ol><li>

HashMap自己实现了自己的hash()方法,通过两次扰动使得它自己的哈希值高低位自行进行异或运算,降低哈希碰撞概率也使得数据分布更平均;

</li> <li>

在保证数组长度为2的幂次方的时候,使用hash()运算之后的值与运算(&)(数组长度 - 1)来获取数组下标的方式进行存储,这样一来是比取余操作更加有效率,二来也是因为只有当数组长度为2的幂次方时,h&(length-1)才等价于h%length,三来解决了“哈希值与数组大小范围不匹配”的Question;

</li> </ol>

面试官:为什么数组长度要保证为2的幂次方呢?

答:

<ol><li>

只有当数组长度为2的幂次方时,h&(length-1)才等价于h%length,即实现了key的定位,2的幂次方也可以减少冲突次数,提高HashMap的查询效率;

</li> <li>

如果 length 为 2 的次幂 则 length-1 转化为二进制必定是 11111……的形式,在于 h 的二进制与操作效率会非常的快,而且空间不浪费;如果 length 不是 2 的次幂,比如 length 为 15,则 length - 1 为 14,对应的二进制为 1110,在于 h 与操作,最后一位都为 0 ,而 0001,0011,0101,1001,1011,0111,1101 这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!这样就会造成空间的浪费。

</li> </ol>

面试官:那为什么是两次扰动呢?

答:这样就是加大哈希值低位的随机性,使得分布更均匀,从而提高对应数组存储下标位置的随机性&均匀性,最终减少Hash冲突,两次就够了,已经达到了高位低位同时参与运算的目的;

<hr /><h2>7)HashMap在JDK1.7和JDK1.8中有哪些不同?</h2>

答:

<table><thead><tr><th>不同</th><th>JDK 1.7</th><th>JDK 1.8</th> </tr></thead><tbody><tr><td>存储结构</td> <td>数组 + 链表</td> <td>数组 + 链表 + 红黑树</td> </tr><tr><td>初始化方式</td> <td>单独函数:inflateTable() </td> <td>直接集成到了扩容函数resize()中</td> </tr><tr><td>hash值计算方式</td> <td>扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算</td> <td>扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算</td> </tr><tr><td>存放数据的规则</td> <td>无冲突时,存放数组;冲突时,存放链表</td> <td>无冲突时,存放数组;冲突 & 链表长度 < 8:存放单链表;冲突 & 链表长度 > 8:树化并存放红黑树</td> </tr><tr><td>插入数据方式</td> <td>头插法(先讲原位置的数据移到后1位,再插入数据到该位置)</td> <td>尾插法(直接插入到链表尾部/红黑树)</td> </tr><tr><td>扩容后存储位置的计算方式</td> <td>全部按照原来方法进行计算(即hashCode ->> 扰动函数 ->> (h&length-1))</td> <td>按照扩容后的规律计算(即扩容后的位置=原位置 or 原位置 + 旧容量)</td> </tr></tbody></table><hr /><h2>8)为什么HashMap中String、Integer这样的包装类适合作为K?</h2>

答:String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性,能够有效的减少Hash碰撞的几率

<ol><li>都是final类型,即不可变性,保证key的不可更改性,不会存在获取hash值不同的情况</li> <li>内部已重写了equals()hashCode()等方法,遵守了HashMap内部的规范(不清楚可以去上面看看putValue的过程),不容易出现Hash值计算错误的情况;</li> </ol>

面试官:如果我想要让自己的Object作为K应该怎么办呢?

答:重写hashCode()equals()方法

<ol><li>

重写hashCode()是因为需要计算存储数据的存储位置,需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能,这样虽然能更快但可能会导致更多的Hash碰撞;

</li> <li>

重写equals()方法,需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x,x.equals(null)必须返回false的这几个特性,目的是为了保证key在哈希表中的唯一性

</li> </ol><hr /><h2>9)ConcurrentHashMap和Hashtable的区别?</h2>

答:ConcurrentHashMap 结合了 HashMap 和 HashTable 二者的优势。HashMap 没有考虑同步,HashTable 考虑了同步的Question。但是 HashTable 在每次同步执行时都要锁住整个结构。 ConcurrentHashMap 锁的方式是稍微细粒度的。

面试官:ConcurrentHashMap的具体实现知道吗?

<blockquote>

参考资料:http://www.importnew.com/23610.html

</blockquote>

答:在JDK1.7中,ConcurrentHashMap采用Segment + HashEntry的方式进行实现,结构如下:

    <ol><li>

该类包含两个静态内部类 HashEntry 和 Segment ;前者用来封装映射表的键值对,后者用来充当锁的角色;

</li> <li>

Segment 是一种可重入的锁 ReentrantLock,每个 Segment 守护一个HashEntry 数组里得元素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment 锁。

</li> </ol>

JDK1.8中,放弃了Segment臃肿的设计,取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现,结构如下:

   

插入元素过程(建议去看看源码):

<ol><li>如果相应位置的Node还没有初始化,则调用CAS插入相应的数据;</li> </ol>else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) break; // no lock when adding to empty bin } <ol start="2"><li>如果相应位置的Node不为空,且当前该节点不处于移动状态,则对该节点加synchronized锁,如果该节点的hash不小于0,则遍历链表更新节点或插入新节点;</li> </ol>if (fh >= 0) { binCount = 1; for (Node<K,V> e = f;; ++binCount) { K ek; if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { oldVal = e.val; if (!onlyIfAbsent) e.val = value; break; } Node<K,V> pred = e; if ((e = e.next) == null) { pred.next = new Node<K,V>(hash, key, value, null); break; } } } <ol start="3"><li>

如果该节点是TreeBin类型的节点,说明是红黑树结构,则通过putTreeVal方法往红黑树中插入节点;如果binCount不为0,说明put操作对数据产生了影响,如果当前链表的个数达到8个,则通过treeifyBin方法转化为红黑树,如果oldVal不为空,说明是一次更新操作,没有对元素个数产生影响,则直接返回旧值;

</li> <li>

如果插入的是一个新节点,则执行addCount()方法尝试更新元素个数baseCount;

</li> </ol><hr /><h2>10)Java集合的快速失败机制 “fail-fast”?</h2>

答:

是java集合的一种错误检测机制,当多个线程对集合进行结构上的改变的操作时,有可能会产生 fail-fast 机制。

例如:假设存在两个线程(线程1、线程2),线程1通过Iterator在遍历集合A中的元素,在某个时候线程2修改了集合A的结构(是结构上面的修改,而不是简单的修改集合元素的内容),那么这个时候程序就会抛出 ConcurrentModificationException 异常,从而产生fail-fast机制。

原因:迭代器在遍历时直接访问集合中的内容,并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化,就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前,都会检测modCount变量是否为expectedmodCount值,是的话就返回遍历;否则抛出异常,终止遍历。

解决办法:

1. 在遍历过程中,所有涉及到改变modCount值得地方全部加上synchronized。

2. 使用CopyOnWriteArrayList来替换ArrayList

<hr /><h2>11)ArrayList 和 Vector 的区别?</h2>

答:

这两个类都实现了 List 接口(List 接口继承了 Collection 接口),他们都是有序集合,即存储在这两个集合中的元素位置都是有顺序的,相当于一种动态的数组,我们以后可以按位置索引来取出某个元素,并且其中的数据是允许重复的,这是与 HashSet 之类的集合的最大不同处,HashSet 之类的集合不可以按索引号去检索其中的元素,也不允许有重复的元素。

ArrayList 与 Vector 的区别主要包括两个方面:

<ol><li>

同步性:
Vector 是线程安全的,也就是说它的方法之间是线程同步(加了synchronized 关键字)的,而 ArrayList 是线程不安全的,它的方法之间是线程不同步的。如果只有一个线程会访问到集合,那最好是使用 ArrayList,因为它不考虑线程安全的Question,所以效率会高一些;如果有多个线程会访问到集合,那最好是使用 Vector,因为不需要我们自己再去考虑和编写线程安全的代码。

</li> <li>

数据增长:
ArrayList 与 Vector 都有一个初始的容量大小,当存储进它们里面的元素的个人超过了容量时,就需要增加 ArrayList 和 Vector 的存储空间,每次要增加存储空间时,不是只增加一个存储单元,而是增加多个存储单元,每次增加的存储单元的个数在内存空间利用与程序效率之间要去的一定的平衡。Vector 在数据满时(加载因子1)增长为原来的两倍(扩容增量:原容量的 2 倍),而 ArrayList 在数据量达到容量的一半时(加载因子 0.5)增长为原容量的 (0.5 倍 + 1) 个空间。

</li> </ol><hr /><h2>12)ArrayList和LinkedList的区别?</h2>

答:

<ol><li>LinkedList 实现了 List 和 Deque 接口,一般称为双向链表;ArrayList 实现了 List 接口,动态数组;</li> <li>LinkedList 在插入和删除数据时效率更高,ArrayList 在查找某个 index 的数据时效率更高;</li> <li>LinkedList 比 ArrayList 需要更多的内存;</li> </ol>

面试官:Array 和 ArrayList 有什么区别?什么时候该应 Array 而不是 ArrayList 呢?

答:它们的区别是:

<ol><li>Array 可以包含基本类型和对象类型,ArrayList 只能包含对象类型。</li> <li>Array 大小是固定的,ArrayList 的大小是动态变化的。</li> <li>ArrayList 提供了更多的方法和特性,比如:addAll(),removeAll(),iterator() 等等。</li> </ol>

对于基本类型数据,集合使用自动装箱来减少编码工作量。但是,当处理固定大小的基本数据类型的时候,这种方式相对比较慢。

<hr /><h2>13)HashSet是如何保证数据不可重复的?</h2>

答:HashSet的底层其实就是HashMap,只不过我们HashSet是实现了Set接口并且把数据作为K值,而V值一直使用一个相同的虚值来保存,我们可以看到源码:

public boolean add(E e) { return map.put(e, PRESENT)==null;// 调用HashMap的put方法,PRESENT是一个至始至终都相同的虚值 }

由于HashMap的K值本身就不允许重复,并且在HashMap中如果K/V相同时,会用新的V覆盖掉旧的V,然后返回旧的V,那么在HashSet中执行这一句话始终会返回一个false,导致插入失败,这样就保证了数据的不可重复性;

<hr /><h2>14)BlockingQueue是什么?</h2>

答:

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

作者:我没有三颗心脏
链接:https://www.jianshu.com/p/939b8a672070
来源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

来源:博客园

作者:加伊的blog

链接:https://www.cnblogs.com/jiayiblog/p/11423424.html

Recommend