List 接口

迭代器 Iterator 是什么？

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

Iterator 怎么使用？有什么特点？

Iterator 使用代码如下：

List<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
while(it.hasNext()){
String obj = it.next();
System.out.println(obj);
}

Iterator 的特点是只能单向遍历，但是更加安全，因为它可以却道，在当前遍历的集合元素被更改的时候，就会派出 ConcurrentModificationException 异常。

如何边遍历边移除 Collection 中的元素？

边遍历边修改 Collection 的唯一正确方式是使用 Iterator.remove(),如下

Iterator<Integer> it = list.iterator();
while(it.hasNext()){
/** do something*/
it.remove();

一种常见的错误代码如下：

for(Integer i: list){
list.remove(i);

运行以上代码会报 ConcurrentModificationException 异常。这是因为当使用 for（Integer i : list）语句时，会自动生成一个 iterator 来遍历该 list,但同时该 list 正在被 iterator.remove() 修改。Java 一般不允许一个线程在遍历 Clooection 时另一个线程修改它。

Iterator 和 ListIterator 有什么区别？

• Iterator 可以遍历 Set 和 List 集合，而 ListIterator 只能遍历 List。
• Iterator 只能单向遍历，而 ListIterator 可以双向遍历（向前/后遍历）。
• ListIterator 实现 Iterator 接口，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

遍历一个 List 有哪些不同的方式？每种方法的实现原理时什么？Java 中 List 遍历的最佳实践是什么？

遍历方式有以下几种：

1. for 循环遍历，基于计数器。在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素停止。
2. 迭代器遍历，Iterator。Iterator 是面向兑现的一个设计模式，目的是屏蔽不同数据集合的特点，统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。
3. foreach 循环遍历。foreach 内部也是采用的 Iterator 的方式实现，使用时不需要显式声明 Iterator 或计数器。有点时代码简洁，不易出错；缺点是只能做简单的遍历，不能在遍历过程中操作数据集合，例如删除、替换。

最佳实践： Java Collections 框架中提供了一个 RandomAccess 接口，用来标记 List 实现是否支持 Random Access。

• 如果一个数据集合实现了该接口，就意味着它支持 Random Access,按位置读取元素的平均实践复杂度为O（1）,如ArrayList
• 如果没有实现该接口，表示不支持 Random Access,如 LinkedList。推荐的做法就是，支持 Random Access 的列表可用 for 循环遍历，否则建议用 Iterator 或 foreach 遍历。

说一下 ArrayList 的优缺点

ArrayList的优点如下：

• ArrayList 底层以数组实现，是一张随机访问模式。ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。
• ArrayList 在顺序添加了一个元素的时候非常方便。

ArrayList 的缺点如下：

• 删除元素的时候，需要做一次元素复制操作，如果要赋值的元素很多，那么就会比较耗费性能。
• 插入元素的时候，也需要做一次元素复制操作，缺点同上

ArrayList 比较适合顺序添加、随机访问的场景。

如何实现数组和 List 之间的转换？

数组转 List: 使用 Arrays.asList(array) 进行转换。

List转数组： 使用 List 自带的 toArray() 方法。

ArrayList 和 LinkedList 的区别是什么？

• 数据结构实现： ArrayList 是动摇数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
• 随机访问效率： AarrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据存储方式，所以徐娅移动指针从前往后依次查找。
• 增加和删除效率： 在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，因为 ArrayList 增删操作要影响数组内的其他数据的下表。
• 内存空间占用，LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。
• 线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全

综合来说，在需要频繁读取集合中的元素是，更推荐使用 ArrayList,而在插入和删除操作较多时，更推荐使用 LinkedList。

补充：数据结构基础之双向链表

双线链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后续和直接前驱。所以，从双向链表中的任意一个节点开始，都可以很方便地访问它的前驱结点和后继结点。

ArrayList 和 Vector 的区别是什么？

这两个类都实现了 List 接口(list接口继承了 Collection 接口)，他们都是有序集合。

线程安全： Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。

性能： ArrayList 在性能方面要优于 Vector。

扩容： ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%.

Vector 类的所有方法都是同步的。可以由两个线程安全地访问一个 Vector 对象，但是一个线程访问 Vector 的话，代码要在同步操作上耗费大量的时间。ArrayList 不是同步的，所以在不需要保证线程安全时建议是哟个 ArrayList。

插入数据时，ArrayList、LinkedList、Vector 谁速度快？阐述 ArrayList、Vector、LinkedList 的存储性能和特性？

ArrayList、LinkedList、Vector 底层的实现都是使用数组方式存储数据。数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。

Vector 中的方法由于加入 Synchronized 修饰，因此 Vector 是线程安全容器，但性能上较 ArrayList 差。LinkedList 使用双向链表实现存储，按序号索引数据需要向前或后遍历，但插入数据时只需要记录当前项的前后项即可，所以 LinkedList 插入速度较快。

多线程场景下如何使用 ArrayList?

ArrayList 不是线程安全的，如果遇到多线程场景，可以通过 Collections.synchronizedList() 方法将其转换线程安全的容器后再使用，例如像下面这样：

List<String> synchronizedList = Collections.synchronizedList(list);
synchronizedList.add("aaa");
synchronizedList.add("bbb");

for(int i = 0;i < synchronizedList.size();i++）{
System.out.println(synchronizedList.get(i));
}

为什么 ArrayList 的 elementData 加上 transient 修饰？ ArrayList 中的数组定义如下：

private transient Object[] elementData;

再看一下 ArrayList 的定义：

public class ArrayList<E> extends AbstactList<E> implements List<E>,RandomAccess,Cloneable,java.io.Serializable

可以看到 ArrayList 实现了 Serializable 接口，这意味着 ArrayList 支持序列化。transient 的作用时说不希望 elementData 数组被序列化，重写了 writeObject 实现：

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
/** write out element count,and any hidden stuff */
int expectedModount = modCount;
s.defaultWriteObject();
/** write out array length */
s.writeInt(elementData.length);
for(int i = 0; i < size;i+){
throw new ConcurrentModificationException();
}

每次序列化时，先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍历 elementData,只序列化已存入的元素，这样既加快了序列化的速度，又减小了序列化之后的文件大小。

List 和 Set 的区别

List,Set 都是继承自 Collection 接口

List 特点： 一个有序（元素存入集合的顺序和去除的顺序一致）容器，元素可以重复，可以插入多个 null 元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。另外 List 支持 for 循环，也就是通过下表来遍历，也可以用迭代器，但是 set 只能用迭代，因为它无序，无法使用下标来取得想要的值。

Set 和 List 对比

Set： 检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。

List: h和数组类似，List 可以动态增长，查找元素效率高，插入删除元素效率低因为会引起其他元素位置改变。

Set 接口

说一下 HashSet 的实现原理？

HashSet 是基于 HashMap 实现的，HashSet 的值存放于 HashMap 的 key 上，HashMap 的 value 统一为 PRESENT，因此 HashSet 的实现比较简单，相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。

HashSet 如何检查重负？ Hash 是如何保证数据不可重复的？

向 HashSet 中 add() 元素时，判断元素是否存在的依据，不仅要比较 hash 值，同时还要结合 equals 方法比较。HashSet 中的 add() 方法会使用 HashMap 的 put() 方法。HashMap 的 key 是唯一的，由源码可以看出 HashSet 添加进去的值就是作为 HashMap 的 key,并且在 HashMap 中如果 K/V 相同时，会用新的 V ，然后返回旧 V，所以不会重复（HashMap 比较 key 是否相等是先比较 hashcode 再比较 equals）。

以下是 HashSet 部分源码：

private static final Object PRESENT = new Object();
private transient HashMap<E,Object> map；
public HashSet(){
map = new HashMap();
}
public boolean add(E e){
// 调用 HashMap 的 put 方法，PRESENT 是一个至始至终都相同的虚值
return map.put(e,PRESENT) == null;
}

hashCode() 与 equals() 的相关规定：

1. 如果两个对象相等，则 hashcode 一定也是相同的
2. 两个对象相等，对两个 equals 方法返回 true
3. 两个对象有相同的 hashcode 值，它们也不一定是相等的
4. 综上，equals方法被覆盖过，则 hashCode() 方法也必须被覆盖
5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode(),则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

== 与 equals 的区别

1. == 是判断两个变量或实力是不是指向同一个内存空间 equals 是判断连个变量或实力所指向的内存空间的值是不是相同
2. == 是指对内存地址进行比较，equals() 是对字符串的内容进行比较
3. == 指引用是否相同，equals()指的是值是否相同

HashSet 与 HashMap 的区别

HashMap	HashSet
实现了 Map 接口	实现了 Set 接口
存储键值对	仅存储对象
调用 put() 向 map 中添加元素	调用 add() 方法向 Set 中添加元素
HashMap 使用键(Key)计算 Hashcode	HashSet 使用成员对象来计算 hashcode 值，对于两个对象来说 hashcode 可能相同，所以 equals() 方法用来判断对象的相等性，如果两个对象不同的化，那么返回 false
HashMap 相对于 HashSet 较快，因为它是使用唯一的键获取对象	HashSet 较 HashMap 来说比较慢

Queue

BlockingQueue 是什么？

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

• 相同点：都是返回第一个元素，并在队列中删除返回的对象。
• 不同点： 如果没有用元素 poll() 会返回 null，而 remove() 会直接抛出 NoSuchElementException 异常。

代码示例：

Queue<String> queue = new LinkedList<String>();
queue.offer("string"); // add
System.out.println(queue.poll());
System.out.println(queue.remove());
System.out.println(queue.size());