1、Java中的容器有哪些?
答:容器主要包括Collection 和 Map 两种,其中Collection 中存储着对象的集合,Map 中存储两个对象的映射表(键值对)。
图后续补充
2、详细介绍一下集合有哪些类,和各自的特点
- List
- ArrayList :是基于动态数组实现的,支持随机访问
- LinkedLits :基于双向链表实现的,只能顺序访问,但是支持快速的在链表中插入和删除元素,还可以用作栈,队列 和双向队列
- Vector :和ArrayList 类似,但是他是线程安全的。
- Set
- TreeSet :基于红黑树实现的,支持有序性操作,如根据一个范围查找元素。但是查找选了不如HashSet, 查找的时间复杂度为O(logN)
- HashSet :基于HashMap 实现的,支持快速的查找,但是不支持有序性操作。查找的时间复杂度为O(1)。失去了元素的插入顺序信息,就是说,用Iterator 去遍历的时候,得到的结果顺序可能是不确定的。
- LinkedHashSet 是 HashSet 的子类,不能过去内部是通过LinkedHashMap 实现的,内部使用双向链表维护插入顺序,因此是有序的。
- Queue
- LinkedList 可以用它来实现双向队列。
- PriorityQueue 基于堆结构实现,可以用它来实现优先队列。
- ArrayQueue基于数组实现,可以用它实现双端队列,也可以作为栈。
3、说一下Map 有哪些实现类和他们的各自特点
- TreeMap : 基于红黑树实现的,是有序的
- HashMap : jdk7 基于数组加链表实现,jdk8以后基于数组加链表加红黑树实现。
- HashTbale : 与 HashMap类似,但是是线程安全的
- LinkedHashMap : 继承于 HashMap,使用双向链表维护元素的顺序。
4、说一下ArrayList和LinkedList的区别?
ArrayList和LinkedList是List接口两种不同的实现方式,他们最本质的区别就是ArrayList 内部是用动态数组来存储元素,而LinkedList内部使用双线链表来存储元素。
根据存储元素的方式不同,导致他们的相对应的方法具有不同的时间复杂度。
首先对于ArrayList来说,随机查询get(int index)的时间复杂度是O(1),因为是直接从底层数组根据下标获取的,和数组的长度没有关系。这也是ArrayList最大的有点。
插入元素时add(E e)方法回自动将元素插到数组的末尾,如果不需要考虑扩容,时间复杂度是O(1),如果需要扩容,内部执行的Arrays.copyOf()是耗时的关键,因为需要把原有数组中的元素复制到扩容之后的新数组中。
如果指定位置插入元素 add(int index, E element) ,就会涉及到元素的赋值,因此时间复杂度为O(N);
对于删除元素,remove(int index) 方法回将指定位置的元素删除,这个步骤也会涉及到底层元素的复制,因此时间复杂度为O(n);
其次对于LinkedList来说,get(int index)的时间复杂度是O(N),因为每次查询都要遍历链表,由于是双向链表结结构,因此在遍历时,下标小于长度一半从前往后遍历,否则从后往前遍历,这样从理论上来说,时间可以节省一半。getFirst() 和 getLast()两个方法的时间复杂度是O(1)。因为first 和 last 在链表中是直接存储的。
插入元素时add(E e)方法默认将元素添加到链表的末尾,因此时间复杂度是O(1)。
如果指定位置插入元素 add(int index, E element),需要先遍历这个元素,然后在插入,时间复杂度为O(N)
对于删除元素,remove(int index),因为要考虑到查到元素,因此时间复杂度也是O(N)。
以上是通过时间复杂度对ArrayList和LinkedList的比较,需要注意的是,如果列表很大的时候,两个在内存上使用也是不同的,LinkedList 的每个元素都有更多开销,因为要存储上一个和下一个元素的地址,而ArrayList 没有这样的开销。但是ArrayList占用的内存是连续的,不论是否有那么多元素存储,内存都是已经占用了的。
5、说一下Vector 和 ArrayList 的区别?
Vector也是List接口的实现类之一,底层数据结构也是数组,同样具有查找快,增删满的特点。
Vector是线程安全的,源码中大量的方法都使用了synchronized关键字,这导致Vector的效率是比ArrayList要低的。
两者都采用了线性连续空间来存储,当需要扩容时,ArrayList默认扩容为原来的50%,而Vector默认扩容为原来的一倍。
//ArrayList
int newCapacity = oldCapacity + (oldCapacity >> 1);
// Vertor
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
Vector可以设置capacityIncrement,从字面理解就是capacity容量,Increment增加,容量增长的参数,而ArrayList不可以。
6、ArrayList实现 RandomAccess接口有何作用?
RandomAccess接口其实是空的,什么都没有定义,这个接口其实只是一个标记接口,只要List 实现了这个接口,就能支持快速随机访问。 Collections中的 binarySearch() 方法中,会判断是否实现RandomAccess接口来实行查找方式:实现了此接口mid 是直接通过数据下标获得,而未实现则会采用迭代器来遍历。LinkedList没有实现这个接口,是因为他自身链表的属性不支持快速随机访问。
推荐做法:实现了RandomAccess接口的列表就可以用for循环遍历,否则建议用iterator或者foreach遍历。
public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
return Collections.indexedBinarySearch(list, key);
else
return Collections.iteratorBinarySearch(list, key);
}
// indexedBinarySearch 中直接get值
Comparable<? super T> midVal = list.get(mid);
// iteratorBinarySearch中通过迭代器找中间值
ListIterator<? extends Comparable<? super T>> i = list.listIterator();
Comparable<? super T> midVal = get(i, mid);
7、ArrayList的扩容机制
先看一下成员属性:默认容量10,两个默认空数组,用于存储元素的elementData,以及一个int类型的size用于记录list所存的容量。
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData; // non-private to simplify nested class access
private int size;
看一下ArraytList 的三个构造器,这里只关注无参构造器,可以看到,调用无参构造器的时候,返回的是一个空数组。因此,第一次添加数据的话,就会触发扩容。
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
再来看看添加方法:
添加元素的时候,首先调用ensureCapacityInternal方法,并传值size+1,这个方法的作用是,首先判断当前数组是否为空,如果为空就将数组长度扩容为10,否则size+1 是否大于当前数组长度,如果大于,就进行扩容,否则就执行添加元素的操作。
public boolean add(E e) {
// 添加元素前首先调用ensureCapacityInternal方法,并传值size+1
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//调用了两个方法
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算容量,把当前数组 ,和size+1 传进去
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果当前数组为空,就返回max(DEFAULT_CAPACITY, minCapacity),其实就是数组首次扩容,容量为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 不为空就返回 size+1
return minCapacity;
}
//
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// 如果size+1 大于当前数组长度,就触发grow 方法。
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
最后看一下ArrayList扩容的核心方法grow():新容量采用位运算的方式,计算后值为旧容量的1.5倍。
复制元素的方法调用了本地方法System.arraycopy()
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 首次扩容时,newCapacity计算后仍为0,因此赋值为10
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果newCapacity 大于 MAX_ARRAY_SIZE ,就调用 hugeCapacity方法
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
总结下来,ArrayList的扩容发生时机有两种:一个是初始化后第一次插入元素,第一次扩容长度为10 ,另外一个是当前数组已经满了,在往里插元素的时候触发扩容。 其中调用的各种方法都是用于判断是否需要扩容。
8、comparable和comparator的区别?
Comparable是java.lang包下的一个接口,是一个内部比较器,实现了Comparable接口的类可以和自己比较,内部有一个compareTo(Object o)方法,返回值是int类型的 :
- 正整数:比较者大于被比较者
- 零 :两者相等
- 负整数:比较者小于被比较者
实现了Comparable接口的并重写了compareTo方法类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。
Comparator都是java.util包下的两个接口,可以称作是一个外部比较器;如果我们需要对某个类进行排序但是又不好修改这个类,那么就可以 定义一个实现了Comparator接口的类(类B),来作为类A的“比较器”,然后通过该比较器对类进行排序。
总结:实现两个接口都可以用来进行比较和排序,两者各有优缺点:Comparable 简单,但是需要修改源代码,Comparator虽然要另外实现一个比较器,但是不需要修改源码,并且在Comparator里面用户可以实现自己复杂统一的逻辑。
Comparable和Comparator区别(超详细对比分析)_只要酸菜不要鱼的博客-CSDN博客_comparable和comparator
9、介绍一下PriorityQueue?
PriorityQueue 优先队列,jdk1.5中被引入的,与Queue 的区别在于元素出队的顺序是和优先级相关的,即优先级高的元素总优先出队。
优先队列的使用:
public class TestPriorityQueue {
public static void main(String[] args) {
PriorityQueue priorityQueue = new PriorityQueue();
priorityQueue.offer(new Customer(1, "张三"));
priorityQueue.offer(new Customer(2, "李四"));
priorityQueue.offer(new Customer(1, "王五"));
priorityQueue.offer(new Customer(3, "张无"));
priorityQueue.offer(new Customer(1, "张四"));
while (!priorityQueue.isEmpty()) {
System.out.println(priorityQueue.poll());
}
}
}
class Customer implements Comparable<Customer> {
public int level;
public String name;
public Customer(int level, String name) {
this.level = level;
this.name = name;
}
@Override
public String toString() {
return "Customer{" + "level=" + level + ", name='" + name + '\'' + '}';
}
@Override
public int compareTo(Customer o) {
return o.level - level;
}
}
Print:
Customer{level=3, name='张无'}
Customer{level=2, name='李四'}
Customer{level=1, name='张三'}
Customer{level=1, name='王五'}
Customer{level=1, name='张四'}
PriorityQueue内部存储数据使用的是数组,初始化容量为11,对于扩容,当长度比较小时,容量乘以2+2,长度较大的时候,每次增加50%,内部通过堆排序实现有序,插入和删除堆顶元素的时间复杂度为O(log n);
【JDK源码】PriorityQueue源码分析_ΘLLΘ的博客-CSDN博客
10、说一下HashSet的实现原理
底层使用HashMap来存储数据,初始化的时候会创建一个HashMap对象,HashSet的值不允许重复,因此HashSet 的值是作为HashMap的key来存储在HashMap中的。从源码中可以看出,HashSet 的方法都是调用HashMap的方法;
HashSet 有两个特点:无序性和唯一性(允许一个null值);
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
// 底层使用HashMap来保存HashSet中所有元素。
private transient HashMap<E,Object> map;
// 定义一个虚拟的Object对象作为HashMap的value,将此对象定义为static final。
private static final Object PRESENT = new Object();
// 默认的无参构造器,实际底层会初始化一个空的HashMap,并使用默认初始容量为16和加载因子0.75。
public HashSet() {
map = new HashMap<E,Object>();
}
// 返回此set中的元素的数量(set的容量)。
public int size() {
return map.size();
}
// 如果此set不包含任何元素,则返回true。
public boolean isEmpty() {
return map.isEmpty();
}
// 如果此set包含指定元素,则返回true。
public boolean contains(Object o) {
return map.containsKey(o);
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
// 从此set中移除所有元素。此调用返回后,该set将为空。
//
// 底层实际调用HashMap的clear方法清空Entry中所有元素。
public void clear() {
map.clear();
}
11、HashMap的实现原理和底层数据结构是什么?
(hashmap相关的知识参考如下链接:面试阿里,HashMap 这一篇就够了_程序员囧辉的博客-CSDN博客)
jdk1.7 是数组加链表
jdk1.8 以后是数组加链表加红黑树
改成数组加链表加红黑树 主要是为了提升 在hash冲突严重时的查找性能,因为使用链表查询的性能是 O(n),而使用红黑树是 O(logn)。
为什么是红黑树而不是其他树,比如二叉查找树等?因为二叉查找树在特殊情况也会变成线性结构,存在深度遍历的问题,红黑树是平衡二叉树中的一种,插入新数据后会通过左旋 和 右旋 变色等保持黑节点平衡,解决查询深度问题。
对于插入情况:
默认情况下使用的是链表,当同一个数组索引位置的节点在新增后超过8个,就会触发链表转换为红黑树。(当前,转换的前提是此时数组的长度大于等于64,如果数组长度小于64,因为此时数据量相对较少,会首先选择扩容)
对于移除情况:
当同一个索引位置的节点在移除之后小于等于6个,并且该节点时红黑树节点时,会触发红黑树转化为链表节点。
链表转化成红黑树的阈值设置为8 是为什么呢?这个主要是和hashcode碰撞次数的泊松分布有关,主要是为了寻找一种时间和空间的平衡,负载因子为默认值0.75的情况下,单个槽内元素个数为8的概率小于百万分之一。
为什么不直接使用红黑树呢?因为红黑树的节点大小占用的内存大概是链表节点的两倍,节点比较少的时候,而红黑树的查找优势并不明显。
为什么红黑树转回链表的节点设置成6而不是8呢,因为如果节点在8个左右徘徊的时候,就会频繁的进行红黑树和链表的转换,这个是十分耗费性能的。
12、HashMap中有哪些重要的属性,他们都是用作什么?
存储元素的数组table,容量size,负载因子loadFactor,扩容阈值threshold
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
transient Node<K,V>[] table; //存储元素的 table
transient int size; // 容量
int threshold; // 扩容阈值 = 容量*负载因子
final float loadFactor; //负载因子
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
......
}
13、HashMap 的默认初始容量是多少?HashMap 的容量有什么限制吗?
当我们新建一个HashMap对象时,是没有初始化table容量的,只有当插入第一个节点的时候,才会对table进行初始化,避免不必要的空间浪费,table初始化的长度默认是16,当然,也可以在新建HashMap的时候传入一个默认的初始容量,根据实际使用情况设置初始容量其实才是最合理的方案。
而负载因子的默认初始值是0.75,这个也是在时间和空间上权衡的结果,如果负载因子过高,就可增加hash冲突的概率,如果值比较低,虽然hash冲突会降低,但是浪费的空间也增大了。
HashMap的容量需要是2 的N次方,HashMap会根据我们传入的容量计算出一个大于等于该容量的最小的2 的N次方,例如传 7,容量为8,传 9,容量为16
我们看如下的计算代码:
首先解释一下:
- >>>(无符号右移):例如 a >>> b 指的是将 a 向右移动 b 指定的位数,右移后左边空出的位用零来填充,移出右边的位被丢弃: 101 >>>1 = 010 010>>>1 = 001
- a |= b ,可以转成:a = a | b;-----> 101 | 010 = 111
通过五次移位和或操作,我们能够通过n的最高位的1,拿到2个1 、4个1……,最终可以得到一个低位全是1的值,这个值的最高位1 取决于n的值的大小。然后返回的时候在加1,得到的就是一个会比n大的 2 的N次方。
int n = cap - 1 这个是什么意思呢?其实这个是考虑了传入的cap值本身就是2 的N次方的情况,如果cap 本事就是 2 的N次方,一通计算之后,返回的值还是他本身。
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
14、HashMap的容量为什么必须是2 的N次方?
HashMap中计算元素所以的公式为 : int index = (n - 1) & hash; 当n 为 2 的N次方的时候,n-1的低位就全是1,那么此时任何值 和n-1进行&运算,得到的结果就是该值的低N位,这样就达到了取模的效果。
比如hash值为15,n为4,即2的2次方 。15&(4-1)=(1111&0011)=0011=3 ,而15%4=3;其实可以理解发现,对于二进制数,能够整除table的,都在高位(位数大于等于3的都算高位),剩下的低位值和4-1进行与运算,结果就是hash与table取模得到的值。
这么设计的原因就是因为位运算的效率要比取模更高。
15、HashMap的插入流程?
首先计算插入key的hash值,判断数组是否为空,如果为空,进行数组初始化,然后计算索引的位置:上一题说了,索引计算为(n-1)&hash ,判断索引的位置是否已经存在节点,不存在就直接放入,如果存在,就比较头节点的key 和插入的key是否一样,不一样就往后插入,涉及到链表或者红黑树,如果一样,就替换key的value。插入时,可能会涉及到数组table 的扩容、链表向红黑树的转化,以及红黑树的平衡调整。
流程图待补充
16、上述所说的计算key 的hash值,这个值是如何计算的?
计算代码如下所示,key.hashCode()是本地native方法,计算得到的值和自己的高16位进行或运算,得到最终的hash值。这么做的目的是为了在table长度比较小的时候,让高位也参与运算,并且不会有太大的开销。
比如:table=8,(8-1)=0111 ,在计算(n-1)&hash的时候,始终只有后三位参与&运算,这样就是说其实hash值也只有后三位参与了运算,hash值的高位无论这么变,都是无效的,而(h = key.hashCode()) ^ (h >>> 16)就会在后续计算索引的时候将高位也参与运算。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
17、简述HashMap的扩容流程
只描述最简单的扩容,完整流程图后续贴。
触发扩容的时候,创建一个新的数组,容量和扩容阈值都变为原来的两倍,table指向新的数组。然后遍历老的数组,在遍历到的索引位置,看是否有节点,是链表还是红黑树,遍历此索引位置的链表或者红黑树,插入到新数组的索引位置。
18、HashMap扩容时,如何定位新表的索引位置?
新表的索引位置是通过 e.hash & oldCap == 0 来进行判断的:
1、等于0的时候,将节点加到loHead链表的尾部,loHead链表放到“原索引位置”;
2、不等于0的时候,将节点加到hiHead链表的尾部,hiHead链表放到“原索引位置+oldCap”位置。
如:扩容前的table容量为16,扩容后为32,新表的n-1相比于旧表变化在高位多个一个1,因为计算索引 是用 (n-1)&hash 计算的,两个节点在旧表中在同一个索引位置,计算这两个节点在新表中的索引时,其实就只取决于高位多出来的这一位(标红位置),而这一位的值刚好是oldCap,因此,只存在e.hash & oldCap == 0 (原索引位置) 和 e.hash & oldCap == 1 (原索引位置+oldCap)两种情况。
其实,上述几题中有关HashMap索引位置的计算其实都是取模运算,只不过为了优化HashMap 的性能,采用了位运算的方式,而 (n-1)&hash 、e.hash & oldCap 这些计算都是优化后的位运算写法。
19、HashMap扩容时的死循环问题
导致多线程下HashMap扩容时死循环的根本原因就是 jdk1.7 的头插法扩容,而jdk1.8之后的尾插法就不会存在死循环的问题。
jdk1.7的扩容代码如下:(自己对着代码手动画一下)
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
20、在jdk1.8 对HashMap做了哪些优化?在jdk1.8 会存在多线程并发问题吗?
- 底层数据结构变成了“数组+链表+红黑树”,主要是在哈希冲突严重的时候,优化了查找性能O(n) -> O(logn)
- 计算table初始容量的时候,通过“五个移位+或等于运算”
- hash值的计算方式,简单的让高16位参与了运算
- 扩容采用尾插法代替头插法,避免死循环
jdk1.8虽然改用头插法解决了死循环的问题,但是仍然存在线程安全问题,比如在put操作过程中需要扩容,扩容时,线程1拿到了头结点和hash桶,此时CPU时间片让出,线程2获得时间片对这个hash桶进行更改,线程1重新获得时间片后,手上的是一个过期的桶和头节点,在线程1 对桶进行修改的时候,会覆盖之前线程的更改,造成数据丢失。(或者说,在判断当前桶链表个数的时候,有一个++size的操作,这个操作本身就不是线程安全的。)
21、说说LinkedHashMap :
LinkedHashMap继承自HashMap,因此LinkedHashMap的多种操作都是建立在HashMap的基础上,不同的是,LinkedHashMap自身维护了一个Entry的双向链表,保证了Entry 插入的顺序。
额外定义了一个 head 和 tail ,以及一个accessOrder(访问顺序为true,插入顺序为false)
如果不定义accessOrder这个属性,则默认赋值为false,是按照插入顺序来的,如果定义accessOrder属性为true,则按照访问顺序。(后面详细补充)
22、说一下HashMap 和 Hashtable 的区别?
- 线程安全性:Hashtable是线程安全的,而HashMap不是
- 效率问题:因为Hashtable使用synchronize 锁保证多线程安全,因此效率是不如HashMap
- 对null key 和null value 的支持:HashMap可以存储 null 值的 key 和value ,而Hashtable不允许null key 和 value,否则抛出NullPointerException
- 初始化容量大小和扩容容量不同:HashMap初始化为16,总是使用2的N次方,Hashtable初始化默认大小为11,每次扩容变成原来的2n+1。
- 底层数据结构:JDK1.8以后HashMap使用数组加链表加红黑树,而 Hashtable没有红黑树的机制。
23、说一下HashMap 和 TreeMap 区别?
HashMap 和 TreeMap都继承自AbstractMap,但是TreeMap 还实现了NavigableMap(这个实现了SortedMap),这使得TreeMap具有了对集合内元素的搜索能力和根据key进行排序的能力,默认是按照key升序排序,不过也可以初始化的时候指定排序比较器。
24、为什么HashMap中String、Integer这样的包装类适合作为Key?
首先,这些包装类都是由final关键字修饰的,保证了key的不可变性,避免出现key的hash值发生改变的现象。其次,他们内部都已经重写过hashcode() equal()方法;
如果要使用Object对象来作为key,需要重写
- hashcode() --> 计算hash值来确定存储位置
- equal()-->保证key的唯一性
- 因此非要使用对象来当做key也是可以的,但是要注意重写上述两个方法。
25、Queue 与 Deque 有什么区别?
Queue 为单端队列,一端插入元素,一端删除元素,遵循先入先出规则(FIFO),Queue拓展了Collection的接口,根据容量问题而导致操作失败后处理不同分成两类方法,一种是失败后抛出异常,一种是返回特殊值。
Queue 接口 | 抛出异常 | 返回特殊值 |
---|---|---|
插入队尾 | add(E e) | offer(E e) |
删除队首 | remove() | poll() |
查询队首元素 | element() | peek() |
Deque 为双端队列,在队列的首尾两端都可以插入或者删除元素,Deque拓展了Queue的接口,实现了在两端都可以进行插入和删除的方法。
Deque | 抛出异常 | 返回特殊值 |
插入队首 | addFirst(E e) | offerFirst(E e) |
插入队尾 | addLast(E e) | offerLast(E e) |
删除队首 | removeFirst() | pollFirst() |
删除队尾 | removeLast() | pollLast() |
查询队首元素 | getFirst() | peekFirst() |
查询队尾元素 | getLast() | peekLast() |
26.说一下 HashSet、LinkedHashSet 和 TreeSet 三者的异同?
HashSet、LinkedHashSet 和 TreeSet 都是 Set 接口的实现类,都能保证元素唯一,并且都不是线程安全的。他们的不同点:
HashSet、LinkedHashSet 和 TreeSet 的主要区别在于底层数据结构不同:
- HashSet 的底层数据结构是哈希表(基于 HashMap 实现)
- LinkedHashSet 的底层数据结构是链表和哈希表,元素的插入和取出顺序满足 FIFO
- TreeSet 底层数据结构是红黑树,元素是有序的,排序的方式有自然排序和定制排序
底层数据结构不同又导致这三者的应用场景不同:
- HashSet 用于不需要保证元素插入和取出顺序的场景
- LinkedHashSet 用于保证元素的插入和取出顺序满足 FIFO 的场景
- TreeSet 用于支持对元素自定义排序规则的场景
27、数组和list之间的转换方式:
- 数组转list:使用Arrays.asList(array)
- list转数组:使用List自带的toArray()方法
// list to array
List<String> list = new ArrayList<String>();
list.add("123");
list.add("456");
list.toArray();
// array to list
String[] array = new String[]{"123","456"};
Arrays.asList(array);
28、fail-fast(快速失败)机制是什么?
是Java集合中的一种错误检测机制,迭代集合的过程中如果该集合在结构上发生改变时,就有可能发生fail-fast,抛出ConcrurentModificationException异常。