java面试宝典第二弹

arraylist和linklist的区别，hashmap和hashset的区别，常用的集合有哪些

一、基础内容

容器就是一种装其他各种对象的器皿。java.util包 

容器：Set, List, Map ,数组。只有这四种容器。 

Collection（集合） 一个一个往里装，Map 一对一对往里装。 

Set:没有顺序，不可以重复。 List:有顺序，可以重复。 互相的equals就算重复。 

Map定义了存储Key-Value的方法。 

Collection里装的必须都是Object,不能是基础类型。比如Int类型的值分配在栈上，而栈上的内容都是动态的。 

容器类对象在调用remove，cotains等方法时，需要比较对象是否相等，这会涉及到对象类型的equals方法和hashCode方法，对于自定义的类型，需要重写equals方法和hashCode方法以实现自定义对象相等。 

原则： 如果要重写equals方法，那必须重写hashCode方法。两个对象互相equals，那这两个对象必须具有相同的hashCode。 

比较两个对象是不是相等的时候，主要用的是equals方法，当对象用在Map里面作为键时用hashCode方法，这样效率比较高。当对象当做键的时候，hashCode会有用。 

两个对象如果互相equals，那么他们的hashCode一定相等。

二、HashMap,Hashset,ArrayList以及LinkedList集合的区别,以及各自的用法：

HashMap:HashMap实现了Map接口，底层使用的是Hash算法存储数据。HashMap将数据以键值对的方式存储。

HashSet:HashSet实现了Set接口，底层也是用的是Hash算法存储数据。而且HashSet内部有HashMap类型的成员变量,方法也调用了HashMap的方法，存储的时候只不过值为null.

ArrayList:ArrayList实现了List接口，底层使用的是数组，存储空间上是相邻的，所以查询起来会很方便，效率也会比LinkedList要高

LinkedList:实现了List接口，底层使用的是使用双向链表的形式，存储的数据在空间上很可能不相邻，但是他们都有一个引用连在一起，所以增删起来会很方便

Vector与ArrayList十分相似，区别就是就是vector是一种线程安全类,它的方法都带有Synchronized关键字,实际中很少用到。如果遇到多线程的问题，JAVA提供了一个Collections工具类，可以把ArrayList转换成线程安全的类。

throwable有哪些子类，你遇到过哪些运行时异常

Throwable是java.lang包中一个专门用来处理异常的类。它有两个子类，即Error 和Exception，它们分别用来处理两组异常。 

    Error用来处理程序运行环境方面的异常，比如，虚拟机错误、装载错误和连接错误， 这类异常主要是和硬件有关的，而不是由程序本身抛出的。 

    Exception是Throwable的一个主要子类。Exception下面还有子类，其中一部分子类 分别对应于Java程序运行时常常遇到的各种异常的处理，其中包括隐式异常。比如，程序 中除数为0引起的错误、数组下标越界错误等，这类异常也称为运行时异常，因为它们虽然 是由程序本身引起的异常，但不是程序主动抛出的，而是在程序运行中产生的。Exception 子类下面的另一部分子类对应于Java程序中的非运行时异常的处理，这些异常也称为显式异常。它们都是在程序中用语句抛出、并且也是 用语句进行捕获的，比如，文件没找到引起的异常、类没找到引起的异常等。 

    一些主要子类对应的异常处理功能简要说明如下： 

    ArithmeticException——由于除数为0引起的异常； 

    ArrayStoreException——由于数组存储空间不够引起的异常； 

    ClassCastException—一当把一个对象归为某个类，但实际上此对象并不是由这个类 创建的，也不是其子类创建的，则会引起异常； 

    IllegalMonitorStateException——监控器状态出错引起的异常； 

    NegativeArraySizeException—一数组长度是负数，则产生异常； 

    NullPointerException—一程序试图访问一个空的数组中的元素或访问空的对象中的 方法或变量时产生异常； 

    OutofMemoryException——用new语句创建对象时，如系统无法为其分配内存空 间则产生异常； 

    SecurityException——由于访问了不应访问的指针，使安全性出问题而引起异常； 

    IndexOutOfBoundsExcention——由于数组下标越界或字符串访问越界引起异常； 

    IOException——由于文件未找到、未打开或者I/O操作不能进行而引起异常； 

    ClassNotFoundException——未找到指定名字的类或接口引起异常； 

    CloneNotSupportedException——一程序中的一个对象引用Object类的clone方法，但 此对象并没有连接Cloneable接口，从而引起异常； 

    InterruptedException—一当一个线程处于等待状态时，另一个线程中断此线程，从 而引起异常，

    NoSuchMethodException一所调用的方法未找到，引起异常； 

    Illega1AccessExcePtion—一试图访问一个非public方法； 

    StringIndexOutOfBoundsException——访问字符串序号越界，引起异常； 

    ArrayIdexOutOfBoundsException—一访问数组元素下标越界，引起异常； 

    NumberFormatException——字符的UTF代码数据格式有错引起异常； 

    IllegalThreadException—一线程调用某个方法而所处状态不适当，引起异常； 

    FileNotFoundException——未找到指定文件引起异常； 

    EOFException——未完成输入操作即遇文件结束引起异常。

创建线程的几种方法

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示：

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程

通过继承Thread类来创建并启动多线程的一般步骤如下

1】d定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。

2】创建Thread子类的实例，也就是创建了线程对象

3】启动线程，即调用线程的start()方法

 

通过实现Runnable接口创建并启动线程一般步骤如下：

1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体

2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

3】第三部依然是通过调用线程对象的start()方法来启动线程

和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。

》call()方法可以有返回值

》call()方法可以声明抛出异常

Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。

>boolean cancel(boolean mayInterruptIfRunning)：视图取消该Future里面关联的Callable任务

>V get()：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值

>V get(long timeout,TimeUnit unit)：返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException

>boolean isDone()：若Callable任务完成，返回True

>boolean isCancelled()：如果在Callable任务正常完成前被取消，返回True

介绍了相关的概念之后，创建并启动有返回值的线程的步骤如下：

1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。

2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值

3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）

4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

 

实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：

1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。

2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。

4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。

注：一般推荐采用实现接口的方式来创建多线程

对i++多线程访问你会怎么做

在Java多线程中，i++和i--是非线程安全的。

volatile(wo le tao) 该修饰符是强制变量每次从内存中读取，而不会存储在寄存器中。不一定管事

 AtomicInteger  加在i前面

 

JVM内存结构主要有三大块：堆内存、方法区和栈。

java堆（Java Heap）

可通过参数 -Xms 和-Xmx设置

 Java堆是被所有线程共享,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建

 Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里

 Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor区

 新生代：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。

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

java虚拟机栈(stack)

可通过参数 栈帧是方法运行期的基础数据结构栈容量可由-Xss设置

 Java虚拟机栈是线程私有的，它的生命周期与线程相同。

 每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧，用于存储 局部变量表、操作数栈、动态链接、方法出口等信息

方法区（Method Area）

可通过参数-XX:MaxPermSize设置

 线程共享内存区域），用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码，方法区也称持久代（Permanent Generation）。

 方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。

 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载。

 运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池。。

synchronized 悲观锁

乐观锁（ Optimistic Locking）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。（https://blog.csdn.net/liuhouli923914981/article/details/79769666）

Java中是否可以继承String类，为什么

不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。

　final类不能被继承，没有子类，final类中的方法默认是final的。 

　　final方法不能被子类的方法覆盖，但可以被继承。 

　　final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 

　　final不能用于修饰构造方法。 

　　注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

java中的堆、栈和常量池

堆：存放所有new出来的对象；栈：存放基本类型的变量数据和对象的应用，对象（new出来的对象）本身并不存在栈中，而是存放在堆中或者常量池中（字符串常量对象存放在常量池中）；常量池：存放基本类型常量和字符串常量。

对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会自动消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

    而对于字符串来说，其对象的引用都是存储在栈中的，如果是编译期已经创建好（即指用双引号定义的）的就存储在常量池中，如果是运行期（new出来的对象）则存储在堆中。对于equals相等的字符串，在常量池中是只有一份的，在堆中则有多份。

 

public static void main(String[] args) { 

        String s1 = new String("sss"); 

        String s2 = new String("sss"); 

        if(s1!=s2){ 

            System.out.println("不是一个对象"); 

        } 

    } 

可以看出来两者不是一个对象，每执行一次new，都在内存中新开辟一块空间来存储数据，不管之前有没有new过 

 

 

抽象类和接口的区别

 

抽象类

抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板.

接口

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法.

 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。

 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。

 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

Java8中的默认方法和静态方法

Oracle已经开始尝试向接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。现在，我们可以为接口提供默认实现的方法了并且不用强制子类来实现它。这类内容我将在下篇博客进行阐述。

java中垃圾回收机制你是怎么理解的

什么是垃圾回收机制：在系统运行过程中，会产生一些无用的对象，这些对象占据着一定的内存，如果不对这些对象清理回收无用对象的内存，可能会导致内存的耗尽，所以垃圾回收机制回收的是内存。同时GC回收的是堆区和方法区的内存。

JVM回收特点：(stop-the-world)当要进行垃圾回收时候，不管何种GC算法，除了垃圾回收的线程之外其他任何线程都将停止运行。被中断的任务将会在垃圾回收完成后恢复进行。GC不同算法或是GC调优就是减少stop-the-world的时间。à(为何非要stop-the-world)，就像是一个同学的聚会，地上有很多垃圾，你去打扫，边打扫边丢垃圾怎么都不可能打扫干净的哈。当在垃圾回收时候不暂停所有的程序，在垃圾回收时候有new一个新的对象B，此时对象A是可达B的，但是没有来及标记就把B当成无用的对象给清理掉了，这就会导致程序的运行会出现错误。

如何判断哪些对象需要回收呢：

1.      引用计数算法(java中不是使用此方法)：每个对象中添加一个引用计数器，当有别人引用它的时候，计数器就会加1，当别人不引用它的时候，计数器就会减1，当计数器为0的时候对象就可以当成垃圾。算法简单，但是最大问题就是在循环引用的时候不能够正确把对象当成垃圾。

2.     根搜索方法（这是后面垃圾搜集算法的基础）：这是JVM一般使用的算法，设立若干了根对象，当上述若干个跟对象对某一个对象都不可达的时候，这个对象就是无用的对象。对象所占的内存可以回收。

 

根搜索算法的基础上，现代虚拟机的实现当中，垃圾搜集的算法主要有三种，分别是标记-清除算法、复制算法、标记-整理算法。

 

三种算法比较：

效率：复制算法>标记-整理算法>标记-清除算法；

内存整齐度：复制算法=标记-整理算法>标记-清除算法

内存利用率：标记-整理算法=标记-清除算法>复制算法

分代收集算法：

现在使用的Java虚拟机并不是只是使用一种内存回收机制，而是分代收集的算法。就是将内存根据对象存活的周期划分为几块。一般是把堆分为新生代、和老年代。短命对象存放在新生代中，长命对象放在老年代中。

对于不同的代，采用不同的收集算法：

新生代：由于存活的对象相对比较少，因此可以采用复制算法该算法效率比较快。

老年代：由于存活的对象比较多哈，可以采用标记-清除算法或是标记-整理算法

 

（注意）新生态由于根据统计可能有98%对象存活时间很短因此将内存分为一块比较大的Eden空间和两块较小的Survivor空间，每次使用Eden和其中一块Survivor。当回收时，将Eden和Survivor中还存活着的对象一次性地复制到另外一块Survivor空间上，最后清理掉Eden和刚才用过的Survivor空间。

 

二：并行收集器：（Parallel收集器）

 

parallel收集器使用多线程并行处理GC，因此更快。当有足够大的内存和大量芯数时，parallel收集器是有用的。它也被称为“吞吐量优先垃圾收集器。”

 

三：并行收集器：（Parallel Old 垃圾收集器）

相比于parallel收集器，他们的唯一区别就是在老年代所执行的GC算法的不同。它执行三个步骤：标记-汇总-压缩（mark – summary – compaction）。汇总步骤与清理的不同之处在于，其将依然幸存的对象分发到GC预先处理好的不同区域，算法相对清理来说略微复杂一点。

四：并行收集器：（CMS收集器）

（ConcurrentMark Sweep：并发标记清除）是一种以获取最短回收停顿时间为目标的收集器。适合应用在互联网站或者B/S系统的服务器上，这类应用尤其重视服务器的响应速度，希望系统停顿时间最短。

 

五：G1收集器

这个类型的垃圾收集算法是为了替代CMS 收集器而被创建的，因为CMS 收集器在长时间持续运行时会产生很多问题。

 

java会出现内存泄露吗，如果会，在哪种情况下

一、Java内存回收机制 

不论哪种语言的内存分配方式，都需要返回所分配内存的真实地址，也就是返回一个指针到内存块的首地址。Java中对象是采用new或者反射的方法创建的，这些对象的创建都是在堆（Heap）中分配的，所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的。GC为了能够正确释放对象，会监控每个对象的运行状况，对他们的申请、引用、被引用、赋值等状况进行监控，Java会使用有向图的方法进行管理内存，实时监控对象是否可以达到，如果不可到达，则就将其回收，这样也可以消除引用循环的问题。在Java语言中，判断一个内存空间是否符合垃圾收集标准有两个：一个是给对象赋予了空值null，以下再没有调用过，另一个是给对象赋予了新值，这样重新分配了内存空间。

二、Java内存泄露引起原因 

首先，什么是内存泄露？经常听人谈起内存泄露，但要问什么是内存泄露，没几个说得清楚。内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。内存泄露有时不严重且不易察觉，这样开发者就不知道存在内存泄露，但有时也会很严重，会提示你Out of memory。

那么，Java内存泄露根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。具体主要有如下几大类： 

1、静态集合类引起内存泄露： 

像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，因为他们也将一直被Vector等引用着。 

2、当集合里面的对象属性被修改后，再调用remove（）方法时不起作用。可能会

3、监听器 

在java 编程中，我们都需要和监听器打交道，通常一个应用当中会用到很多监听器，我们会调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而增加了内存泄漏的机会。

4、各种连接 

比如数据库连接（dataSourse.getConnection()），网络连接(socket)和io连接，除非其显式的调用了其close（）方法将其连接关闭，否则是不会自动被GC 回收的。对于Resultset 和Statement 对象可以不进行显式回收，但Connection 一定要显式回收，因为Connection 在任何时候都无法自动回收，而Connection一旦回收，Resultset 和Statement 对象就会立即为NULL。但是如果使用连接池，情况就不一样了，除了要显式地关闭连接，还必须显式地关闭Resultset Statement 对象（关闭其中一个，另外一个也会关闭），否则就会造成大量的Statement 对象无法释放，从而引起内存泄漏。这种情况下一般都会在try里面去的连接，在finally里面释放连接。

5、内部类和外部模块等的引用 

内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列的后继类对象没有释放。此外程序员还要小心外部模块不经意的引用，例如程序员A 负责A 模块，调用了B 模块的一个方法如： 

public void registerMsg(Object b); 

这种调用就要非常小心了，传入了一个对象，很可能模块B就保持了对该对象的引用，这时候就需要注意模块B 是否提供相应的操作去除引用。

6、单例模式 

不正确使用单例模式是引起内存泄露的一个常见问题，单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露.