面试题总结-----简单的开始吧02

1.## Iterator和ListIterator的区别是什么？
答案：下面列出了他们的区别：
Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。
ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。
简单暴力：

2.## 快速失败(fail-fast)和安全失败(fail-safe)的区别是什么？
一：快速失败（fail—fast）
在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的结构进行了修改（增加、删除），则会抛出Concurrent Modification Exception。
原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果结构发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
注意：这里异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug。
场景：java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。

二：安全失败（fail—safe）
  采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。
  原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。
  缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。
   场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

理解：快速失败，在修改集合内容时没事，但是对集合的结构更改，会影响带modCount的值，报错
安全失败：遍历副本，但是不能拿到实时的数据

3.## Java中的HashMap的工作原理是什么？
答案：Java中的HashMap是以键值对**(key-value)的**形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。

理解：
<1>hashMap是数组加链表的结构
<2>HashMap的两个重要属性是容量capacity和加载因子loadfactor，默认值分布为16和0.75，当容器中的元素个数大于 capacity*loadfactor时，容器会进行扩容resize 为2n
<3>HashMap的底层是用hash数组和单向链表实现的 ，当调用put方法是，首先计算key的hashcode，定位到合适的数组索引，然后再在该索引上的单向链表进行循环遍历用equals比较key是否存在，如果存在则用新的value覆盖原值，如果没有则向后追加。

4.## hashCode()和equals()方法的重要性体现在什么地方？
答案：Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引，当根据键获取值的时候也会用到这两个方法。如果没有正确的实现这两个方法，两个不同的键可能会有相同的hash值，因此，可能会被集合认为是相等的。而且，这两个方法也用来发现重复元素。所以这两个方法的实现对HashMap的精确性和正确性是至关重要的。

理解：HashMap的很多函数要基于equal()函数和hashCode()函数。hashCode()用来定位要存放的位置，equal()用来判断是否相等。hashcode和equals组合在一起确定元素的唯一性。 比较两个元素时，先比较hashcode，如果hashcode不同，则元素一定不相等；如果相同，再用equals判断。

5.## HashMap和Hashtable有什么区别？
答案：HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点：
<1> HashMap允许键和值是null，而Hashtable不允许键或者值是null。
<2> Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。
<3> HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。
一般认为Hashtable是一个遗留的类。
<4> HashMap是非线程安全的，HashTable是线程安全的。因为线程安全的问题，HashMap效率比HashTable的要高。
<5> 一般现在不建议用HashTable, ①是HashTable是遗留类，内部实现很多没优化和冗余。②即使在多线程环境下，现在也有同步的ConcurrentHashMap替代，没有必要因为是多线程而用HashTable。

6.## 数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用Array而不是ArrayList？
答案：下面列出了Array和ArrayList的不同点：
<1> Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。
<1> Array大小是固定的，ArrayList的大小是动态变化的。
<3> ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。
对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。Array数组在存放的时候一定是同种类型的元素。ArrayList就不一定了，因为ArrayList可以存储Object。

理解：ArrayList的空间是动态增长的，如果空间不够，它会创建一个空间比原空间大一倍的新数组，然后将所有元素复制到新数组中，接着抛弃旧数组。而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。

7.## ArrayList和LinkedList有什么区别？
答案：ArrayList和LinkedList都实现了List接口，他们有以下的不同点：
<1> ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。
<2> 相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。
<3> LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
也可以参考ArrayList vs. LinkedList。

理解：ArrayList的实现用的是数组，LinkedList是基于链表，ArrayList适合查找，LinkedList适合增删

8.## Comparable和Comparator接口是干什么的？列出它们的区别。
答案：
Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明已经存在的对象小于，等于，大于输入对象。
Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。

理解：
comparable接口：
优点：对于单元素集合可以实现直接排序
缺点：对于多元素排序，排序依据是固定不可更改的。（元素内部只能实现一次compareTo方法）
comparator接口：
元素的排序依据时刻变的，所以可以通过定义多个外部类的方式来实现不同的排序。使用时按照需求选取。
创建外部类的代价太大。

9.## 什么是Java优先级队列(Priority Queue)？
答案：PriorityQueue是一个基于优先级堆的无界队列，它的元素是按照自然顺序(natural order)排序的。在创建的时候，我们可以给它提供一个负责给元素排序的比较器。PriorityQueue不允许null值，因为他们没有自然顺序，或者说他们没有任何的相关联的比较器。最后，PriorityQueue不是线程安全的，入队和出队的时间复杂度是O(log(n))。

理解：
优先级队列中的元素可以按照任意的顺序插入，却总是按照排序的顺序进行检索。无论何时调用remove方法，总会获得当前优先级队列中的最小元素，但并不是对所有元素都排序。它是采用了堆（一个可以自我调整的二叉树），执行增加删除操作后，可以让最小元素移动到根。

10.## 你了解大O符号(big-O notation)么？你能给出不同数据结构的例子么？
答案：大O符号描述了当数据结构里面的元素增加的时候，算法的规模或者是一个渐进上界 。
大O符号也可用来描述其他的行为，比如：内存消耗。因为集合类实际上是数据结构，我们一般使用大O符号基于时间，内存和性能来选择最好的实现。大O符号可以对大量数据的性能给出一个很好的说明。

大神解说：
其函数表示是：
对于函数f(n),g(n),如果存在一个常数c，使得f(n)<=c*g(n),则f(n)=O(g(n));
大O描述当数据结构中的元素增加时，算法的规模和性能在最坏情景下有多好。

11.## 如何权衡是使用无序的数组还是有序的数组？
答案：有序数组最大的好处在于查找的时间复杂度是O(log n)，而无序数组是O(n)。有序数组的缺点是插入操作的时间复杂度是O(n)，因为值大的元素需要往后移动来给新元素腾位置。相反，无序数组的插入时间复杂度是常量O(1)。

理解：
数组中存储的数据是有序的还是无序的，以此来区分是有序数组，还是无序数组
有序数组
查找，可以使用二分查找， 时间复杂度 O(long N)
插入, 需要比较，移动数据，找到合适的位置插入数据 O（N）

          无序数组：
                查找：需要循环遍历  O(N)
                插入：放到末尾就好 O(1)

12.## Java集合类框架的最佳实践有哪些？
答案：根据应用的需要正确选择要使用的集合的类型对性能非常重要，
假如元素的数量是固定的，而且能事先知道，我们就应该用Array而不是ArrayList。
有些集合类允许指定初始容量。因此，如果我们能估计出存储的元素的数目，我们可以设置初始容量来避免重新计算hash值或者是扩容。
为了类型安全，可读性和健壮性的原因总是要使用泛型。同时，使用泛型还可以避免运行时的ClassCastException。
使用JDK提供的不变类(immutable class)作为Map的键可以避免为我们自己的类实现hashCode()和equals()方法。
编程的时候接口优于实现。
底层的集合实际上是空的情况下，返回长度是0的集合或者是数组，不要返回null。

13.## Enumeration接口和Iterator接口的区别有哪些？
答案：Enumeration速度是Iterator的2倍，同时占用更少的内存。但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。

理解：枚举速度快，占用内存少，但是不是快速失败的，线程不安全。迭代允许删除底层数据，枚举不行

14.## HashSet和TreeSet有什么区别？
答案：HashSet是由一个hash表来实现的，因此，它的元素是无序的。add()，remove()，contains()方法的时间复杂度是O(1)。
另一方面，TreeSet是由一个树形的结构来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。

理解：Hashset 的底层是由哈希表实现的，Treeset 底层是由红黑树实现的。如果需要在Treeset 中插入对象，需要实现Comparable 接口，为其指定比较策略。
HashSet不允许保存重复对象，这个重复是有自己定义的。比如需要保存People对象，People类包含名字和年龄两个属性，你可以在People类中重写equals和hashCode方法，指明姓名和年龄都相等的People对象是相等的，那么就不能重复存入姓名和年龄相等的People对象。HashSet中的对象没有顺序。
TreeSet保存的对象有顺序性，也有不可重复性。顺序性有两种方法实现，一个是类实现Comparable接口；另一个是构造比较器，将比较器对象作为TreeSet的构造函数的参数传入。顺序性和不可重复性都是在compareTo()方法中实现的，当按年龄排序时，先比较年龄，年龄相等再比较姓名，姓名相等则不存入。

15.## Java中垃圾回收有什么目的？什么时候进行垃圾回收？
答案：垃圾回收是在内存中存在没有引用的对象或超过作用域的对象时进行。
垃圾回收的目的是识别并且丢弃应用不再使用的对象来释放和重用资源。
理解：
垃圾回收的目的是回收堆内存中不再使用的对象所占的内存，释放资源。
回收时间：即触发GC的时间，在新生代的Eden区满了，会触发新生代GC（Mimor GC），经过多次触发新生代GC存活下来的对象就会升级到老年代，升级到老年代的对象所需的内存大于老年代剩余的内存，则会触发老年代GC（Full GC）。当程序调用System.gc()时也会触发Full GC。

16.## System.gc()和Runtime.gc()会做什么事情？
答案：这两个方法用来提示JVM要进行垃圾回收。但是，立即开始还是延迟进行垃圾回收是取决于JVM的。

理解：java.lang.System.gc()只是java.lang.Runtime.getRuntime().gc()的简写，两者的行为没有任何不同。唯一要能说有什么不同那就是在字节码层面上调用前者比调用后者短一点点，前者是1条字节码而后者是2条。

17.## finalize()方法什么时候被调用？析构函数(finalization)的目的是什么？
答案：垃圾回收器(garbage collector)决定回收某对象时，就会运行该对象的finalize()方法 但是在Java中很不幸，如果内存总是充足的，那么垃圾回收可能永远不会进行，也就是说filalize()可能永远不被执行，显然指望它做收尾工作是靠不住的。 那么finalize()究竟是做什么的呢？它最主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器，所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序（C或C++），finalize()的工作就是回收这部分的内存。

理解：
对于Java而言：
调用时机：当垃圾回收器要宣告一个对象死亡时，至少要经过两次标记过程：如果对象在进行可达性分析后发现没有和GC Roots相连接的引用链，就会被第一次标记，并且判断是否执行finalizer( )方法，如果对象覆盖finalizer( )方法且未被虚拟机调用过，那么这个对象会被放置在F-Queue队列中，并在稍后由一个虚拟机自动建立的低优先级的Finalizer线程区执行触发finalizer( )方法，但不承诺等待其运行结束。

finalization的目的：对象逃脱死亡的最后一次机会。（只要重新与引用链上的任何一个对象建立关联即可。）但是不建议使用，运行代价高昂，不确定性大，且无法保证各个对象的调用顺序。可用try-finally或其他替代。

18.## 如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？
答案：不会，在下一个垃圾回收周期中，这个对象将是可被回收的。

大神西游版解说：链接：https://www.nowcoder.com/questionTerminal/fbef4d5971ce4009aa720aecf7d83f3c
来源：牛客网

孙大圣（JVM）-：嘚！你这妖怪，不给你家神仙主子干活，下凡来占着我的茅坑（内存），我先暂且饶你一命，看你主子会不会来领你回家干活，要是刚把你给打死了，你主子就要来找我咬人，麻烦死了，不要再为非作歹，占着茅坑（内存）不拉屎。下次大圣发现茅坑不够了：卧槽？你。。TM还在着占着茅坑？要不要点脸，滚开，我这边还有新人要拉屎。然后大圣一棍子打死。

19.## Java堆的结构是什么样子的？什么是堆中的永久代(Perm Gen space)?
答案：JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。
堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。

永久代是用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate 等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类，永久代中一般包含：
类的方法(字节码…)
类名(Sring对象)
.class文件读到的常量信息
class对象相关的对象列表和类型列表 (e.g., 方法对象的array).
JVM创建的内部对象
JIT编译器优化用的信息

理解：
虚拟机中的共划分为三个代：
年轻代（Young Generation）、年老代（Old Generation）和持久代（Permanent
Generation）。其中持久代主要存放的是Java类的类信息，与垃圾收集要收集的Java对象关系
不大。年轻代和年老代的划分是对垃 圾收集影响比较大的。

年轻代: 所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生
命周期短的对象。年轻代分三个区。一个Eden区，两个 Survivor区(一般而言)。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个 Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。同时，根据程序需要，Survivor区是可以配置为多个的（多于两个），这样可以增加对象在年轻代中的存在时间，减
少被放到年老代的可能。

**年老代:**在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。

持久代: 用于存放静态文件，如今Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate 等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=进行设置。

20.## 串行(serial)收集器和吞吐量(throughput)收集器的区别是什么？
答案：吞吐量收集器使用并行版本的新生代垃圾收集器，它用于中等规模和大规模数据的应用程序。而串行收集器对大多数的小应用(在现代处理器上需要大概100M左右的内存)就足够了。
理解：
串行GC：整个扫描和复制过程均采用单线程的方式，相对于吞吐量GC来说简单；适合于单CPU、客户端级别。
吞吐量GC：采用多线程的方式来完成垃圾收集；适合于吞吐量要求较高的场合，比较适合中等和大规模的应用程序。

声明：见01文章@_@！！