本题集列举了众多IT公司面试真题，对应聘Java程序员职位的常见考点和知识体系都进行的分类和归纳整理。

本题集适合应聘Java和JavaEE职位的程序员作为面试复习、学习和强化的资料，也适合其他程序员作为拓展读物进行阅读。

本题集包含了常见的算法、面试题，也包含了新的高级技术，比如：微服务架构等技术的面试题目。本题集非常全面，对于工作1-5年左右的java程序员面试有非常好的指导作用。

大家也可以访问（直接在线观看最新版的面试题）：

四个专业都要学，从零开始2000小时，成为高端人才，打下一生技术基础，不再是低端码农。

1.Java跨平台原理（字节码文件、虚拟机）

C/C++语言都直接编译成针对特定平台机器码。如果要跨平台，需要使用相应的编译器重新编译。

Java源程序（.java）要先编译成与平台无关的字节码文件(.class)，然后字节码文件再解释成机器码运行。解释是通过Java虚拟机来执行的。

字节码文件不面向任何具体平台，只面向虚拟机。

Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的，但它们都提供了相同的接口。

Java语言具有一次编译，到处运行的特点。就是说编译后的.class可以跨平台运行，前提是该平台具有相应的Java虚拟机。但是性能比C/C++要低。

Java的跨平台原理决定了其性能没有C/C++高

语言层次的安全性主要体现在：

Java取消了强大但又危险的指针，而代之以引用。由于指针可进行移动运算，指针可随便指向一个内存区域，而不管这个区域是否可用，这样做是危险的，因为原来这个内存地址可能存储着重要数据或者是其他程序运行所占用的，并且使用指针也容易数组越界。

垃圾回收机制：不需要程序员直接控制内存回收，由垃圾回收器在后台自动回收不再使用的内存。避免程序忘记及时回收，导致内存泄露。避免程序错误回收程序核心类库的内存，导致系统崩溃。

强制类型转换：只有在满足强制转换规则的情况下才能强转成功。

底层的安全性可以从以下方面来说明

Java在字节码的传输过程中使用了公开密钥加密机制(PKC)。

在运行环境提供了四级安全性保障机制：

字节码校验器 -类装载器 -运行时内存布局 -文件访问限制

Java2平台包括标准版（J2SE）、企业版（J2EE）和微缩版（J2ME）三个版本：

比如：数据库连接、接口定义、输入/输出、网络编程

Micro Edition(微缩版) J2ME 包含J2SE中一部分类，用于消费类电子产品的软件开发。

比如：呼机、智能卡、手机、PDA、机顶盒

他们的范围是：J2SE包含于J2EE中，J2ME包含了J2SE的核心类，但新添加了一些专有类

应用场合，API的覆盖范围各不相同。

Machine（Java虚拟机）的缩写，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行，也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。JVM是Java平台的基础，和实际的机器一样，它也有自己的指令集，并且在运行时操作不同的内存区域。 JVM通过抽象操作系统和CPU结构，提供了一种与平台无关的代码执行方法，即与特殊的实现方法、主机硬件、主机操作系统无关。JVM的主要工作是解释自己的指令集（即字节码）到CPU的指令集或对应的系统调用，保护用户免被恶意程序骚扰。 JVM对上层的Java源文件是不关心的，它关注的只是由源文件生成的类文件（.class文件）。

environment（java运行环境）的缩写。光有JVM还不能让class文件执行，因为在解释class的时候JVM需要调用解释所需要的类库lib。在JDK的安装目录里你可以找到jre目录，里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和lib和起来就称为jre。所以，在你写完java程序编译成.class之后，你可以把这个.class文件和jre一起打包发给朋友，这样你的朋友就可以运行你写程序了（jre里有运行.class的java.exe）。JRE是Sun公司发布的一个更大的系统，它里面就有一个JVM。JRE就与具体的CPU结构和操作系统有关，是运行Java程序必不可少的（除非用其他一些编译环境编译成.exe可执行文件……），JRE的地位就象一台PC机一样，我们写好的Win32应用程序需要操作系统帮我们运行，同样的，我们编写的Java程序也必须要JRE才能运行。

让我们看一下JDK的安装目录。在目录下面有六个文件夹、一个src类库源码压缩包、和其他几个声明文件。其中，真正在运行java时起作用的是以下四个文件夹：bin、include、lib、jre。现在我们可以看出这样一个关系，JDK包含JRE，而JRE包含JVM。

（注意：这里的bin、lib文件夹和jre里的bin、lib是不同的）总的来说JDK是用于java程序的开发,而jre则是只能运行class而没有编译的功能。eclipse、idea等其他IDE有自己的编译器而不是用JDK bin目录中自带的，所以在安装时你会发现他们只要求你选jre路径就ok了。

jdk是JAVA程序开发时用的开发工具包，其内部也有JRE运行环境JRE。JRE是JAVA程序运行时需要的运行环境，就是说如果你光是运行JAVA程序而不是去搞开发的话，只安装JRE就能运行已经存在的JAVA程序了。JDk、JRE内部都包含JAVA虚拟机JVM，JAVA虚拟机内部包含许多应用程序的类的解释器和类加载器等等。

共有单行注释、多行注释、文档注释3种注释类型。使用如下：

单行注释，采用“//”方式.只能注释一行代码。如：//类成员变量

多行注释，采用“/*...*/”方式，可注释多行代码，其中不允许出现嵌套。如：

文档注释，采用“/**...*/”方式。如：

6.8种基本数据类型及其字节数

2、如果i++,++i是一条单独的语句，两者没有任何区别

3、i++和++i的使用仅仅针对变量。 5++和++5会报错，因为5不是变量。

如果i++,++i不是一条单独的语句，他们就有区别i++ ：先运算后增1。如：

++i ： 先增1后运算。如：

&和&&都可以用作逻辑与运算符，但是要看使用时的具体条件来决定。

情况1：当上述的操作数是boolean类型变量时，&和&&都可以用作逻辑与运算符。

情况2：当上述的表达式结果是boolean类型变量时，&和&&都可以用作逻辑与运算符。

表示逻辑与(and)，当运算符两边的表达式的结果或操作数都为true时，整个运算结果才为true，否则，只要有一方为false，结果都为false。

(1)、&逻辑运算符称为逻辑与运算符，&&逻辑运算符称为短路与运算符，也可叫逻辑与运算符。

对于&：无论任何情况，&两边的操作数或表达式都会参与计算。

对于&&：当&&左边的操作数为false或左边表达式结果为false时，&&右边的操作数或表达式将不参与计算，此时最终结果都为false。

综上所述，如果逻辑与运算的第一个操作数是false或第一个表达式的结果为false时，对于第二个操作数或表达式是否进行运算，对最终的结果没有影响，结果肯定是false。推介平时多使用&&，因为它效率更高些。

、&还可以用作位运算符。当&两边操作数或两边表达式的结果不是boolean类型时，&用于按位与运算符的操作。

9.用最有效率的方法算出2乘以8等于多少

使用位运算来实现效率最高。位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和结果都是整型数。对于位运算符“<<”, 是将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，位运算cpu直接支持的，效率最高。所以，2乘以8等于几的最效率的方法是2 << 3

10.基本数据类型的类型转换规则

基本类型转换分为自动转换和强制转换。

自动转换规则：容量小的数据类型可以自动转换成容量大的数据类型，也可

以说低级自动向高级转换。这儿的容量指的不是字节数，而是指类型表述的范围。

强制转换规则：高级变为低级需要强制转换。

（1）赋值运算符“=”右边的转换，先自动转换成表达式中级别最高的数据类型，再进行运算。

（2）赋值运算符“=”两侧的转换，若左边级别>右边级别，会自动转换；若左边级别 == 右边级别，不用转换；若左边级别 < 右边级别，需强制转换。

(3)可以将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，前提是不超出其表述范围，否则必须进行强制转换。

11.if多分支语句和switch多分支语句的异同之处

相同之处：都是分支语句，多超过一种的情况进行判断处理。

switch更适合用于多分支情况，就是有很多种情况需要判断处理，判断条件类型单一，只有一个入口，在分支执行完后（如果没有break跳出），不加判断地执行下去;而if—elseif---else多分枝主要适用于分支较少的分支结构，判断类型不是单一，只要一个分支被执行后，后边的分支不再执行。switch为等值判断（不允许比如>= <=），而if为等值和区间都可以，if的使用范围大。

while先判断后执行，第一次判断为false,循环体一次都不执行

do while先执行 后判断，最少执行1次。

如果while循环第一次判断为true, 则两种循环没有区别。

break: 结束当前循环并退出当前循环体。

continue: 循环体中后续的语句不执行，但是循环没有结束，继续进行循环条件的判断（for循环还会i++）。continue只是结束本次循环。

14.请使用递归算法计算n！

15.递归的定义和优缺点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点：

(1) 递归就是在过程或函数里调用自身。

(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3) 递归算法解题通常显得很简洁，但运行效率较低。所以一般不提倡用递归算法设计程序。

(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

数组是（相同类型数据）的（有序）（集合）

数组会在内存中开辟一块连续的空间，每个空间相当于之前的一个变量，称为数组的元素element

数组元素有序的，不是大小顺序，是索引 的顺序

数组中可以存储基本数据类型，可以存储引用数据类型；但是对于一个数组而言，数组的类型是固定的，只能是一个

数组的长度是固定的，一经定义，不能再发生变化（数组的扩容）

17.请写出冒泡排序代码

18.请写出选择排序的代码

19.请写出插入排序的代码

20.可变参数的作用和特点

1.可变参数的形式 ...

2.可变参数只能是方法的形参

3.可变参数对应的实参可以0,1,2.....个，也可以是一个数组

4.在可变参数的方法中，将可变参数当做数组来处理

5.可变参数最多有一个，只能是最后一个

6.可变参数好处：方便 简单 减少重载方法的数量

7.如果定义了可变参数的方法，不允许同时定义相同类型数组参数的方法

总结2：数组做形参和可变参数做形参联系和区别

1.实参都可以是数组；2.方法体中，可变参数当做数组来处理

1.个数不同 可变参数只能有一个数组参数可以多个

2.位置不同 可变参数只能是最后一个 数组参数位置任意

3.实参不同 可变参数实参可以0,1,2.....个，也可以是一个数组，数组的实参只能是数组

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

类和对象好比图纸和实物的关系，模具和铸件的关系。

比如人类就是一个概念，人类具有身高，体重等属性。人类可以做吃饭、说话等方法。

小明就是一个具体的人，也就是实例，他的属性是具体的身高200cm，体重180kg，他做的方法是具体的吃了一碗白米饭，说了“12345”这样一句话。

22.面向过程和面向对象的区别

两者都是软件开发思想，先有面向过程，后有面向对象。在大型项目中，针对面向过程的不足推出了面向对象开发思想。

面向过程是蛋炒饭，面向对象是盖浇饭。盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是“可维护性”比较好，“饭” 和“菜”的耦合度比较低。

编程思路不同： 面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。

封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。

面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显。

方法重载和方法重写（覆盖）的区别

this是对象内部指代自身的引用,同时也是解决成员变量和局部变量同名问题；this可以调用成员变量，不能调用局部变量；this也可以调用成员方法，但是在普通方法中可以省略this，在构造方法中不允许省略，必须是构造方法的第一条语句。，而且在静态方法当中不允许出现this关键字。

super代表对当前对象的直接父类对象的引用，super可以调用直接父类的成员变量（注意权限修饰符的影响，比如不能访问private成员）

super可以调用直接父类的成员方法（注意权限修饰符的影响，比如不能访问private成员）；super可以调用直接父类的构造方法，只限构造方法中使用，且必须是第一条语句。

static可以修饰变量、方法、代码块和内部类

static属性属于这个类所有，即由该类创建的所有对象共享同一个static属性。可以对象创建后通过对象名.属性名和类名.属性名两种方式来访问。也可以在没有创建任何对象之前通过类名.属性名的方式来访问。

static变量和非static变量的区别(都是成员变量，不是局部变量)

不管有多少个对象，static变量只有1份。对于每个对象，实例变量都会有单独的一份

static变量是属于整个类的，也称为类变量。而非静态变量是属于对象的，也称为实例变量

2.在内存中存放的位置不同

2.在内存中存放的位置不同

静态变量：对象名.变量名 stu1.schoolName="西二旗小学"; 不推荐如此使用

4.在内存中分配空间的时间不同

static方法也可以通过对象名.方法名和类名.方法名两种方式来访问

static代码块。当类被第一次使用时（可能是调用static属性和方法，或者创建其对象）执行静态代码块，且只被执行一次，主要作用是实现static属性的初始化。

static内部类：属于整个外部类，而不是属于外部类的每个对象。不能访问外部类的非静态成员（变量或者方法），.可以访问外部类的静态成员

final和abstract是功能相反的两个关键字，可以对比记忆

abstract可以用来修饰类和方法，不能用来修饰属性和构造方法；使用abstract修饰的类是抽象类，需要被继承，使用abstract修饰的方法是抽象方法，需要子类被重写。

final可以用来修饰类、方法和属性，不能修饰构造方法。使用final修饰的类不能被继承，使用final修饰的方法不能被重写，使用final修饰的变量的值不能被修改，所以就成了常量。

特别注意：final修饰基本类型变量，其值不能改变，由原来的变量变为常量；但是final修饰引用类型变量，栈内存中的引用不能改变，但是所指向的堆内存中的对象的属性值仍旧可以改变。例如

final修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承例如：String类、Math类等。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重写，但是能够重载。 使用final修饰的对象，对象的引用地址不能变，但是对象的值可以变！

finally在异常处理时提供 finally 块来执行任何清除操作。如果有finally的话，则不管是否发生异常，finally语句都会被执行。一般情况下，都把关闭物理连接(IO流、数据库连接、Socket连接)等相关操作，放入到此代码块中。

finalize方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器删除对象之前被调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。 一般情况下，此方法由JVM调用，程序员不要去调用！

比较对象的地址值是否相等，如果子类重写，则比较对象的内容是否相等；

public公共的 可被同一项目中所有的类访问。 (必须与文件名同名)

default默认的 可被同一个包中的类访问。

成员（成员变量或成员方法）访问权限共有四种：

public 公共的 可以被项目中所有的类访问。(项目可见性)

protected 受保护的 可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问。（子类可见性）

default 默认的被这个类本身访问；被同一个包中的类访问。（包可见性）

private 私有的 只能被这个类本身访问。（类可见性）

29.继承条件下构造方法的执行过程

继承条件下构造方法的调用规则如下：

情况1：如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。

情况2：如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。

情况3：如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。

特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

“==”是关系运算符，equals()是方法，同时他们的结果都返回布尔值；

“==”使用情况如下：

a) 基本类型，比较的是值

b) 引用类型，比较的是地址

c) 不能比较没有父子关系的两个对象

a) 系统类一般已经覆盖了equals()，比较的是内容。

c) 用户自定义类需要覆盖父类的equals()

注意：Object的==和equals比较的都是地址，作用相同

实现多态的三个条件（前提条件，向上转型、向下转型）

1、继承的存在；（继承是多态的基础，没有继承就没有多态）

2、子类重写父类的方法。（多态下会调用子类重写后的方法）

3、父类引用变量指向子类对象。（涉及子类到父类的类型转换）

将一个父类的引用指向一个子类对象，成为向上转型，自动进行类型转换。此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法此时通过父类引用变量无法调用子类特有的方法。

将一个指向子类对象的引用赋给一个子类的引用，成为向下转型，此时必须进行强制类型转换。向下转型必须转换为父类引用指向的真实子类类型，，否则将出现ClassCastException，不是任意的强制转换

32.简述Java的垃圾回收机制

传统的C/C++语言，需要程序员负责回收已经分配内存。

显式回收垃圾回收的缺点：

1）程序忘记及时回收，从而导致内存泄露，降低系统性能。

2）程序错误回收程序核心类库的内存，导致系统崩溃。

Java语言不需要程序员直接控制内存回收，是由JRE在后台自动回收不再使用的内存，称为垃圾回收机制，简称GC；

1）可以提高编程效率。

2）保护程序的完整性。

3）其开销影响性能。Java虚拟机必须跟踪程序中有用的对象，确定哪些是无用的。

1）垃圾回收机制回收JVM堆内存里的对象空间,不负责回收栈内存数据。

2）对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力。

3）垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行。

4）可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。

现在的JVM有多种垃圾回收 实现算法，表现各异。

垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。

程序员可以通过System.GC()或者Runtime.getRuntime().GC()来通知系统进行垃圾回收，会有一些效果，但是系统是否进行垃圾回收依然不确定。

永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

33.基本数据类型和包装类

1) 八个基本数据类型的包装类

2)为什么为基本类型引入包装类

2.1基本数据类型有方便之处，简单、高效。

2.2但是Java中的基本数据类型却是不面向对象的（没有属性、方法），这在实际使用时存在很多的不便（比如集合的元素只能是Object）。

为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行包装，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

3) 包装类和基本数据类型之间的转换

4) 自动装箱和自动拆箱

JDK1.5提供了自动装箱（autoboxing）和自动拆箱（autounboxing）功能, 从而实现了包装类和基本数据类型之间的自动转换

5) 包装类还可以实现基本类型变量和字符串之间的转换

int是java提供的8种原始数据类型之一，Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。

int是java提供的8种原始数据类型之一，Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。

在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。

另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

实例包装的毫秒值必须通过将时间、分钟、秒和毫秒设置为与该实例相关的特定时区中的零来“规范化”。 说白了，java.sql.Date就是与数据库Date相对应的一个类型，而java.util.Date是纯java的Date。

2）JAVA里提供的日期和时间类，java.sql.Date和java.sql.Time,只会从数据库里读取某部分值，这有时会导致丢失数据。例如一个包含 5:00:57 PM的字段，读取日期时得到的是,而读取时间时得到的是5:00:57 PM. 你需要了解数据库里存储时间的精度。有些数据库，比如MySQL,精度为毫秒，然而另一些数据库，包括Oracle,存储SQL DATE类型数据时，毫秒部分的数据是不保存的。以下操作中容易出现不易被发现的BUG：获得一个JAVA里的日期对象。 从数据库里读取日期 试图比较两个日期对象是否相等。如果毫秒部分丢失，本来认为相等的两个日期对象用Equals方法可能返回false。.sql.Timestamp类比java.util.Date类精确度要高。这个类包了一个getTime()方法，但是它不会返回额外精度部分的数据，因此必须使用...

在Android开发中，无论是插件化仍是组件化，都是基于Android系统的类加载器ClassLoader来设计的。只不过Android平台上虚拟机运行的是Dex字节码，一种对class文件优化的产物，传统Class文件是一个Java源码文件会生成一个.class文件，而Android是把全部Class文件进行合并、优化，而后再生成一个最终的/")

在建立retrofit对象的时候用到了build()方法，该方法的实现以下：

该方法返回了一个Retrofit对象，经过retrofit对象建立网络请求的接口的方式以下：

图片函数库的选择须要根据APP的具体状况而定，对于严重依赖图片缓存的APP，例如壁纸类，图片社交类APP来讲，能够选择最专业的Fresco。对于通常的APP，选择Fresco会显得比较重，毕竟Fresco3.4M的体量摆在这。根据APP对图片的显示和缓存的需求从低到高，咱们能够对以上函数库作一个排序。

Picasso ：和Square的网络库一块儿能发挥最大做用，由于Picasso能够选择将网络请求的缓存部分交给了okhttp实现。

FB的图片加载框架Fresco：最大的优点在于5.0如下(最低2.3)的bitmap加载。在5.0如下系统，Fresco将图片放到一个特别的内存区域(Ashmem区)。固然，在图片不显示的时候，占用的内存会自动被释放。这会使得APP更加流畅，减小因图片内存占用而引起的OOM。为何说是5.0如下，由于在5.0之后系统默认就是存储在Ashmem区了。

Picasso所能实现的功能，Glide都能作，无非是所需的设置不一样。可是Picasso体积比起Glide小太多若是项目中网络请求自己用的就是okhttp或者retrofit(本质仍是okhttp)，那么建议用Picasso，体积会小不少(Square全家桶的干活)。Glide的好处是大型的图片流，好比gif、Video，若是大家是作美拍、爱拍这种视频类应用，建议使用。

不过在使用起来也有些不便（小建议：他只能用内置的一个ImageView来实现这些功能，用起来比较麻烦，咱们一般是根据Fresco本身改改，直接使用他的Bitmap层）

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布初版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不须要例外额外的jar，可以直接跑在JDK上。而在使用这种对象转换以前需先建立好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson彻底能够将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。Gson在功能上面无可挑剔，可是性能上面比FastJson有所差距。

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。

无依赖，不须要例外额外的jar，可以直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，致使Json转换出错，须要制定引用。FastJson采用首创的算法，将parse的速度提高到极致，超过全部json库。

综上Json技术的比较，在项目选型的时候能够使用Google的Gson和阿里巴巴的FastJson两种并行使用，若是只是功能要求，没有性能要求，能够使用google的Gson，若是有性能上面的要求能够使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean

组件化：是将一个APP分红多个module，每一个module都是一个组件，也能够是一个基础库供组件依赖，开发中能够单独调试部分组件，组件中不须要相互依赖可是能够相互调用，最终发布的时候全部组件以lib的形式被主APP工程依赖打包成一个apk。

1. APP版本迭代，新功能不断增长，业务变得复杂，维护成本高
2. 业务耦合度高，代码臃肿，团队内部多人协做开发困难
3. Android编译代码卡顿，单一工程下代码耦合严重，修改一处须要从新编译打包，耗时耗力。
4. 方便单元测试，单独改一个业务模块，不须要着重关注其余模块。

1. 组件化将通用模块独立出来，统一管理，以提升复用，将页面拆分为粒度更小的组件，组件内部出了包含UI实现，还能够包含数据层和逻辑层
2. 每一个组件度能够独立编译、加快编译速度、独立打包。
3. 每一个工程内部的修改，不会影响其余工程。
4. 业务库工程能够快速拆分出来，集成到其余App中。
5. 迭代频繁的业务模块采用组件方式，业务线研发能够互不干扰、提高协做效率，并控制产品质量，增强稳定性。
6. 并行开发，团队成员只关注本身的开发的小模块，下降耦合性，后期维护方便等。

组件化后的每个业务的module均可以是一个单独的APP（isModuleRun=false）， release 包的时候各个业务module做为lib依赖，这里彻底由一个变量控制，在根项目

当咱们建立了多个Module的时候，如何解决相同资源文件名合并的冲突，业务Module和BaseModule资源文件名称重复会产生冲突，解决方案在于：

每一个 module 都有 app_name，为了避免让资源名重名，在每一个组件的 build.gradle 中增长 resourcePrefix “xxx_强行检查资源名称前缀。固定每一个组件的资源前缀。可是 resourcePrefix 这个值只能限定 xml 里面的资源，并不能限定图片资源。

多个Module之间如何引用一些共同的library以及工具类

组件化以后，Module之间是相互隔离的，如何进行UI跳转以及方法调用，具体能够使用阿里巴巴ARouter或者美团的WMRouter等路由框架。

各业务Module以前不须要任何依赖能够经过路由跳转，完美解决业务之间耦合。

咱们知道组件之间是有联系的，因此在单独调试的时候如何拿到其它的Module传递过来的参数

当组件单独运行的时候，每一个Module自成一个APK，那么就意味着会有多个Application，很显然咱们不肯意重复写这么多代码，因此咱们只须要定义一个BaseApplication便可，其它的Application直接继承此BaseApplication就OK了，BaseApplication里面还可定义公用的参数。

关于如何进行组件化，能够参考：

提到插件化，就不得不提起方法数超过65535的问题，咱们能够经过Dex分包来解决，同时也能够经过使用插件化开发来解决。插件化的概念就是由宿主APP去加载以及运行插件APP。

在一个大的项目里面，为了明确的分工，每每不一样的团队负责不一样的插件APP，这样分工更加明确。各个模块封装成不一样的插件APK，不一样模块能够单独编译，提升了开发效率。 解决了上述的方法数超过限制的问题。能够经过上线新的插件来解决线上的BUG，达到“热修复”的效果。 减少了宿主APK的体积。

插件化开发的APP不能在Google Play上线，也就是没有海外市场。

含义：手机对角线的物理尺寸 单位：英寸（inch），1英寸=2.54cm

Android手机常见的尺寸有5寸、5.5寸、6寸，6.5寸等等

含义：手机在横向、纵向上的像素点数总和

通常描述成屏幕的”宽x高”=AxB 含义：屏幕在横向方向（宽度）上有A个像素点，在纵向方向

（高）有B个像素点 例子：，即宽度方向上有1080个像素点，在高度方向上有1920个像素点

UI设计师的设计图会以px做为统一的计量单位

假设设备内每英寸有160个像素，那么该设备的屏幕像素密度=160dpi

2.使用相对布局，禁用绝对布局。

从这个角度咱们来解释一下上面的现象。在上面的代码中，咱们设置每一个Button的宽度都是match_parent，假设屏幕宽度为L，那么每一个Button的宽度也应该都为L，剩余宽度就等于L-（L+L）= -L。

参考连接： Android的性能优化，主要是从如下几个方面进行优化的： 稳定（内存溢出、崩溃） 流畅（卡顿） 耗损（耗电、流量） 安装包（APK瘦身） 影响稳定性的缘由不少，好比内存使用不合理、代码异常场景考虑不周全、代码逻辑不合理等，都会对应用的稳定性形成影响。其中最多见的两个场景是：Crash 和 ANR，这两个错误将会使得程序没法使用。因此作好Crash全局监控，处理闪退同时把崩溃信息、异常信息收集记录起来，以便后续分析;合理使用主线程处理业务，不要在主线程中作耗时操做，防止ANR程序无响应发生。

它是Android Studio自带的一个内存监视工具，它能够很好地帮助咱们进行内存实时分析。经过点击Android Studio右下角的Memory Monitor标签，打开工具能够看见较浅蓝色表明free的内存，而深色的部分表明使用的内存从内存变换的走势图变换，能够判断关于内存的使用状态，例如当内存持续增高时，可能发生内存泄漏；当内存忽然减小时，可能发生GC等，以下图所示。

Android Lint Tool 是Android Sutido种集成的一个Android代码提示工具，它能够给你布局、代码提供很是强大的帮助。硬编码会提示以级别警告，例如：在布局文件中写了三层冗余的LinearLayout布局、直接在TextView中写要显示的文字、字体大小使用dp而不是sp为单位，就会在编辑器右边看到提示。

卡顿的场景一般是发生在用户交互体验最直接的方面。影响卡顿的两大因素，分别是界面绘制和数据处理。

界面绘制：主要缘由是绘制的层级深、页面复杂、刷新不合理，因为这些缘由致使卡顿的场景更多出如今 UI 和启动后的初始界面以及跳转到页面的绘制上。

数据处理：致使这种卡顿场景的缘由是数据处理量太大，通常分为三种状况，一是数据在处理 UI 线程，二是数据处理占用 CPU 高，致使主线程拿不到时间片，三是内存增长致使 GC 频繁，从而引发卡顿。

在Android种系统对View进行测量、布局和绘制时，都是经过对View数的遍从来进行操做的。若是一个View数的高度过高就会严重影响测量、布局和绘制的速度。Google也在其API文档中建议View高度不宜哦过10层。如今版本种Google使用RelativeLayout替代LineraLayout做为默认根布局，目的就是下降LineraLayout嵌套产生布局树的高度，从而提升UI渲染的效率。

布局复用，使用标签重用layout； 提升显示速度，使用延迟View加载； 减小层级，使用标签替换父级布局； 注意使用wrap_content，会增长measure计算成本； 删除控件中无用属性；

过分绘制是指在屏幕上的某个像素在同一帧的时间内被绘制了屡次。在多层次重叠的 UI 结构中，若是不可见的 UI 也在作绘制的操做，就会致使某些像素区域被绘制了屡次，从而浪费了多余的 CPU 以及 GPU 资源。如何避免过分绘制？

布局上的优化。移除 XML 中非必须的背景，移除 Window 默认的背景、按需显示占位背景图片

自定义View优化。使用 canvas.clipRect() 帮助系统识别那些可见的区域，只有在这个区域内才会被绘制。

在 Android5.0 之前，关于应用电量消耗的测试即麻烦又不许确，而5.0 以后Google专门引入了一个获取设备上电量消耗信息的API—— Battery Historian。Battery Historian 是一款由 Google 提供的 Android 系统电量分析工具，直观地展现出手机的电量消耗过程，经过输入电量分析文件，显示消耗状况。

最后提供一些可供参考耗电优化的方法：

浮点运算：计算机里整数和小数形式就是按普通格式进行存储，例如102四、3.1415926等等，这个没什么特色，可是这样的数精度不高，表达也不够全面，为了可以有一种数的通用表示法，就发明了浮点数。浮点数的表示形式有点像科学计数法（.×10^），它的表示形式是0.×10^，在计算机中的形式为 .* e ±**），其中前面的星号表明定点小数，也就是整数部分为0的纯小数，后面的指数部分是定点整数。利用这样的形式就能表示出任意一个整数和小数，例如1024就能表示成0.，也就是 .，3.1415926就能表示成0.^1，也就是 .1，这就是浮点数。浮点数进行的运算就是浮点运算。浮点运算比常规运算更复杂，所以计算机进行浮点运算速度要比进行常规运算慢得多。

Lock是一种锁的机制，主要是相对系统的休眠而言的，,只要有人拿着这个锁，系统就没法进入休眠意思就是个人程序给CPU加了这个锁那系统就不会休眠了，这样作的目的是为了全力配合咱们程序的运行。有的状况若是不这么作就会出现一些问题，好比微信等及时通信的心跳包会在熄屏不久后中止网络访问等问题。因此微信里面是有大量使用到了Wake_Lock锁。系统为了节省电量，CPU在没有任务忙的时候就会自动进入休眠。有任务须要唤醒CPU高效执行的时候，就会给CPU加Wake_Lock锁。你们常常犯的错误，咱们很容易去唤醒CPU来工做，可是很容易忘记释放Wake_Lock。

在Android 5.0 API 21 中，google提供了一个叫作JobScheduler API的组件，来处理当某个时间点或者当知足某个特定的条件时执行一个任务的场景，例如当用户在夜间休息时或设备接通电源适配器链接WiFi启动下载更新的任务。这样能够在减小资源消耗的同时提高应用的效率。

assets文件夹。存放一些配置文件、资源文件，assets不会自动生成对应的 ID，而是经过 AssetManager 类的接口获取。

res。res 是 resource 的缩写，这个目录存放资源文件，会自动生成对应的 ID 并映射到 .R 文件中，访问直接使用资源 ID。

META-INF。保存应用的签名信息，签名信息能够验证 APK 文件的完整性。

AndroidManifest.xml。这个文件用来描述 Android 应用的配置信息，一些组件的注册信息、可以使用权限等。

resources.arsc。记录着资源文件和资源 ID 之间的映射关系，用来根据资源 ID 寻找资源。

代码混淆。使用IDE 自带的 proGuard 代码混淆器工具 ，它包括压缩、优化、混淆等功能。 资源优化。好比使用 Android Lint 删除冗余资源，资源文件最少化等。 图片优化。好比利用 PNG优化工具 对图片作压缩处理。推荐目前最早进的压缩工具Googlek开源库zopfli。若是应用在0版本以上，推荐使用 WebP图片格式。 避免重复或无用功能的第三方库。例如，百度地图接入基础地图便可、讯飞语音无需接入离线、图片库Glide\Picasso等。 插件化开发。好比功能模块放在服务器上，按需下载，能够减小安装包大小。 能够使用微信开源资源文件混淆工具——AndResGuard。通常能够压缩apk的1M左右大。

冷启动 在启动应用时，系统中没有该应用的进程，这时系统会建立一个新的进程分配给该应用；

热启动 在启动应用时，系统中已有该应用的进程（例：按back键、home键，应用虽然会退出，可是该应用的进程仍是保留在后台）；

区别 冷启动：系统没有该应用的进程，须要建立一个新的进程分配给应用，因此会先建立和初始化Application类，再建立和初始化MainActivity类（包括一系列的测量、布局、绘制），最后显示在界面上。 热启动： 从已有的进程中来启动，不会建立和初始化Application类，直接建立和初始化MainActivity类（包括一系列的测量、布局、绘制），最后显示在界面上。

冷启动优化 减小在Application和第一个Activity的onCreate()方法的工做量； 不要让Application参与业务的操做； 不要在Application进行耗时操做； 不要以静态变量的方式在Application中保存数据； 减小布局的复杂性和深度；

模型层（Model）:主要是获取数据功能，业务逻辑和实体模型。

视图层（View）：对应于Activity或Fragment，负责视图的部分展现和业务逻辑用户交互

控制层（Presenter）:负责完成View层与Model层间的交互，经过P层来获取M层中数据后返回给V层，使得V层与M层间没有耦合。

，Presenter层彻底将View层和Model层进行了分离，把主要程序逻辑放在Presenter层实现，Presenter与具体的View层（Activity）是没有直接的关联，是经过定义接口来进行交互的，从而使得当View层（Activity）发生改变时，Persenter依然能够保持不变。View层接口类只应该只有set/get方法，及一些界面显示内容和用户输入，除此以外不该该有多余的内容。毫不容许View层直接访问Model层，这是与MVC最大区别之处，也是MVP核心优势。

Android4.4及之前使用的都是Dalvik虚拟机，咱们知道Apk在打包的过程当中会先将java等源码经过javac编译成.class文件，可是咱们的Dalvik虚拟机只会执行.dex文件，这个时候dx会将.class文件转换成Dalvik虚拟机执行的.dex文件。Dalvik虚拟机在启动的时候会先将.dex文件转换成快速运行的机器码，又由于65535这个问题，致使咱们在应用冷启动的时候有一个合包的过程，最后致使的一个结果就是咱们的app启动慢，这就是Dalvik虚拟机的JIT特性（Just

time），这个特性就是咱们在安装APK的时候就将dex直接处理成可直接供ART虚拟机使用的机器码，ART虚拟机将.dex文件转换成可直接运行的.oat文件，ART虚拟机天生支持多dex，因此也不会有一个合包的过程，因此ART虚拟机会很大的提高APP冷启动速度。

提供功能全面的Debug特性

APP安装速度慢，由于在APK安装的时候要生成可运行.oat文件

APK占用空间大，由于在APK安装的时候要生成可运行.oat文件

关于ART更详细的介绍，能够参考

熟悉Android性能分析工具、UI卡顿、APP启动、包瘦身和内存性能优化

熟悉Android APP架构设计，模块化、组件化、插件化开发

熟练掌握Java、设计模式、网络、多线程技术

jvm将.class类文件信息加载到内存并解析成对应的class对象的过程，注意：jvm并非一开始就把全部的类加载进内存中，只是在第一次遇到某个须要运行的类才会加载，而且只加载一次

主要分为三部分：一、加载，二、连接（1.验证，2.准备，3.解析），三、初始化

验证：（验证class文件的字节流是否符合jvm规范）

准备：为类变量分配内存，而且进行赋初值

解析：将常量池里面的符号引用（变量名）替换成直接引用（内存地址）过程，在解析阶段，jvm会把全部的类名、方法名、字段名、这些符号引用替换成具体的内存地址或者偏移量。

主要对类变量进行初始化，执行类构造器的过程，换句话说，只对static修试的变量或者语句进行初始化。

Java编程思想中的类的初始化过程主要有如下几点：

1. 找到class文件，将它加载到内存
2. 在堆内存中分配内存地址
3. 将堆内存地址指给栈内存中的p变量

StringBuffer里面的不少方法添加了synchronized关键字，是能够表征线程安全的，因此多线程状况下使用它。

StringBuilder牺牲了性能来换取速度的，这两个是能够直接在原对象上面进行修改，省去了建立新对象和回收老对象的过程，而String是字符串常量（final）修试，另外两个是字符串变量，常量对象一旦建立就不能够修改，变量是能够进行修改的，因此对于String字符串的操做包含下面三个步骤：

1. 建立一个新对象，名字和原来的同样

Java对象实例化过程当中，主要使用到虚拟机栈、Java堆和方法区。Java文件通过编译以后首先会被加载到jvm方法区中，jvm方法区中很重的一个部分是运行时常量池，用以存储class文件类的版本、字段、方法、接口等描述信息和编译期间的常量和静态常量。

类加载器classLoader，在JVM启动时或者类运行时将须要的.class文件加载到内存中。 执行引擎，负责执行class文件中包含的字节码指令。 本地方法接口，主要是调用C/C++实现的本地方法及返回结果。 内存区域（运行时数据区），是在JVM运行的时候操做所分配的内存区， 主要分为如下五个部分，以下图：

• 方法区：用于存储类结构信息的地方，包括常量池、静态变量、构造函数等。
• Java堆（heap）：存储Java实例或者对象的地方。这块是gc的主要区域。
• Java栈（stack）：Java栈老是和线程关联的，每当建立一个线程时，JVM就会为这个线程建立一个对应的Java栈。在这个java栈中又会包含多个栈帧，每运行一个方法就建立一个栈帧，用于存储局部变量表、操做栈、方法返回值等。每个方法从调用直至执行完成的过程，就对应一个栈帧在java栈中入栈到出栈的过程。因此java栈是线程私有的。
• 程序计数器：用于保存当前线程执行的内存地址，因为JVM是多线程执行的，因此为了保证线程切换回来后还能恢复到原先状态，就须要一个独立的计数器，记录以前中断的地方，可见程序计数器也是线程私有的。
• 本地方法栈：和Java栈的做用差很少，只不过是为JVM使用到的native方法服务的。

垃圾收集器通常完成两件事

一般，Java对象的引用能够分为4类：强引用、软引用、弱引用和虚引用。 强引用：一般能够认为是经过new出来的对象，即便内存不足，GC进行垃圾收集的时候也不会主动回收。

软引用：在内存不足的时候，GC进行垃圾收集的时候会被GC回收。

弱引用：不管内存是否充足，GC进行垃圾收集的时候都会回收。

虚引用：和弱引用相似，主要区别在于虚引用必须和引用队列一块儿使用。

引用队列：若是软引用和弱引用被GC回收，JVM就会把这个引用加到引用队列里，若是是虚引用，在回收前就会被加到引用队列里。

引用计数法：给每一个对象添加引用计数器，每一个地方引用它，计数器就+1，失效时-1。若是两个对象互相引用时，就致使没法回收。 可达性分析算法：以根集对象为起始点进行搜索，若是对象不可达的话就是垃圾对象。根集（Java栈中引用的对象、方法区中常量池中引用的对象、本地方法中引用的对象等。JVM在垃圾回收的时候，会检查堆中全部对象是否被这些根集对象引用，不可以被引用的对象就会被垃圾回收器回收。）

常见的垃圾回收算法有：

标记：首先标记全部须要回收的对象，在标记完成以后统计回收全部被标记的对象，它的标记过程即为上面的可达性分析算法。 清除：清除全部被标记的对象 缺点： 效率不足，标记和清除效率都不高 空间问题，标记清除以后会产生大量不连续的内存碎片，致使大对象分配没法找到足够的空间，提早进行垃圾回收。

复制回收算法 将可用的内存按容量划分为大小相等的2块，每次只用一块，当这一块的内存用完了，就将存活的对象复制到另一块上面，而后把已使用过的内存空间一次清理掉。

将内存缩小了本来的通常，代价比较高 大部分对象是“朝生夕灭”的，因此没必要按照1：1的比例划分。 如今商业虚拟机采用这种算法回收新生代，但不是按1：1的比例，而是将内存区域划分为eden 空间、from 空间、to 空间 3 个部分。 其中 from 空间和 to 空间能够视为用于复制的两块大小相同、地位相等，且可进行角色互换的空间块。from 和 to 空间也称为 survivor 空间，即幸存者空间，用于存放未被回收的对象。

在垃圾回收时，eden 空间中的存活对象会被复制到未使用的 survivor 空间中 (假设是 to)，正在使用的 survivor 空间 (假设是 from) 中的年轻对象也会被复制到 to 空间中 (大对象，或者老年对象会直接进入老年带，若是 to 空间已满，则对象也会直接进入老年代)。此时，eden 空间和 from 空间中的剩余对象就是垃圾对象，能够直接清空，to 空间则存放这次回收后的存活对象。这种改进的复制算法既保证了空间的连续性，又避免了大量的内存空间浪费。

在老年代的对象大都是存活对象，复制算法在对象存活率教高的时候，效率就会变得比较低。根据老年代的特色，有人提出了“标记-压缩算法(Mark-Compact)”

标记过程与标记-清除的标记同样，但后续不是对可回收对象进行清理，而是让全部的对象都向一端移动，而后直接清理掉端边界之外的内存。

这种方法既避免了碎片的产生，又不须要两块相同的内存空间，所以，其性价比比较高。

根据对象存活的周期不一样将内存划分为几块，通常是把Java堆分为老年代和新生代，这样根据各个年代的特色采用适当的收集算法。

新生代每次收集都有大量对象死去，只有少许存活，那就选用复制算法，复制的对象数较少就可完成收集。 老年代对象存活率高，使用标记-压缩算法，以提升垃圾回收效率。

程序在启动的时候，并不会一次性加载程序所要用的全部class文件，而是根据程序的须要，经过Java的类加载机制（ClassLoader）来动态加载某个class文件到内存当中的，从而只有class文件被载入到了内存以后，才能被其它class所引用。因此ClassLoader就是用来动态加载class文件到内存当中用的。

每一个ClassLoader实例都有一个父类加载器的引用（不是继承关系，是一个包含的关系），虚拟机内置的类加载器（Bootstrap ClassLoader）自己没有父类加载器，可是能够用作其余ClassLoader实例的父类加载器。

当一个ClassLoader 实例须要加载某个类时，它会试图在亲自搜索这个类以前先把这个任务委托给它的父类加载器，这个过程是由上而下依次检查的，首先由顶层的类加载器Bootstrap CLassLoader进行加载，若是没有加载到，则把任务转交给Extension CLassLoader视图加载，若是也没有找到，则转交给AppCLassLoader进行加载，仍是没有的话，则交给委托的发起者，由它到指定的文件系统或者网络等URL中进行加载类。尚未找到的话，则会抛出CLassNotFoundException异常。不然将这个类生成一个类的定义，并将它加载到内存中，最后返回这个类在内存中的Class实例对象。

JVM在判断两个class是否相同时，不只要判断两个类名是否相同，还要判断是不是同一个类加载器加载的。

避免重复加载，父类已经加载了，则子CLassLoader没有必要再次加载。 考虑安全因素，假设自定义一个String类，除非改变JDK中CLassLoader的搜索类的默认算法，不然用户自定义的CLassLoader如法加载一个本身写的String类，由于String类在启动时就被引导类加载器Bootstrap CLassLoader加载了。

关于Android的双亲委托机制，能够参考

Java集合类主要由两个接口派生出：Collection和Map，这两个接口是Java集合的根接口。

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

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

List,Set都是继承自Collection接口，Map则不是; List特色：元素有放入顺序，元素可重复; Set特色：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，可是元素在set中的位置是有该元素的HashCode决定的，其位置实际上是固定的，加入Set 的Object必须定义equals()方法;

Vector是多线程安全的，线程安全就是说多线程访问同一代码，不会产生不肯定的结果。而ArrayList不是，这个能够从源码中看出，Vector类中的方法不少有synchronized进行修饰，这样就致使了Vector在效率上没法与ArrayList相比； 两个都是采用的线性连续空间存储元素，可是当空间不足的时候，两个类的增长方式是不一样。 Vector能够设置增加因子，而ArrayList不能够。 Vector是一种老的动态数组，是线程同步的，效率很低，通常不同意使用。

在HashMap中进行查找是否存在这个key，value始终是同样的，主要有如下几种状况：

• 若是hash码值不相同，说明是一个新元素，存；
• 若是hash码值相同，且equles判断相等，说明元素已经存在，不存；
• 若是hash码值相同，且equles判断不相等，说明元素不存在，存；
• 若是有元素和传入对象的hash值相等，那么，继续进行equles()判断，若是仍然相等，那么就认为传入元素已经存在，再也不添加，结束，不然仍然添加；

• HashSet是基于Hash算法实现的，其性能一般都优于TreeSet。为快速查找而设计的Set，咱们一般都应该使用HashSet，在咱们须要排序的功能时，咱们才使用TreeSet。
• TreeSet 是二叉树（红黑树的树据结构）实现的,Treeset中的数据是自动排好序的，不容许放入null值
• HashSet是哈希表实现的,HashSet中的数据是无序的，能够放入null，但只能放入一个null，二者中的值都不能重复，就如数据库中惟一约束。
• HashSet是基于Hash算法实现的，其性能一般都优于TreeSet。为快速查找而设计的Set，咱们一般都应该使用HashSet，在咱们须要排序的功能时，咱们才使用TreeSet。

HashMap 非线程安全，基于哈希表(散列表)实现。使用HashMap要求添加的键类明肯定义了hashCode()和equals()[能够重写hashCode()和equals()]，为了优化HashMap空间的使用，您能够调优初始容量和负载因子。其中散列表的冲突处理主要分两种，一种是开放定址法，另外一种是链表法。HashMap的实现中采用的是链表法。 TreeMap：非线程安全基于红黑树实现，TreeMap没有调优选项，由于该树总处于平衡状态

当数值范围为-128~127时：若是两个new出来Integer对象，即便值相同，经过“==”比较结果为false，但两个对象直接赋值，则经过“==”比较结果为“true，这一点与String很是类似。 当数值不在-128~127时，不管经过哪一种方式，即便两个对象的值相等，经过“==”比较，其结果为false； 当一个Integer对象直接与一个int基本数据类型经过“==”比较，其结果与第一点相同； Integer对象的hash值为数值自己；

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操做的数据类型被指定为一个参数。这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

泛型的好处是在编译的时候检查类型安全，而且全部的强制转换都是自动和隐式的，提升代码的重用率。

它提供了编译期的类型安全，确保你只能把正确类型的对象放入 集合中，避免了在运行时出现ClassCastException。

使用Java的泛型时应注意如下几点：

• 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
• 同一种泛型能够对应多个版本（由于参数类型是不肯定的），不一样版本的泛型类实例是不兼容的。
• 泛型的类型参数能够有多个。
• 泛型的参数类型能够使用extends语句，例如。习惯上称为“有界类型”。

• ？ 表示不肯定的java类型。

Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

泛型是经过类型擦除来实现的，编译器在编译时擦除了全部类型相关的信息，因此在运行时不存在任何类型相关的信息。例如 List在运行时仅用一个List来表示。这样作的目的，是确保能和Java 5以前的版本开发二进制类库进行兼容。你没法在运行时访问到类型参数，由于编译器已经把泛型类型转换成了原始类型。

一种是<? extends T>它经过确保类型必须是T的子类来设定类型的上界， 另外一种是<? super T>它经过确保类型必须是T的父类来设定类型的下界。 另外一方面表 示了非限定通配符，由于能够用任意类型来替代。 例如List<? extends Number>能够接受List或List。

对任何一个不太熟悉泛型的人来讲，这个Java泛型题目看起来使人疑惑，由于乍看起来String是一种Object，因此 List应当能够用在须要List的地方，可是事实并不是如此。真这样作的话会致使编译错误。如 果你再深一步考虑，你会发现Java这样作是有意义的，由于List能够存储任何类型的对象包括String, Integer等等，而List却只能用来存储Strings。

JAVA反射机制是在运行状态中，对于任意一个类，都可以知道这个类的全部属性和方法；对于任意一个对象，都可以调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了如下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具备的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳所有的排序记录，在排序过程当中须要访问外存。

将第一个数和第二个数排序，而后构成一个有序序列 将第三个数插入进去，构成一个新的有序序列。 对第四个数、第五个数……直到最后一个数，重复第二步。 代码：

首先设定插入次数，即循环次数，for(int i=1;i<length;i++)，1个数的那次不用插入。 设定插入数和获得已经排好序列的最后一个数的位数。insertNum和j=i-1。

单例主要分为：懒汉式单例、饿汉式单例、登记式单例。

1. 单例类必须本身建立本身的惟一实例
2. 单例类必须给全部其余对象提供这一实例。

在计算机系统中，像线程池，缓存、日志对象、对话框、打印机等常被设计成单例。

Singleton经过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的惟一实例只能经过getInstance()方法访问。（事实上，经过Java反射机制是可以实例化构造方法为private的类的，那基本上会使全部的Java单例实现失效。

它是线程不安全的，并发状况下颇有可能出现多个Singleton实例，要实现线程安全，有如下三种方式： 1.在getInstance方法上加上同步

这种方式对比前两种，既实现了线程安全，又避免了同步带来的性能影响。

饿汉式在建立类的同时就已经建立好了一个静态的对象供系统使用，之后再也不改变，因此天生是系统安全。

Java虚拟机是如何加载Java类的？  这个问题也就是面试常问到的Java类加载机制。在年初面试百战之后，菜鸟喜鹊也是能把这流程倒背如流啊！但是，也只是字面上的背诵，根本就是像上学时背书考试一样。

tonight ！ 我们把它映射到实战里，看看如何用代码说明这个流程。

一、类加载机制（理论部分）

 类加载机制有三大过程：加载、链接、初始化。其中链接又细分为验证、准备及解析。

Java语言的类型分为两大类：基本类型和引用类型。Java的基本类型是由Java虚拟机预先定义好的。而引用类型又分为：数组类、类、接口、泛型参数。在JVM中，只存在数组类、类、接口三类，而数组类是直接由Java虚拟机直接生成的，其他两类则有字节流而来。

字节流又是怎么来呢？最常见的还是从字节码文件而来（还可以从网络等而来）。所以，我就以字节码文件分析一下加载机制。