java 集合

csdn

1.ArrayList和LinkList的区别

ArrayList（数组结构）：

优点：get和set调用花费常数时间，也就是查询的速度快；
缺点：新项的插入和现有项的删除代价昂贵，也就是添加删除的速度慢

LinkedList（链表结构）：
优点：新项的插入和和现有项的删除开销很小，即添加和删除的速度快
缺点：对get和set的调用花费昂贵，不适合做查询

2.Collection接口的remove()方法和Iterator接口的remove()方法区别？

①性能方面

Collection的remove方法必须首先找出要被删除的项，找到该项的位置采用的是单链表结构查询，单链表查询效率比较低，需要从集合中一个一个遍历才能找到该对象；

Iterator的remove方法结合next()方法使用，比如集合中每隔一项删除一项，Iterator的remove()效率更高

②容错方面

在使用Iterator遍历时，如果使用Collection的remove则会报异常，会出现ConcurrentModificationException，因为集合中对象的个数会改变而Iterator 内部对象的个数不会，不一致则会出现该异常

在使用Iterator遍历时，不会报错，因为iterator内部的对象个数和原来集合中对象的个数会保持一致

3 Array与ArrayList有什么区别

①Array是Java中的数组，声明数组有三种方式

在定义一个数组的时候，必须指定这个数组的数据类型及数组的大小，也就是说数组中存放的元素个数固定并且类型一样

②ArrayList是动态数组,也就是数组的复杂版本，它可以动态的添加和删除元素，被称为”集合“，在不使用泛型的情况下，这个list是可以添加进不同类型的元素的，而且arraylist是可以不用指定长度的。在使用泛型时，我们就只能添加一种类型的数据了

4.怎样将一个数组转成List，有什么方法

①数组转list，可以使用Arrays.asList(数组)

②List转数组，使用list.toArray()

5.HashSet、TreeSet、LinkedHashSet区别？

可以从集合的使用场合回答面试官

①.需要速度快的集合，使用HashSet

②.需要集合有排序功能，使用TreeSet

③.需要按照插入的顺序存储集合，使用LinkedHashSet

7.HashMap和HashSet区别

a. HashMap实现了Map接口，HashSet实现了Set接口

b.HashMap存储键值对，HashSet存储对象

c.HashMap调用put()向map中添加元素，HashSet调用add()像set中添加元素

d.HashMap使用Key计算hasncode,HashMap使用成员计算Hashcode

HashMap相对于HashSet较快，因为它是使用唯一的键获取对象

HashSet较HashMap来说比较慢

8.HashMap的实现原理

通过put和get存储和获取对象，存储对象时，我们将K/V传给put方法时，它调用hashcode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量。获取对象时，我们将K传递给get，他调用hashcode计算hash从而得到bucket位置，并进一步调用equals()方法确认键值对。

9.List、Set、Map之间的区别

List和Set都继承Collection，但是Map不是Collection的子接口。

List Set Map

可以允许重复的元素

不允许重复元素

键值对存储，键必须唯一，但是值可以重复

可以插入多个null元素

只允许一个null元素

键只允许一个null,值可以允许有多个null

有序的容器，插入的顺序和输出的顺序一样

无序容器

无序容器

---

11.什么时候使用ConcurrentHashMap？

ConcurrentHashMap被作为故障安全迭代器的一个实例，它允许完整的并发检索和更新。当有大量的并发更新时，ConcurrentHashMap此时可以被使用。这非常类似于Hashtable，但ConcurrentHashMap不锁定整个表来提供并发，所以从这点上ConcurrentHashMap的性能似乎更好一些。所以当有大量更新时ConcurrentHashMap应该被使用。

12.哪一个List实现了最快插入？

LinkedList和ArrayList是另个不同变量列表的实现。ArrayList的优势在于动态的增长数组，非常适合初始时总长度未知的情况下使用。LinkedList的优势在于在中间位置插入和删除操作，速度是最快的。

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

ArrayList实现了可变大小的数组。它允许所有元素，包括null。 每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

13.Iterator和ListIterator的区别

●ListIterator有add()方法，可以向List中添加对象，而Iterator不能。

●ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。

●ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

●都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

14 .什么是CopyOnWriteArrayList，它与ArrayList有何不同？

CopyOnWriteArrayList是ArrayList的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。相比较于ArrayList它的写操作要慢一些，因为它需要实例的快照。

CopyOnWriteArrayList中写操作需要大面积复制数组，所以性能肯定很差

但是读操作因为操作的对象和写操作不是同一个对象，读之间也不需要加锁，读和写之间的同步处理只是在写完后通过一个简单的"="将引用指向新的数组对象上来，这个几乎不需要时间，这样读操作就很快很安全，适合在多线程里使用，绝对不会发生ConcurrentModificationException ，因此CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。

15.迭代器和枚举之间的区别

如果面试官问这个问题，那么他的意图一定是让你区分Iterator不同于Enumeration的两个方面：

●Iterator允许移除从底层集合的元素。

●Iterator的方法名是标准化的。

16.Hashmap如何同步?

当我们需要一个同步的HashMap时，有两种选择：

●使用Collections.synchronizedMap（…）来同步HashMap。

●使用ConcurrentHashMap的
这两个选项之间的首选是使用ConcurrentHashMap，这是因为我们不需要锁定整个对象，以及通过ConcurrentHashMap分区地图来获得锁。

17.IdentityHashMap和HashMap的区别

IdentityHashMap是Map接口的实现。不同于HashMap的，这里采用参考平等。

●在HashMap中如果两个元素是相等的，则key1.equals(key2)

●在IdentityHashMap中如果两个元素是相等的，则key1 == key2

18、集合与数组

数组（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。
集合（只能存储对象，对象类型可以不一样）的长度可变，可在多数情况下使用。

二、层次关系

如图所示：图中，实线边框的是实现类，折线边框的是抽象类，而点线边框的是接口

Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。

Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。

Iterator，所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含以下三种方法：
1.hasNext()是否还有下一个元素。
2.next()返回下一个元素。
3.remove()删除当前元素。

三、几种重要的接口和类简介

1、List（有序、可重复）
List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所以插入删除数据速度慢。

2、Set（无序、不能重复）
Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。

3、Map（键值对、键唯一、值不唯一）
Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

对比如下：

		是否有序	是否允许元素重复
Collection
List	是	是
Set	AbstractSet	否	否
	HashSet
	TreeSet	是（用二叉排序树）
Map	AbstractMap	否	使用key-value来映射和存储数据，key必须唯一，value可以重复
	HashMap
	TreeMap	是（用二叉排序树）

四、遍历

在类集中提供了以下四种的常见输出方式：

1）Iterator：迭代输出，是使用最多的输出方式。

2）ListIterator：是Iterator的子接口，专门用于输出List中的内容。

3）foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。

4）for循环

代码示例如下：

for的形式：for（int i=0;i<arr.size();i++）{…}

foreach的形式： for（int　i：arr）{…}

iterator的形式：
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); …}

五、ArrayList和LinkedList

ArrayList和LinkedList在用法上没有区别，但是在功能上还是有区别的。LinkedList经常用在增删操作较多而查询操作很少的情况下，ArrayList则相反。

六、Map集合

实现类：HashMap、Hashtable、LinkedHashMap和TreeMap

HashMap

HashMap是最常用的Map，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。因为键对象不可以重复，所以HashMap最多只允许一条记录的键为Null，允许多条记录的值为Null，是非同步的

Hashtable

Hashtable与HashMap类似，是HashMap的线程安全版，它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢，它继承自Dictionary类，不同的是它不允许记录的键或者值为null，同时效率较低。

ConcurrentHashMap

线程安全，并且锁分离。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。

LinkedHashMap

LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性。

TreeMap

TreeMap实现SortMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序（自然顺序），也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。不允许key值为空，非同步的；

map的遍历

第一种：KeySet()
将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。 keySet():迭代后只能通过get()取key 。
取到的结果会乱序，是因为取得数据行主键的时候，使用了HashMap.keySet()方法，而这个方法返回的Set结果，里面的数据是乱序排放的。
典型用法如下：
Map map = new HashMap();
map.put(“key1”,“lisi1”);
map.put(“key2”,“lisi2”);
map.put(“key3”,“lisi3”);
map.put(“key4”,“lisi4”);
//先获取map集合的所有键的set集合，keyset（）
Iterator it = map.keySet().iterator();
//获取迭代器
while(it.hasNext()){
Object key = it.next();
System.out.println(map.get(key));
}

第二种：entrySet（）
Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。（一个关系就是一个键-值对），就是把(key-value)作为一个整体一对一对地存放到Set集合当中的。Map.Entry表示映射关系。entrySet()：迭代后可以e.getKey()，e.getValue()两种方法来取key和value。返回的是Entry接口。
典型用法如下：
Map map = new HashMap();
map.put(“key1”,“lisi1”);
map.put(“key2”,“lisi2”);
map.put(“key3”,“lisi3”);
map.put(“key4”,“lisi4”);
//将map集合中的映射关系取出，存入到set集合
Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry e =(Entry) it.next();
System.out.println(“键”+e.getKey () + “的值为” + e.getValue());
}
推荐使用第二种方式，即entrySet()方法，效率较高。
对于keySet其实是遍历了2次，一次是转为iterator，一次就是从HashMap中取出key所对于的value。而entryset只是遍历了第一次，它把key和value都放到了entry中，所以快了。两种遍历的遍历时间相差还是很明显的。

七、主要实现类区别小结

Vector和ArrayList
1，vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。
2，如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%，而arraylist增长率为目前数组长度的50%。如果在集合中使用数据量比较大的数据，用vector有一定的优势。
3，如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，如果频繁的访问数据，这个时候使用vector和arraylist都可以。而如果移动一个指定位置会导致后面的元素都发生移动，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据时其它元素不移动。
ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以索引数据快，插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快。

arraylist和linkedlist
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

HashMap与TreeMap
1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。
两个map中的元素一样，但顺序不一样，导致hashCode()不一样。
同样做测试：
在HashMap中，同样的值的map,顺序不同，equals时，false;
而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。

HashTable与HashMap
1、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
2、HashMap允许存在一个为null的key，多个为null的value 。

3、hashtable的key和value都不允许为null。

Java集合框架为Java编程语言的基础，也是Java面试中很重要的一个知识点。这里，我列出了一些关于Java集合的重要问题和答案。

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

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

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

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

（3）通过使用JDK附带的集合类，可以降低代码维护成本。

（4）复用性和可操作性。

2.集合框架中的泛型有什么优点？

​ Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代码整洁，我们不需要使用显式转换和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.为何Map接口不继承Collection接口？

​ 尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。

​ 如果Map继承Collection接口，那么元素去哪儿？Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。

6.Iterator是什么？

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

7.Enumeration和Iterator接口的区别？

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

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

8.为何没有像Iterator.add()这样的方法，向集合中添加元素？

​ 语义不明，已知的是，Iterator的协议不能确保迭代的次序。然而要注意，ListIterator没有提供一个add操作，它要确保迭代的顺序。

9.为何迭代器没有一个方法可以直接获取下一个元素，而不需要移动游标？

​ 它可以在当前Iterator的顶层实现，但是它用得很少，如果将它加到接口中，每个继承都要去实现它，这没有意义。

10.Iterater和ListIterator之间有什么区别？

（1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。

（2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。

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

11.遍历一个List有哪些不同的方式？

List<String> strList = new ArrayList<>();



//使用for-each循环



for(String obj : strList){



  System.out.println(obj);



}



//using iterator



Iterator<String> it = strList.iterator();



while(it.hasNext()){



  String obj = it.next();



  System.out.println(obj);



}

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

12.通过迭代器fail-fast属性，你明白了什么？

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

13.fail-fast与fail-safe有什么区别？

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

14.在迭代一个集合的时候，如何避免ConcurrentModificationException？

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

15.为何Iterator接口没有具体的实现？

​ Iterator接口定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。

这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的。

16.UnsupportedOperationException是什么？

​ UnsupportedOperationException是用于表明操作不支持的异常。在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在所有add和remove操作中抛出这个异常。

17.在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进行初始化是个不错的做法。

18.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。

19.我们能否使用任何类作为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大量使用。

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

21.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。

22.如何决定选用HashMap还是TreeMap？

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

23.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工具类轻易地获取同步列表和只读列表。

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

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

​ Array是指定大小的，而ArrayList大小是固定的。

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

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

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

（3）如果你要使用多维数组，使用[][]比List<List<>>更容易。

25.ArrayList和LinkedList有何区别？

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

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

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

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

26.哪些集合类提供对元素的随机访问？

​ ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机访问。

27.EnumSet是什么？

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

28.哪些集合类是线程安全的？

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

29.并发集合类是什么？

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

30.BlockingQueue是什么？

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

31.队列和栈是什么，列出它们的区别？

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

栈与队列很相似，但它允许对元素进行后进先出（LIFO）进行检索。

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

32.Collections类是什么？

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

33.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；若第一个比第二个大，返回正整数。

34.Comparable和Comparator接口有何区别？

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

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

35.我们如何对一组对象进行排序？

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

36.当一个集合被作为参数传递给一个函数时，如何才可以确保函数不能修改它？

​ 在作为参数传递之前，我们可以使用Collections.unmodifiableCollection(Collection c)方法创建一个只读集合，这将确保改变集合的任何操作都会抛出UnsupportedOperationException。

37.我们如何从给定集合那里创建一个synchronized的集合？

​ 我们可以使用Collections.synchronizedCollection(Collection c)根据指定集合来获取一个synchronized（线程安全的）集合。

38.集合框架里实现的通用算法有哪些？

​ Java集合框架提供常用的算法实现，比如排序和搜索。Collections类包含这些方法实现。大部分算法是操作List的，但一部分对所有类型的集合都是可用的。部分算法有排序、搜索、混编、最大最小值。

39.大写的O是什么？举几个例子？

​ 大写的O描述的是，就数据结构中的一系列元素而言，一个算法的性能。Collection类就是实际的数据结构，我们通常基于时间、内存和性能，使用大写的O来选择集合实现。比如：例子1：ArrayList的get(index i)是一个常量时间操作，它不依赖list中元素的数量。所以它的性能是O(1)。例子2：一个对于数组或列表的线性搜索的性能是O(n)，因为我们需要遍历所有的元素来查找需要的元素。

40.与Java集合框架相关的有哪些最好的实践？

（1）根据需要选择正确的集合类型。比如，如果指定了大小，我们会选用Array而非ArrayList。如果我们想根据插入顺序遍历一个Map，我们需要使用TreeMap。如果我们不想重复，我们应该使用Set。

（2）一些集合类允许指定初始容量，所以如果我们能够估计到存储元素的数量，我们可以使用它，就避免了重新哈希或大小调整。

（3）基于接口编程，而非基于实现编程，它允许我们后来轻易地改变实现。

（4）总是使用类型安全的泛型，避免在运行时出现ClassCastException。

（5）使用JDK提供的不可变类作为Map的key，可以避免自己实现hashCode()和equals()。

（6）尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性。

===========================================================

1.Java集合框架是什么？说出一些集合框架的长处？

每种编程语言中都有集合。最初的Java版本号包括几种集合类：Vector、Stack、HashTable和Array。

随着集合的广泛使用。Java1.2提出了囊括全部集合接口、实现和算法的集合框架。

在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了非常久。它还包括在Java并发包中，堵塞接口以及它们的实现。

集合框架的部分长处例如以下：

（1）使用核心集合类减少开发成本，而非实现我们自己的集合类。

（2）随着使用经过严格測试的集合框架类。代码质量会得到提高。

（3）通过使用JDK附带的集合类，能够减少代码维护成本。

（4）复用性和可操作性。

2.集合框架中的泛型有什么长处？

Java1.5引入了泛型。全部的集合接口和实现都大量地使用它。泛型同意我们为集合提供一个能够容纳的对象类型，因此。假设你加入其他类型的不论什么元素，它会在编译时报错。这避免了在执行时出现ClassCastException。由于你将会在编译时得到报错信息。

泛型也使得代码整洁，我们不须要使用显式转换和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.为何Map接口不继承Collection接口？

虽然Map接口和它的实现也是集合框架的一部分。但Map不是集合。集合也不是Map。

因此，Map继承Collection毫无意义，反之亦然。

假设Map继承Collection接口，那么元素去哪儿？Map包括key-value对，它提供抽取key或value列表集合的方法，可是它不适合“一组对象”规范。

6.Iterator是什么？

Iterator接口提供遍历不论什么Collection的接口。

我们能够从一个Collection中使用迭代器方法来获取迭代器实例。迭代器代替了Java集合框架中的Enumeration。迭代器同意调用者在迭代过程中移除元素。

7.Enumeration和Iterator接口的差别？

Enumeration的速度是Iterator的两倍，也使用更少的内存。

Enumeration是非常基础的，也满足了基础的须要。可是，与Enumeration相比，Iterator更加安全，由于当一个集合正在被遍历的时候。它会阻止其他线程去改动集合。

迭代器代替了Java集合框架中的Enumeration。

迭代器同意调用者从集合中移除元素，而Enumeration不能做到。

为了使它的功能更加清晰，迭代器方法名已经经过改善。

8.为何没有像Iterator.add()这种方法。向集合中加入元素？

语义不明。已知的是，Iterator的协议不能确保迭代的次序。然而要注意。ListIterator没有提供一个add操作，它要确保迭代的顺序。

9.为何迭代器没有一个方法能够直接获取下一个元素。而不须要移动游标？

它能够在当前Iterator的顶层实现。可是它用得非常少，假设将它加到接口中，每一个继承都要去实现它。这没有意义。

10.Iterater和ListIterator之间有什么差别？

（1）我们能够使用Iterator来遍历Set和List集合，而ListIterator仅仅能遍历List。

（2）Iterator仅仅能够向前遍历。而LIstIterator能够双向遍历。

（3）ListIterator从Iterator接口继承，然后加入了一些额外的功能，比方加入一个元素、替换一个元素、获取前面或后面元素的索引位置。

---

11.遍历一个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。

12.通过迭代器fail-fast属性，你明确了什么？

每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的不论什么改动。假设发现不论什么改动。它抛出ConcurrentModificationException。Collection中全部Iterator的实现都是按fail-fast来设计的（ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外）。

13.fail-fast与fail-safe有什么差别？

Iterator的fail-fast属性与当前的集合共同起作用，因此它不会受到集合中不论什么改动的影响。

Java.util包中的全部集合类都被设计为fail-fast的。而java.util.concurrent中的集合类都为fail-safe的。

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

14.在迭代一个集合的时候，怎样避免ConcurrentModificationException？

在遍历一个集合的时候，我们能够使用并发集合类来避免ConcurrentModificationException，比方使用CopyOnWriteArrayList。而不是ArrayList。

15.为何Iterator接口没有详细的实现？

Iterator接口定义了遍历集合的方法。但它的实现则是集合实现类的责任。每一个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。

这就同意集合类去选择迭代器是fail-fast还是fail-safe的。比方，ArrayList迭代器是fail-fast的。而CopyOnWriteArrayList迭代器是fail-safe的。

16.UnsupportedOperationException是什么？

UnsupportedOperationException是用于表明操作不支持的异常。

在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在全部add和remove操作中抛出这个异常。

17.在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进行初始化是个不错的做法。

18.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。

19.我们能否使用不论什么类作为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大量使用。

20.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<Map.Entry<K,V>> entrySet()：返回一个map钟包括的全部映射的一个集合视图。

这个集合受map支持的，map的变化会在collection中反映出来。反之亦然。当一个迭代器正在遍历一个集合时，若map被改动了（除迭代器自身的移除操作，以及对迭代器返回的entry进行setValue外），迭代器的结果会变为没有定义。

集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除相应的映射。它不支持add和addAll操作。

---

21.HashMap和HashTable有何不同？

（1）HashMap同意key和value为null。而HashTable不同意。

（2）HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。

（3）在Java1.4中引入了LinkedHashMap，HashMap的一个子类，假如你想要遍历顺序，你非常easy从HashMap转向LinkedHashMap，可是HashTable不是这种。它的顺序是不可预知的。

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

（5）HashTable被觉得是个遗留的类。假设你寻求在迭代的时候改动Map，你应该使用CocurrentHashMap。

22.怎样决定选用HashMap还是TreeMap？

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

23.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工具类轻易地获取同步列表和仅仅读列表。

24.Array和ArrayList有何差别？什么时候更适合用Array？

• Array能够容纳基本类型和对象，而ArrayList仅仅能容纳对象。
• Array是指定大小的，而ArrayList大小是固定的。
• Array没有提供ArrayList那么多功能，比方addAll、removeAll和iterator等。虽然ArrayList明显是更好的选择。但也有些时候Array比較好用。

（1）假设列表的大小已经指定，大部分情况下是存储和遍历它们。

（2）对于遍历基本数据类型，虽然Collections使用自己主动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得非常慢。

（3）假设你要使用多维数组，使用[][]比List<List<>>更easy。

25.ArrayList和LinkedList有何差别？

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

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

（2）与ArrayList相比，在LinkedList中插入、加入和删除一个元素会更快。由于在一个元素被插入到中间的时候，不会涉及改变数组的大小，或更新索引。

（3）LinkedList比ArrayList消耗很多其他的内存，由于LinkedList中的每一个节点存储了前后节点的引用。

26.哪些集合类提供对元素的随机訪问？

ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机訪问。

27.EnumSet是什么？

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

28.哪些集合类是线程安全的？

Vector、HashTable、Properties和Stack是同步类，所以它们是线程安全的，能够在多线程环境下使用。

Java1.5并发API包括一些集合类。同意迭代时改动，由于它们都工作在集合的克隆上。所以它们在多线程环境中是安全的。

29.并发集合类是什么？

Java1.5并发包（java.util.concurrent）包括线程安全集合类，同意在迭代时改动集合。

迭代器被设计为fail-fast的，会抛出ConcurrentModificationException。一部分类为：CopyOnWriteArrayList、 ConcurrentHashMap、CopyOnWriteArraySet。

30.BlockingQueue是什么？

Java.util.concurrent.BlockingQueue是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在加入一个元素时，它会等待队列中的可用空间。

BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不须要操心等待生产者有可用的空间。或消费者有可用的对象。由于它都在BlockingQueue的实现类中被处理了。

Java提供了集中BlockingQueue的实现，比方ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。

---

31.队列和栈是什么，列出它们的差别？

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

栈与队列非常类似，但它同意对元素进行后进先出（LIFO）进行检索。

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

32.Collections类是什么？

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

33.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；若第一个比第二个大。返回正整数。

34.Comparable和Comparator接口有何差别？

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

Comparator接口被用来提供不同的排序算法，我们能够选择须要使用的Comparator来对给定的对象集合进行排序。

35.我们怎样对一组对象进行排序？

假设我们须要对一个对象数组进行排序，我们能够使用Arrays.sort()方法。假设我们须要排序一个对象列表，我们能够使用Collection.sort()方法。

两个类都实用于自然排序（使用Comparable）或基于标准的排序（使用Comparator）的重载方法sort()。Collections内部使用数组排序方法，全部它们两者都有同样的性能。仅仅是Collections须要花时间将列表转换为数组。

36.当一个集合被作为參数传递给一个函数时，怎样才干够确保函数不能改动它？

在作为參数传递之前，我们能够使用Collections.unmodifiableCollection(Collection c)方法创建一个仅仅读集合，这将确保改变集合的不论什么操作都会抛出UnsupportedOperationException。

37.我们怎样从给定集合那里创建一个synchronized的集合？

我们能够使用Collections.synchronizedCollection(Collection c)依据指定集合来获取一个synchronized（线程安全的）集合。

38.集合框架里实现的通用算法有哪些？

Java集合框架提供经常使用的算法实现，比方排序和搜索。Collections类包括这些方法实现。大部分算法是操作List的，但一部分对全部类型的集合都是可用的。部分算法有排序、搜索、混编、最大最小值。

39.大写的O是什么？举几个样例？

大写的O描写叙述的是。就数据结构中的一系列元素而言，一个算法的性能。

Collection类就是实际的数据结构。我们通常基于时间、内存和性能，使用大写的O来选择集合实现。

比方：

样例1：ArrayList的get(index i)是一个常量时间操作，它不依赖list中元素的数量。所以它的性能是O(1)。

样例2：一个对于数组或列表的线性搜索的性能是O(n)，由于我们须要遍历全部的元素来查找须要的元素。

40.与Java集合框架相关的有哪些最好的实践？

（1）依据须要选择正确的集合类型。比方，假设指定了大小，我们会选用Array而非ArrayList。

假设我们想依据插入顺序遍历一个Map，我们须要使用TreeMap。假设我们不想反复。我们应该使用Set。

（2）一些集合类同意指定初始容量。所以假设我们能够预计到存储元素的数量，我们能够使用它，就避免了又一次哈希或大小调整。

（3）基于接口编程，而非基于实现编程。它同意我们后来轻易地改变实现。

（4）总是使用类型安全的泛型。避免在执行时出现ClassCastException。

（5）使用JDK提供的不可变类作为Map的key，能够避免自己实现hashCode()和equals()。

（6）尽可能使用Collections工具类，或者获取仅仅读、同步或空的集合，而非编写自己的实现。

它将会提供代码重用性，它有着更好的稳定性和可维护性。