我正在参加「启航方案」
———————————————————————————————————
以下首要针对往期录入的面试题进行一个分类概括收拾，方便我们一致回顾和参阅。今天是第一集~
强调一下：【因篇幅问题：文中只放部分内容，全部文档需求的可找作者获取。】
Java 基础部分
1.笼统类与接口的差异？
参阅答案：大体差异如下：
- 笼统类能够供给成员办法的完成细节，而接口中只能存在 public 笼统办法；
- 笼统类中的成员变量可所以各种类型的，而接口中的成员变量只能是
public static final类型的； - 接口中不能含有结构器、静态代码块以及静态办法，而笼统类能够有结构器、静态代码块和静态办法；
- 一个类只能承继一个笼统类，而一个类却能够完成多个接口；
- 笼统类拜访速度比接口速度要快，因为接口需求时间去寻找在类中具体完成的办法；
- 假如你往笼统类中增加新的办法，你能够给它供给默许的完成。因而你不需求改动你现在的代码。假如你往接口中增加办法，那么你有必要改动完成该接口的类。
- 接口更多的为了束缚类的行为，可用于解耦，而笼统类更加侧重于代码复用。
2.别离讲讲 final、static 和 synchronized 能够润饰什么，以及润饰后的效果？
参阅答案：final ：能够润饰 类，办法，字段。
润饰类：该类不会被承继。
润饰办法：该办法不能被重写。
润饰字段：被润饰的 字段有必要 赋初始值，并且不能被改动。假如字段是引证类型的。那么他将不能引证别的目标，可是当时的目标内的特点值是能够改动的。
static ：能够润饰内部类，办法，字段。
润饰内部类：被static润饰 的内部类能够直接作为一个 一般的类来运用，而不需先实例一个外部列。
润饰办法：调用该办法的时分只需求类名 . 办法就能够直接调用，不需求创立目标。
润饰字段：经过类名 . 的办法能够直接 获取 或许 赋值。
synchronized 能够润饰 办法，代码块
润饰办法：被 synchronized 润饰办法办法在同一时间只能被一个线程拜访。其他线程将会被堵塞，直到当时线程释放锁。
润饰代码块：其实和润饰办法差不多，只不过 润饰代码块能够 运用 类锁。办法假如要运用类锁，只能设置为静态的办法。
3.请简述一下 String、StringBuffer 和 StringBuilder 三者的差异？
参阅答案：
String 为字符串常量，一旦创立不能够被修正，是线程安全的；String 类运用 final 润饰符，不能够被承继；String 的长度是不变的。适用于少数操作的字符串。 StringBuffer 为字符串变量，长度是可变的，线程安全。适用于多线程下在字符缓冲区进行很多字符串操作 StringBuilder 为字符串变量，长度是可变的，线程不安全。适用于单线程下在字符缓冲区进行很多字符串操作。 字符串操作在执行速度：StringBuilder > StringBuffer > String
- “equals” 与 “==”、“hashCode” 的差异和运用场景？
参阅答案：
- ==： == 用于比较变量所对应的内存中所存储的数值是否相同，要比较两个根本类型的数据(注意是根本类型)或两个 引证变量是否持平，只能用==操作符。 假如一个变量指向的数据是目标类型的，例如Objet obj 1= new Object() 那么，这时分涉及了两块内存;变量 obj1 是一个内存，new Object() 是另一个内存(堆内存)，此刻，变量 obj1 所对应的内存中存储的数值便是目标占用的那块内存(堆内存)的首地址。关于指向目标类型的变量，假如要比较两个变量是否指向同一个目标，即要看这两个变量所对应的内存中的数值是否持平，这时分就需求用==操作符进行比较；
- equals： equals 办法是用于比较两个独立目标的内容是否相同：
String a=new String("a");
String b=new String("a");
两条new句子创立了两个目标，然后用a/b这两个变量别离指向了其中一个目标，这是两个不同的目标，它们的首地址是不同的，即a和b中存储的数值(对应目标的首地址)是不相同的，所以，表达式a==b将回来false，而这两个目标中的内容是相同的，所以，表达式a.equals(b)将回来true。我们看看equal 源码:
* Note that it is generally necessary to override the {@code hashCode}
* method whenever this method is overridden, so as to maintain the
* general contract for the {@code hashCode} method, which states
* that equal objects must have equal hash codes.
*
* @param obj the reference object with which to compare.
* @return {@code true} if this object is the same as the obj
* argument; {@code false} otherwise.
* @see #hashCode()
* @see java.util.HashMap
*/
public boolean equals(Object obj) {
return (this == obj);
}
假如一个类没有重写equals 办法 那么便是调用 object 的 equals 其实便是 ==。
- hashCode： 因为重写的 equals() 里一般比较的比较全面比较复杂，这样功率就比较低，而使用hashCode()进行比照，则只要生成一个 hash 值进行比较就能够了，功率很高，那么 hashCode() 已然功率这么高为什么还要 equals() 呢？
- 运用场景： 因为 hashCode() 并不是彻底牢靠，有时分不同的目标他们生成的 hashcode 也会相同（hash抵触），所以 hashCode()只能说是大部分时分牢靠，并不是必定牢靠，所以能够得出： equals() 持平的两个目标他们的 hashCode() 必定持平，也便是用 equals() 比照是必定牢靠的。 hashCode() 持平的两个目标他们的 equals() 不用定持平，也便是 hashCode() 不是必定牢靠的。 一切关于需求很多并且快速的比照的话假如都用 equals() 去做明显功率太低，所以处理办法是，每逢需求比照的时分，首要用 hashCode() 去比照，假如 hashCode() 不相同，则表明这两个目标必定不持平（也便是不用再用 equals() 去再比照了）,假如 hashCode() 相同，此刻再比照他们的 equals()，假如 equals() 也相同，则表明这两个目标是真的相同了
5.Java 中深复制与浅复制的差异？
参阅答案：
首要需求了解，浅复制和深复制都是针对一个已有目标的操作。那先来看看浅复制和深复制的概念。在 Java 中，除了根本数据类型（元类型）之外，还存在 类的实例目标 这个引证数据类型。而一般运用 『 = 』号做赋值操作的时分。关于根本数据类型，实际上是复制的它的值，可是关于目标而言，其实赋值的仅仅这个目标的引证，将原目标的引证传递曩昔，他们实际上还是指向的同一个目标。
而浅复制和深复制便是在这个基础之上做的区别，假如在复制这个目标的时分，只对根本数据类型进行了复制，而对引证数据类型仅仅进行了引证的传递，而没有真实的创立一个新的目标，则认为是浅复制。反之，在对引证数据类型进行复制的时分，创立了一个新的目标，并且复制其内的成员变量，则认为是深复制。所以到现在，就应该了解了，所谓的浅复制和深复制，仅仅在复制目标的时分，对 类的实例目标 这种引证数据类型的不同操作而已。
总结来说：
1、浅复制：对根本数据类型进行值传递，对引证数据类型进行引证传递般的复制，此为浅复制。
2、深复制：对根本数据类型进行值传递，对引证数据类型，创立一个新的目标，并复制其内容，此为深复制。
6.谈谈 Error 和 Exception 的差异？
参阅答案：
Error 是体系中的过错，不行预料的，这种反常发生后，会导致程序立即崩溃。只能经过修正代码，使过错不在出现，这种过错 无法被捕获。
Exception 则是能够预料的。在程序中假如过感觉某段代码会出现 反常，则能够运用 try catch 进行捕获 ，或许直接抛出反常。Exception 可分为 编译时反常(CheckedException) 和 运行时反常(RuntimeException)。运行时反常能够 疏忽捕获操作(RuntimeException)，编译时反常有必要运用 try catch 进行捕获。
7.什么是反射机制？反射机制的运用场景有哪些？
参阅答案：
Java 反射机制是在运行状态中，关于恣意一个类，都能够知道这个类中的一切特点和办法，关于恣意一个目标，都能够调用它的恣意一个办法和特点；这种动态获取的信息以及动态调用目标的办法的功用称为 Java 言语的反射机制。 运用场景：
- 逆向代码，例如反编译
- 与注解相结合的结构，如 Retrofit
- 单纯的反射机制运用结构，例如 EventBus（事件总线）
- 动态生成类结构 例如Gson
8.谈谈怎么重写 equals() 办法？为什么还要重写 hashCode()？
参阅答案：
equals：比较两个目标的地址是否持平
hashCode ：一般用在调集里面，比如在hashMap 里面，存入元素的时分 会首要算出 哈希值，然后依据哈希值来确定元素的位置，关于在任何一个目标上调用hashCode 时，回来的 哈希值必定持平的。
为什么 需求重写 hashCode
给调会集存元素时，首要会获取 hashCode 的值，假如没有重写 hashCode ，他会直接将元素的地址转化成一个整数回来。假如我们创立了两个目标，两个目标的一切特点值都相同，在存入HashSet 时，第一个元素会直接存进去，第二个获取的 哈希值 和 第一个不同，所以第二个元素也会存进去，因为 jdk 默许不同的 hashCode 值，equals 必定回来false。所以 这两个值都会被存进去。可是这两个目标的特点值都是相同的，所以这样会形成数据的不唯一性。所以一般重写了 equals 后有必要要重写 hashCode。
内存走漏的问题
想象一下，一个类 创立了两个目标，特点值不同，一起重写了 equals 和 hashCode 。然后将他们都存进了 HashSet 中。然后修正第二个 元素的值。最后将第二个元素充 set 调会集删去。 删去之后 则迭代进行打印，会发现第二个元素没有被删去掉，为什么呢？ 因为在删去 某个元素时，会获取 hashCode 值，可是因为修正了特点值，导致获取的 哈希值和 存入时获取的不同，所以查找为空，jdk 认为该目标不在调会集，所以不会进行删去操作，可是用户使命 目标现已被删去，导致该目标长期不能被释放，形成内存走漏。处理的办法是不要在执行的期间 修正与 HashCode 值相关的目标信息，假如非要修正，则有必要先从调会集删去，更新数据后在增加到调集。
总结：
1.hashCode是为了进步在散列结构存储中查找的功率，在线性表中没有用果
2.equals和hashCode需求一起覆盖。
3.若两个目标equals回来true，则hashCode必定回来相同的int数。
4.若两个目标equals回来false，则hashCode不用定回来不同的int数,但为不持平的目标生成不同hashCode值能够进步 哈希表的性能
5.若两个目标hashCode回来相同int数，则equals不用定回来true。
6.若两个目标hashCode回来不同int数，则equals必定回来false。
7.同一目标在执行期间若现已存储在调会集，则不能修正影响hashCode值的相关信息，否则会导致内存走漏问题。
9.Java 中 IO 流分为几种？它们之间有什么差异？
参阅答案：
IO 流分为几种
Java中的流分为两种，一种是字节省，另一种是字符流，别离由四个笼统类来表明（每种流包含输入和输出两种所以一共四个）:InputStream，OutputStream，Reader，Writer。Java中其他多种多样改动的流均是由它们派生出来的.
字符流和字节省是依据处理数据的不同来区别的。字节省依照8位传输，字节省是最根本的，一切文件的贮存是都是字节（byte）的贮存，在磁盘上保存的并不是文件的字符而是先把字符编码成字节，再贮存这些字节到磁盘。
- 1.字节省可用于任何类型的目标，包含二进制目标，而字符流只能处理字符或许字符串；
- 2.节省供给了处理任何类型的IO操作的功用，但它不能直接处理Unicode字符，而字符流就能够。
读文本的时分用字符流，例如txt文件。读非文本文件的时分用字节省，例如mp3。理论上任何文件都能够用字节省读取，但当读取的是文本数据时，为了能还原成文本你有必要再经过一个转化的工序，相对来说字符流就省了这个麻烦，能够有办法直接读取。
字符流处理的单元为2个字节的Unicode字符，别离操作字符、字符数组或字符串，而字节省处理单元为1个字节， 操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国言语支撑性比较好！
BIO、NIO、AIO 有什么差异
BIO：Block IO 同步堵塞式 IO，便是我们平常运用的传统 IO，它的特点是形式简略运用方便，并发处理才能低。 NIO：Non IO 同步非堵塞 IO，是传统 IO 的升级，客户端和服务器端经过 Channel（通道）通讯，完成了多路复用。 AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，完成了异步非堵塞 IO ，异步 IO 的操作根据事件和回调机制。
BIO是一个衔接一个线程。 NIO是一个恳求一个线程。 AIO是一个有用恳求一个线程。
- BIO：同步并堵塞，服务器完成形式为一个衔接一个线程，即客户端有衔接恳求时服务器端就需求发动一个线程进行处理，假如这个衔接不做任何事情会形成不用要的线程开销，当然能够经过线程池机制改进。
- NIO：同步非堵塞，服务器完成形式为一个恳求一个线程，即客户端发送的衔接恳求都会注册到多路复用器上，多路复用器轮询到衔接有I/O恳求时才发动一个线程进行处理。
- AIO：异步非堵塞，服务器完成形式为一个有用恳求一个线程，客户端的I/O恳求都是由OS先完成了再告诉服务器运用去发动线程进行处理。
适用场景分析
- BIO办法适用于衔接数目比较小且固定的架构，这种办法对服务器资源要求比较高，并发局限于运用中，JDK1.4曾经的唯一挑选，但程序直观简略易了解。
- NIO办法适用于衔接数目多且衔接比较短（轻操作）的架构，比如聊天服务器，并发局限于运用中，编程比较复杂，JDK1.4开始支撑。
- AIO办法运用于衔接数目多且衔接比较长（重操作）的架构，比如相册服务器，充沛调用OS参与并发操作，编程比较复杂，JDK7开始支撑。
10.谈谈你对 Java 泛型中类型擦除的了解，并说说其局限性？
参阅答案：
1:类型擦除，发生在编译过程。指的是，一切的泛型信息都会被擦除(默许承继Object)
2:已处理的局限： 1 ArrayList(String> 不能够增加Integer类型的数据；经过 编译器先查看代码中的泛型的类型 处理 2 编辑器从ArrayList(String>中泛型中获取值，都有Object 强转 String 3 父类界说泛型，子类完成；完成的 重载，实际上，编译器会变成重写。经过 编译器的桥办法处理
3:未处理的局限： 1）泛型类型变量，不能是，根本数据类型 2）运行时，无法检测类型；例如：object instanceof ArrayList(String> 这个逻辑无法完成 3）泛型类型，无法在静态办法和静态变量中运用；如下：
public class TestClass {
public static T getSome() {
return null;
}
}
这一段逻辑，增加 static字段，编译器报错
11.String 为什么要设计成不行变的？
参阅答案：
1：字符串常量池的需求
当创立一个 String 目标时，假如此字符串现已存在于常量池中，则不会创立一个新的目标，而是引证现已存在的目标
假如答应改动，那么将导致各种逻辑过错，比如改动一个目标将会影响另一个独立目标，严格来说，这种常量池的思想是一种优化手法
2：答应String目标缓存 HashCode
java 中 String 目标的哈希码会被频繁的运用，比如在 hashMap中。字符串的不变形保证了hash码的唯一性，因而能够放定心的进行缓存。这也是一种优化手法，意味着不用没说都计算新的哈希码。在 String 类中有 private int hash 来缓存hashcode
3：安全性
String 被许多的类来当做参数，如 网络url，文件路径path 等等，假如String 不是固定的，将会引起各种安全隐患
12.说说你对 Java 注解的了解？
参阅答案：
本质：做一个标识，经过这个标识对代码标准、变量值做一些润饰。首要划分为三类
| Source | 仅仅存在在.java文件，编译成.class文件就消失了。效果为：让开发者依照注解的标准编写代码。例如：@OverRide | |
|---|---|---|
| Class | 在前期编译期的流程中，会被处理成.class内容，与原生代码功率简直相同。效果为：自动生成.class文件，做一些辅助性作业。例如：ButterKnife、GreenDao、ARouter | 功率和原生代码适当 |
| Runtime | 编译成.class文件之后，仍旧以注解的办法存在。而是在运行期收效。效果为：在运行期，经过反射做一些辅助性作业。例如：xUtils | 因为会集运用遍历+反射，因而功率较低。并且在9.0禁用反射 |
13.谈一谈 Java 成员变量、局部变量和静态变量的创立和收回时机？
参阅答案：
成员变量:生命周期随同类目标,类目标收回时收回 存在堆里 静态变量:不收回 在办法区 跟着类的加载而加载，跟着类的消失而消失，因为类需求非常长期的不运用，不使用，不关联，才有可能会被收回机制收回， 所以静态成员变量的生命周期特别长，除非是同享数据，否则不建议运用静态； 局部变量:办法调用时创立 办法结束时被标记为可收回 存在栈里。
