Java面试题集

前几天,有朋友去面试之前问我关于后端架构相关的问题,但奈于我去年很多其它的工作是在移动SDK开发上,对此有所遗忘,实属无奈,后面准备总结下.

今天要谈的主题是关于求职.求职是在每一个技术人员的生涯中都要经历多次,对于我们大部分人而言,在进入自己心仪的公司之前少不了准备工作,有一份全面仔细面试题将帮助我们降低很多麻烦.在跳槽季来临之前,特地做这个系列的文章,一方面帮助自己巩固下基础,还有一方面也希望帮助想要换工作的朋友.

从12年開始,我先后做过爬虫,搜索,机器学习,javaEE及Android等方面的事情,而其中主要的工具便是Java和C,所以这个系列的重点也放在这双方面.感兴趣的朋友能够关注:https://github.com/closedevice/interview-about.

为了更好的树立知识体系,我附加了相关的思维导图,分为pdf版和mindnote版.比方java相关的导图例如以下:

由于时间仓促,有些地方未写完,后面会继续补充.如有不妥之处,欢迎及时与我沟通.

---

相关概念

面向对象的三个特征

封装,继承,多态.这个应该是人人皆知.有时候也会加上抽象.

多态的优点

同意不同类对象对同一消息做出响应,即同一消息能够依据发送对象的不同而採用多种不同的行为方式(发送消息就是函数调用).主要有下面优点:

1. 可替换性:多态对已存在代码具有可替换性.
2. 可扩充性:添加新的子类不影响已经存在的类结构.
3. 接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完好或者重写它来实现的.
4. 灵活性:
5. 简化性:

代码中怎样实现多态

实现多态主要有下面三种方式:
1. 接口实现
2. 继承父类重写方法
3. 同一类中进行方法重载

虚拟机是怎样实现多态的

动态绑定技术(dynamic binding),运行期间推断所引用对象的实际类型,依据实际类型调用相应的方法.

接口的意义

接口的意义用三个词就能够概括:规范,扩展,回调.

抽象类的意义

抽象类的意义能够用三句话来概括:

1. 为其它子类提供一个公共的类型
2. 封装子类中反复定义的内容
3. 定义抽象方法,子类尽管有不同的实现,可是定义时一致的

接口和抽象类的差别

比較	抽象类	接口
默认方法	抽象类能够有默认的方法实现	,java 8之前,接口中不存在方法的实现.
实现方式	子类使用extends关键字来继承抽象类.假设子类不是抽象类,子类须要提供抽象类中所声明方法的实现.	子类使用implements来实现接口,须要提供接口中全部声明的实现.
构造器	抽象类中能够有构造器,	接口中不能
和正常类差别	抽象类不能被实例化	接口则是全然不同的类型
訪问修饰符	抽象方法能够有public,protected和default等修饰	接口默认是public,不能使用其它修饰符
多继承	一个子类仅仅能存在一个父类	一个子类能够存在多个接口
加入新方法	想抽象类中加入新方法,能够提供默认的实现,因此能够不改动子类现有的代码	假设往接口中加入新方法,则子类中须要实现该方法.

父类的静态方法是否能被子类重写

不能.重写仅仅适用于实例方法,不能用于静态方法,而子类其中含有和父类同样签名的静态方法,我们一般称之为隐藏.

什么是不可变对象

不可变对象指对象一旦被创建，状态就不能再改变。不论什么改动都会创建一个新的对象。如 String、Integer及其它包装类。

静态变量和实例变量的差别?

静态变量存储在方法区,属于类全部.实例变量存储在堆其中,其引用存在当前线程栈.

是否能创建一个包括可变对象的不可变对象?

当然能够创建一个包括可变对象的不可变对象的。你仅仅须要慎重一点，不要共享可变对象的引用就能够了。假设须要变化时，就返回原对象的一个拷贝。最常见的样例就是对象中包括一个日期对象的引用.

java 创建对象的几种方式

1. 採用new
2. 通过反射
3. 採用clone
4. 通过序列化机制

前2者都须要显式地调用构造方法. 造成耦合性最高的恰好是第一种,因此你发现不管什么框架,仅仅要涉及到解耦必先降低new的使用.

switch中是否能使用string做參数

在idk 1.7之前,switch仅仅能支持byte,short,char,int或者其相应的封装类以及Enum类型。

从idk 1.7之后switch開始支持String.

switch是否能作用在byte,long上?

能够用在byte上,可是不能用在long上.

String s1=”ab”,String s2=”a”+”b”,String s3=”a”,String s4=”b”,s5=s3+s4请问s5==s2返回什么?

返回false.在编译过程中,编译器会将s2直接优化为”ab”,会将其放置在常量池其中,s5则是被创建在堆区,相当于s5=new String(“ab”);

你对String对象的intern()熟悉么?

intern()方法会首先从常量池中查找是否存在该常量值,假设常量池中不存在则如今常量池中创建,假设已经存在则直接返回.
比方
String s1=”aa”;
String s2=s1.intern();
System.out.print(s1==s2);//返回true

Object中有哪些公共方法?

1. equals()
2. clone()
3. getClass()
4. notify(),notifyAll(),wait()
5. toString

java其中的四种引用

强引用,软引用,弱引用,虚引用.不同的引用类型主要体如今GC上:

1. 强引用：假设一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。假设想中断强引用和某个对象之间的关联，能够显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象
2. 软引用：在使用软引用时。假设内存的空间足够。软引用就能继续被使用，而不会被垃圾回收器回收。仅仅有在内存不足时。软引用才会被垃圾回收器回收。
3. 弱引用：具有弱引用的对象拥有的生命周期更短暂。

   由于当 JVM 进行垃圾回收，一旦发现弱引用对象。不管当前内存空间是否充足，都会将弱引用回收。只是由于垃圾回收器是一个优先级较低的线程。所以并不一定能迅速发现弱引用对象

4. 虚引用：顾名思义，就是形同虚设，假设一个对象仅持有虚引用，那么它相当于没有引用。在不论什么时候都可能被垃圾回收器回收。

很多其它了解參见深入对象引用

WeakReference与SoftReference的差别?

这点在四种引用类型中已经做了解释,这里简单说明一下就可以:
尽管 WeakReference 与 SoftReference 都有利于提高 GC 和 内存的效率，可是 WeakReference ，一旦失去最后一个强引用，就会被 GC 回收。而软引用尽管不能阻止被回收。可是能够延迟到 JVM 内存不足的时候。

为什么要有不同的引用类型

不像C语言,我们能够控制内存的申请和释放,在Java中有时候我们须要适当的控制对象被回收的时机,因此就诞生了不同的引用类型,能够说不同的引用类型实则是对GC回收时机不可控的妥协.有下面几个使用场景能够充分的说明:

1. 利用软引用和弱引用解决OOM问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自己主动回收这些缓存图片对象所占用的空间。从而有效地避免了OOM的问题.
2. 通过软引用实现Java对象的快速缓存:比方我们创建了一Person的类，假设每次须要查询一个人的信息,哪怕是几秒中之前刚刚查询过的，都要又一次构建一个实例。这将引起大量Person对象的消耗,而且由于这些对象的生命周期相对较短,会引起多次GC影响性能。此时,通过软引用和 HashMap 的结合能够构建快速缓存,提供性能.

java中==和eqauls()的差别,equals()和`hashcode的差别

==是运算符,用于比較两个变量是否相等,而equals是Object类的方法,用于比較两个对象是否相等.默认Object类的equals方法是比較两个对象的地址,此时和==的结果一样.换句话说:基本类型比較用==,比較的是他们的值.默认下,对象用==比較时,比較的是内存地址,假设须要比較对象内容,须要重写equal方法

equals()和hashcode()的联系

hashCode()是Object类的一个方法,返回一个哈希值.假设两个对象依据equal()方法比較相等,那么调用这两个对象中随意一个对象的hashCode()方法必须产生同样的哈希值.
假设两个对象依据eqaul()方法比較不相等,那么产生的哈希值不一定相等(碰撞的情况下还是会相等的.)

a.hashCode()有什么用?

与a.equals(b)有什么关系

hashCode() 方法是相应对象整型的 hash 值。它经常使用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。

依据 Java 规范，使用 equal() 方法来推断两个相等的对象。必须具有同样的 hashcode。

将对象放入到集合中时,首先推断要放入对象的hashcode是否已经在集合中存在,不存在则直接放入集合.假设hashcode相等,然后通过equal()方法推断要放入对象与集合中的随意对象是否相等:假设equal()推断不相等,直接将该元素放入集合中,否则不放入.

有没有可能两个不相等的对象有同样的hashcode

有可能，两个不相等的对象可能会有同样的 hashcode 值，这就是为什么在 hashmap 中会有冲突。假设两个对象相等，必须有同样的hashcode 值。反之不成立.

能够在hashcode中使用随机数字吗?

不行。由于同一对象的 hashcode 值必须是同样的

a==b与a.equals(b)有什么差别

假设a 和b 都是对象，则 a==b 是比較两个对象的引用，仅仅有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比較，所以通常须要重写该方法来提供逻辑一致性的比較。比如，String 类重写 equals() 方法，所以能够用于两个不同对象，可是包括的字母同样的比較。

3*0.1==0.3返回值是什么

false，由于有些浮点数不能全然精确的表示出来。

a=a+b与a+=b有什么差别吗?

+=操作符会进行隐式自己主动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,而a=a+b则不会自己主动进行类型转换.如：
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok
（译者注：这个地方应该表述的有误。事实上不管 a+b 的值为多少，编译器都会报错，由于 a+b 操作会将 a、b 提升为 int 类型。所以将 int 类型赋值给 byte 就会编译出错）

short s1= 1; s1 = s1 + 1; 该段代码是否有错,有的话怎么改？

有错误,short类型在进行运算时会自己主动提升为int类型,也就是说s1+1的运算结果是int类型.

short s1= 1; s1 += 1; 该段代码是否有错,有的话怎么改？

+=操作符会自己主动对右边的表达式结果强转匹配左边的数据类型,所以没错.

& 和 &&的差别

首先记住&是位操作,而&&是逻辑运算符.另外须要记住逻辑运算符具有短路特性,而&不具备短路特性.

public class Test{
    static String name;

    public static void main(String[] args){
        if(name!=null&userName.equals("")){
            System.out.println("ok");
        }else{
            System.out.println("erro");
        }
    }
}

以上代码将会抛出空指针异常.

一个.java文件内部能够有类?(非内部类)

仅仅能有一个public公共类,可是能够有多个default修饰的类.

怎样正确的退出多层嵌套循环.

1. 使用标号和break;
2. 通过在外层循环中加入标识符

内部类的作用

内部类能够有多个实例,每一个实例都有自己的状态信息,而且与其它外围对象的信息相互独立.在单个外围类其中,能够让多个内部类以不同的方式实现同一接口,或者继承同一个类.创建内部类对象的时刻不依赖于外部类对象的创建.内部类并没有令人疑惑的”is-a”关系,它就像是一个独立的实体.

内部类提供了更好的封装,除了该外围类,其它类都不能訪问

final,finalize和finally的不同之处

final 是一个修饰符，能够修饰变量、方法和类。假设 final 修饰变量。意味着该变量的值在初始化后不能被改变。

finalize 方法是在对象被回收之前调用的方法。给对象自己最后一个复活的机会，可是什么时候调用 finalize 没有保证。

finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被运行，不管在 try 块中是否有发生异常。

clone()是哪个类的方法?

java.lang.Cloneable 是一个标示性接口，不包括不论什么方法，clone 方法在 object 类中定义。

而且须要知道 clone() 方法是一个本地方法，这意味着它是由 c 或 c++ 或 其它本地语言实现的。

深拷贝和浅拷贝的差别是什么?

浅拷贝：被复制对象的全部变量都含有与原来的对象同样的值，而全部的对其它对象的引用仍然指向原来的对象。

换言之，浅拷贝仅仅复制所考虑的对象。而不复制它所引用的对象。

深拷贝：被复制对象的全部变量都含有与原来的对象同样的值。而那些引用其它对象的变量将指向被复制过的新对象。而不再是原有的那些被引用的对象。

换言之。深拷贝把要复制的对象所引用的对象都复制了一遍。

static都有哪些使用方法?

差点儿全部的人都知道static关键字这两个主要的使用方法:静态变量和静态方法.也就是被static所修饰的变量/方法都属于类的静态资源,类实例所共享.

除了静态变量和静态方法之外,static也用于静态块,多用于初始化操作:

public calss PreCache{
    static{
        //运行相关操作
    }
}

此外static也多用于修饰内部类,此时称之为静态内部类.

最后一种使用方法就是静态导包,即import static.import static是在JDK 1.5之后引入的新特性,能够用来指定导入某个类中的静态资源,而且不须要使用类名.资源名,能够直接使用资源名,比方:

import static java.lang.Math.*;

public class Test{

    public static void main(String[] args){
        //System.out.println(Math.sin(20));传统做法
        System.out.println(sin(20));
    }
}

final有哪些使用方法

final也是非常多面试喜欢问的地方,能回答下下面三点就不错了:
1.被final修饰的类不能够被继承
2.被final修饰的方法不能够被重写
3.被final修饰的变量不能够被改变.假设修饰引用,那么表示引用不可变,引用指向的内容可变.
4.被final修饰的方法,JVM会尝试将其内联,以提高运行效率
5.被final修饰的常量,在编译阶段会存入常量池中.

回答出编译器对final域要遵守的两个重排序规则更好:
1.在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序.
2.初次读一个包括final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序.

---

数据类型相关

java中int char,long各占多少字节?

类型	位数	字节数
short	2	16
int	4	32
long	8	64
float	4	32
double	8	64
char	2	16

64位的JVM其中,int的长度是多少?

Java 中。int 类型变量的长度是一个固定值。与平台无关，都是 32 位。

意思就是说，在 32 位 和 64 位 的Java 虚拟机中，int 类型的长度是同样的。

int和Integer的差别

Integer是int的包装类型,在拆箱和装箱中,二者自己主动转换.int是基本类型。直接存数值。而integer是对象，用一个引用指向这个对象.

int 和Integer谁占用的内存很多其它?

Integer 对象会占用很多其它的内存。Integer是一个对象。须要存储对象的元数据。可是 int 是一个原始类型的数据。所以占用的空间更少。

String,StringBuffer和StringBuilder差别

String是字符串常量,final修饰;StringBuffer字符串变量(线程安全);
StringBuilder 字符串变量(线程不安全).

String和StringBuffer

String和StringBuffer主要差别是性能:String是不可变对象,每次对String类型进行操作都等同于产生了一个新的String对象,然后指向新的String对象.所以尽量不在对String进行大量的拼接操作,否则会产生非常多暂时对象,导致GC開始工作,影响系统性能.

StringBuffer是对对象本身操作,而不是产生新的对象,因此在有大量拼接的情况下,我们建议使用StringBuffer.

可是须要注意如今JVM会对String拼接做一定的优化:
String s=“This is only ”+”simple”+”test”会被虚拟机直接优化成String s=“This is only simple test”,此时就不存在拼接过程.

StringBuffer和StringBuilder

StringBuffer是线程安全的可变字符串,其内部实现是可变数组.StringBuilder是jdk 1.5新增的,其功能和StringBuffer相似,可是非线程安全.因此,在没有多线程问题的前提下,使用StringBuilder会取得更好的性能.

什么是编译器常量?使用它有什么风险?

公共静态不可变（public static final ）变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，由于编译器知道这些变量的值，而且知道这些变量在运行时不能改变。这样的方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量。可是这个值后面被其它人改变了，可是你的client仍然在使用老的值。甚至你已经部署了一个新的jar。为了避免这样的情况。当你在更新依赖 JAR 文件时，确保又一次编译你的程序。

java其中使用什么类型表示价格比較好?

假设不是特别关心内存和性能的话，使用BigDecimal，否则使用提前定义精度的 double 类型。

怎样将byte转为String

能够使用 String 接收 byte[] 參数的构造器来进行转换。须要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码同样，也可能不同。

能够将int强转为byte类型么?

会产生什么问题?

我们能够做强制转换。可是Java中int是32位的而byte是8 位的。所以,假设强制转化int类型的高24位将会被丢弃。byte 类型的范围是从-128到128

---

关于垃圾回收

你知道哪些垃圾回收算法?

垃圾回收从理论上非常easy理解,详细的方法有下面几种:
1. 标记-清除
2. 标记-复制
3. 标记-整理
4. 分代回收
更详细的内容參见深入理解垃圾回收算法

怎样推断一个对象是否应该被回收

这就是所谓的对象存活性推断,经常使用的方法有两种:1.引用计数法;2:对象可达性分析.由于引用计数法存在互相引用导致无法进行GC的问题,所以眼下JVM虚拟机多使用对象可达性分析算法.

简单的解释一下垃圾回收

Java 垃圾回收机制最主要的做法是分代回收。内存中的区域被划分成不同的世代。对象依据其存活的时间被保存在相应世代的区域中。

一般的实现是划分成3个世代：年轻、年老和永久。

内存的分配是发生在年轻世代中的。当一个对象存活时间足够长的时候，它就会被拷贝到年老世代中。对于不同的世代能够使用不同的垃圾回收算法。进行世代划分的出发点是相应用中对象存活时间进行研究之后得出的统计规律。一般来说，一个应用中的大部分对象的存活时间都非常短。比方局部变量的存活时间就仅仅在方法的运行过程中。基于这一点。对于年轻世代的垃圾回收算法就能够非常有针对性.

调用System.gc()会发生什么?

通知GC開始工作,可是GC真正開始的时间不确定.

---

进程,线程相关

说说进程,线程,协程之间的差别

简而言之,进程是程序运行和资源分配的基本单位,一个程序至少有一个进程,一个进程至少有一个线程.进程在运行过程中拥有独立的内存单元,而多个线程共享内存资源,降低切换次数,从而效率更高.线程是进程的一个实体,是cpu调度和分派的基本单位,是比程序更小的能独立运行的基本单位.同一进程中的多个线程之间能够并发运行.

你了解守护线程吗?它和非守护线程有什么差别

程序运行完成,jvm会等待非守护线程完成后关闭,可是jvm不会等待守护线程.守护线程最典型的样例就是GC线程

什么是多线程上下文切换

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU运行权的线程的过程。

创建两种线程的方式?他们有什么差别?

通过实现java.lang.Runnable或者通过扩展java.lang.Thread类.相比扩展Thread,实现Runnable接口可能更优.原因有二:

1. Java不支持多继承.因此扩展Thread类就代表这个子类不能扩展其它类.而实现Runnable接口的类还可能扩展还有一个类.
2. 类可能仅仅要求可运行就可以,因此继承整个Thread类的开销过大.

Thread类中的start()和run()方法有什么差别?

start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。

当你调用run()方法的时候，仅仅会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

怎么检測一个线程是否持有对象监视器

Thread类提供了一个holdsLock(Object obj)方法，当且仅当对象obj的监视器被某条线程持有的时候才会返回true，注意这是一个static方法。这意味着”某条线程”指的是当前线程。

Runnable和Callable的差别

Runnable接口中的run()方法的返回值是void，它做的事情仅仅是纯粹地去运行run()方法中的代码而已；Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合能够用来获取异步运行的结果。
这事实上是非常实用的一个特性，由于多线程相比单线程更难、更复杂的一个重要原因就是由于多线程充满着未知性，某条线程是否运行了？某条线程运行了多久？某条线程运行的时候我们期望的数据是否已经赋值完成？无法得知，我们能做的仅仅是等待这条多线程的任务运行完成而已。而Callable+Future/FutureTask却能够方便获取多线程运行的结果，能够在等待时间太长没获取到须要的数据的情况下取消该线程的任务

什么导致线程堵塞

堵塞指的是暂停一个线程的运行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经非常熟悉了。

Java 提供了大量方法来支持堵塞，下面让我们逐一分析。

方法	说明
sleep()	sleep() 同意 指定以毫秒为单位的一段时间作为參数，它使得线程在指定的时间内进入堵塞状态，不能得到CPU 时间。指定的时间一过，线程又一次进入可运行状态。 典型地，sleep() 被用在等待某个资源就绪的情形：測试发现条件不满足后，让线程堵塞一段时间后又一次測试，直到条件满足为止
suspend() 和 resume()	两个方法配套使用，suspend()使得线程进入堵塞状态，而且不会自己主动恢复。必须其相应的resume() 被调用，才干使得线程又一次进入可运行状态。典型地，suspend() 和 resume() 被用在等待还有一个线程产生的结果的情形：測试发现结果还没有产生后，让线程堵塞，还有一个线程产生了结果后，调用 resume() 使其恢复。
yield()	yield() 使当前线程放弃当前已经分得的CPU 时间。但不使当前线程堵塞，即线程仍处于可运行状态，随时可能再次分得 CPU 时间。 调用 yield() 的效果等价于调度程序觉得该线程已运行了足够的时间从而转到还有一个线程
wait() 和 notify()	两个方法配套使用，wait() 使得线程进入堵塞状态，它有两种形式。一种同意 指定以毫秒为单位的一段时间作为參数。还有一种没有參数，前者当相应的 notify() 被调用或者超出指定时间时线程又一次进入可运行状态。后者则必须相应的 notify() 被调用.

wait(),notify()和suspend(),resume()之间的差别

初看起来它们与 suspend() 和 resume() 方法对没有什么分别，可是事实上它们是截然不同的。

差别的核心在于，前面叙述的全部方法，堵塞时都不会释放占用的锁（假设占用了的话），而这一对方法则相反。

上述的核心差别导致了一系列的细节上的差别。

首先，前面叙述的全部方法都隶属于 Thread 类，可是这一对却直接隶属于 Object 类，也就是说。全部对象都拥有这一对方法。初看起来这十分不可思议，可是实际上却是非常自然的，由于这一对方法堵塞时要释放占用的锁，而锁是不论什么对象都具有的，调用随意对象的 wait() 方法导致线程堵塞，而且该对象上的锁被释放。而调用 随意对象的notify()方法则导致从调用该对象的 wait() 方法而堵塞的线程中随机选择的一个解除堵塞（但要等到获得锁后才真正可运行）。

其次，前面叙述的全部方法都可在不论什么位置调用。可是这一对方法却必须在 synchronized 方法或块中调用，理由也非常easy，仅仅有在synchronized 方法或块中当前线程才占有锁，才有锁能够释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁能够释放。

因此，这一对方法调用必须放置在这样的 synchronized 方法或块中。该方法或块的上锁对象就是调用这一对方法的对象。

若不满足这一条件，则程序尽管仍能编译，但在运行时会出现IllegalMonitorStateException 异常。

wait() 和 notify() 方法的上述特性决定了它们经常和synchronized关键字一起使用。将它们和操作系统进程间通信机制作一个比較就会发现它们的相似性：synchronized方法或块提供了相似于操作系统原语的功能，它们的运行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。它们的结合使得我们能够实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。

关于 wait() 和 notify() 方法最后再说明两点：
第一：调用 notify() 方法导致解除堵塞的线程是从因调用该对象的 wait() 方法而堵塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这样的不确定性而产生问题。

第二：除了 notify()，还有一个方法 notifyAll() 也可起到相似作用，唯一的差别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而堵塞的全部线程一次性全部解除堵塞。当然，仅仅有获得锁的那一个线程才干进入可运行状态。

谈到堵塞。就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是。Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。

以上我们对 Java 中实现线程堵塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify() 方法，由于它们的功能最强大，使用也最灵活，可是这也导致了它们的效率较低，较easy出错。实际使用中我们应该灵活使用各种方法。以便更好地达到我们的目的。

产生死锁的条件

1.相互排斥条件：一个资源每次仅仅能被一个进程使用。
2.请求与保持条件：一个进程因请求资源而堵塞时。对已获得的资源保持不放。
3.不剥夺条件:进程已获得的资源。在末使用完之前，不能强行剥夺。
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

为什么wait()方法和notify()/notifyAll()方法要在同步块中被调用

这是JDK强制的，wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁

wait()方法和notify()/notifyAll()方法在放弃对象监视器时有什么差别

wait()方法和notify()/notifyAll()方法在放弃对象监视器的时候的差别在于：wait()方法马上释放对象监视器。notify()/notifyAll()方法则会等待线程剩余代码运行完成才会放弃对象监视器。

wait()与sleep()的差别

关于这两者已经在上面进行详细的说明,这里就做个概括好了:

• sleep()来自Thread类。和wait()来自Object类.调用sleep()方法的过程中，线程不会释放对象锁。

  而 调用 wait 方法线程会释放对象锁

• sleep()睡眠后不出让系统资源。wait让其它线程能够占用CPU
• sleep(milliseconds)须要指定一个睡眠时间，时间一到会自己主动唤醒.而wait()须要配合notify()或者notifyAll()使用

为什么wait,nofity和nofityAll这些方法不放在Thread类其中

一个非常明显的原因是JAVA提供的锁是对象级的而不是线程级的，每一个对象都有锁，通过线程获得。假设线程须要等待某些锁那么调用对象中的wait()方法就有意义了。假设wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。

简单的说，由于wait，notify和notifyAll都是锁级别的操作。所以把他们定义在Object类中由于锁属于对象。

怎么唤醒一个堵塞的线程

假设线程是由于调用了wait()、sleep()或者join()方法而导致的堵塞，能够中断线程，而且通过抛出InterruptedException来唤醒它；假设线程遇到了IO堵塞，无能为力，由于IO是操作系统实现的，Java代码并没有办法直接接触到操作系统。

什么是多线程的上下文切换

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU运行权的线程的过程。

synchronized和ReentrantLock的差别

synchronized是和if、else、for、while一样的关键字，ReentrantLock是类，这是二者的本质差别。既然ReentrantLock是类，那么它就提供了比synchronized很多其它更灵活的特性，能够被继承、能够有方法、能够有各种各样的类变量，ReentrantLock比synchronized的扩展性体如今几点上：
（1）ReentrantLock能够对获取锁的等待时间进行设置，这样就避免了死锁
（2）ReentrantLock能够获取各种锁的信息
（3）ReentrantLock能够灵活地实现多路通知
另外，二者的锁机制事实上也是不一样的:ReentrantLock底层调用的是Unsafe的park方法加锁，synchronized操作的应该是对象头中mark word.

FutureTask是什么

这个事实上前面有提到过，FutureTask表示一个异步运算的任务。FutureTask里面能够传入一个Callable的详细实现类。能够对这个异步运算的任务的结果进行等待获取、推断是否已经完成、取消任务等操作。

当然。由于FutureTask也是Runnable接口的实现类。所以FutureTask也能够放入线程池中。

一个线程假设出现了运行时异常怎么办?

假设这个异常没有被捕获的话。这个线程就停止运行了。另外重要的一点是：假设这个线程持有某个某个对象的监视器，那么这个对象监视器会被马上释放

Java其中有哪几种锁

1. 自旋锁: 自旋锁在JDK1.6之后就默认开启了。基于之前的观察，共享数据的锁定状态仅仅会持续非常短的时间，为了这一小段时间而去挂起和恢复线程有点浪费。所以这里就做了一个处理。让后面请求锁的那个线程在稍等一会。可是不放弃处理器的运行时间，看看持有锁的线程是否能快速释放。为了让线程等待，所以须要让线程运行一个忙循环也就是自旋操作。在jdk6之后，引入了自适应的自旋锁。也就是等待的时间不再固定了。而是由上一次在同一个锁上的自旋时间及锁的拥有者状态来决定

2. 偏向锁: 在JDK1.之后引入的一项锁优化，目的是消除数据在无竞争情况下的同步原语。

   进一步提升程序的运行性能。 偏向锁就是偏心的偏，意思是这个锁会偏向第一个获得他的线程。假设接下来的运行过程中。改锁没有被其它线程获取，则持有偏向锁的线程将永远不须要再进行同步。偏向锁能够提高带有同步但无竞争的程序性能，也就是说他并不一定总是对程序运行有利。假设程序中大多数的锁都是被多个不同的线程訪问，那偏向模式就是多余的，在详细问题详细分析的前提下，能够考虑是否使用偏向锁。

3. 轻量级锁: 为了降低获得锁和释放锁所带来的性能消耗，引入了“偏向锁”和“轻量级锁”，所以在Java SE1.6里锁一共同拥有四种状态。无锁状态。偏向锁状态，轻量级锁状态和重量级锁状态。它会随着竞争情况逐渐升级。锁能够升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁

怎样在两个线程间共享数据

通过在线程之间共享对象就能够了，然后通过wait/notify/notifyAll、await/signal/signalAll进行唤起和等待，比方说堵塞队列BlockingQueue就是为线程之间共享数据而设计的

怎样正确的使用wait()?

使用if还是while?

wait() 方法应该在循环调用，由于当线程获取到 CPU 開始运行的时候，其它条件可能还没有满足，所以在处理前，循环检測条件是否满足会更好。

下面是一段标准的使用 wait 和 notify 方法的代码：

 synchronized (obj) {
    while (condition does not hold)
      obj.wait(); // (Releases lock, and reacquires on wakeup)
      ... // Perform action appropriate to condition
 }

什么是线程局部变量ThreadLocal

线程局部变量是局限于线程内部的变量，属于线程自身全部。不在多个线程间共享。Java提供ThreadLocal类来支持线程局部变量，是一种实现线程安全的方式。可是在管理环境下（如 web server）使用线程局部变量的时候要特别小心，在这样的情况下，工作线程的生命周期比不论什么应用变量的生命周期都要长。不论什么线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。

ThreadLoal的作用是什么?

简单说ThreadLocal就是一种以空间换时间的做法在每一个Thread里面维护了一个ThreadLocal.ThreadLocalMap把数据进行隔离，数据不共享，自然就没有线程安全方面的问题了.

生产者消费者模型的作用是什么?

（1）通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率，这是生产者消费者模型最关键的数据
（2）解耦，这是生产者消费者模型附带的作用，解耦意味着生产者和消费者之间的联系少。联系越少越能够独自发展而不须要收到相互的制约

写一个生产者-消费者队列

能够通过堵塞队列实现,也能够通过wait-notify来实现.

使用堵塞队列来实现

//消费者
public class Producer implements Runnable{
    private final BlockingQueue<Integer> queue;

    public Producer(BlockingQueue q){
        this.queue=q;
    }

    @Override
    public void run() {
        try {
            while (true){
                Thread.sleep(1000);//模拟耗时
                queue.put(produce());
            }
        }catch (InterruptedException e){

        }
    }

    private int produce() {
        int n=new Random().nextInt(10000);
        System.out.println("Thread:" + Thread.currentThread().getId() + " produce:" + n);
        return n;
    }
}
//消费者
public class Consumer implements Runnable {
    private final BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue q){
        this.queue=q;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(2000);//模拟耗时
                consume(queue.take());
            }catch (InterruptedException e){

            }

        }
    }

    private void consume(Integer n) {
        System.out.println("Thread:" + Thread.currentThread().getId() + " consume:" + n);

    }
}
//測试
public class Main {

    public static void main(String[] args) {
        BlockingQueue<Integer> queue=new ArrayBlockingQueue<Integer>(100);
        Producer p=new Producer(queue);
        Consumer c1=new Consumer(queue);
        Consumer c2=new Consumer(queue);

        new Thread(p).start();
        new Thread(c1).start();
        new Thread(c2).start();
    }
}

使用wait-notify来实现

该种方式应该最经典,这里就不做说明了

假设你提交任务时，线程池队列已满，这时会发生什么

假设你使用的LinkedBlockingQueue，也就是无界队列的话，没关系，继续加入任务到堵塞队列中等待运行。由于LinkedBlockingQueue能够近乎觉得是一个无穷大的队列。能够无限存放任务；假设你使用的是有界队列比方说ArrayBlockingQueue的话，任务首先会被加入到ArrayBlockingQueue中，ArrayBlockingQueue满了，则会使用拒绝策略RejectedExecutionHandler处理满了的任务。默认是AbortPolicy。

为什么要使用线程池

避免频繁地创建和销毁线程，达到线程对象的重用。另外。使用线程池还能够依据项目灵活地控制并发的数目。

java中用到的线程调度算法是什么

抢占式。一个线程用完CPU之后。操作系统会依据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程运行。

Thread.sleep(0)的作用是什么

由于Java採用抢占式的线程调度算法。因此可能会出现某条线程经常获取到CPU控制权的情况，为了让某些优先级比較低的线程也能获取到CPU控制权，能够使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作。这也是平衡CPU控制权的一种操作。

什么是CAS

CAS，全称为Compare and Swap。即比較-替换。假设有三个操作数：内存值V、旧的预期值A、要改动的值B，当且仅当预期值A和内存值V同样时。才会将内存值改动为B并返回true，否则什么都不做并返回false。当然CAS一定要volatile变量配合，这样才干保证每次拿到的变量是主内存中最新的那个值，否则旧的预期值A对某条线程来说，永远是一个不会变的值A。仅仅要某次CAS操作失败，永远都不可能成功

什么是乐观锁和悲观锁

乐观锁：乐观锁觉得竞争不总是会发生，因此它不须要持有锁，将比較-替换这两个动作作为一个原子操作尝试去改动内存中的变量，假设失败则表示发生冲突，那么就应该有相应的重试逻辑。

悲观锁：悲观锁觉得竞争总是会发生，因此每次对某资源进行操作时。都会持有一个独占的锁，就像synchronized，不管三七二十一，直接上了锁就操作资源了。

ConcurrentHashMap的并发度是什么?

ConcurrentHashMap的并发度就是segment的大小。默觉得16，这意味着最多同一时候能够有16条线程操作ConcurrentHashMap。这也是ConcurrentHashMap对Hashtable的最大优势，不论什么情况下，Hashtable能同一时候有两条线程获取Hashtable中的数据吗？

ConcurrentHashMap的工作原理

ConcurrentHashMap在jdk 1.6和jdk 1.8实现原理是不同的.

jdk 1.6:

ConcurrentHashMap是线程安全的，可是与Hashtablea相比，实现线程安全的方式不同。

Hashtable是通过对hash表结构进行锁定。是堵塞式的，当一个线程占有这个锁时，其它线程必须堵塞等待其释放锁。ConcurrentHashMap是採用分离锁的方式。它并没有对整个hash表进行锁定。而是局部锁定。也就是说当一个线程占有这个局部锁时。不影响其它线程对hash表其它地方的訪问。

详细实现:ConcurrentHashMap内部有一个Segment

jdk 1.8

在jdk 8中，ConcurrentHashMap不再使用Segment分离锁。而是採用一种乐观锁CAS算法来实现同步问题。但其底层还是“数组+链表->红黑树”的实现。

CyclicBarrier和CountDownLatch差别

这两个类非常相似，都在java.util.concurrent下，都能够用来表示代码运行到某个点上，二者的差别在于：

• CyclicBarrier的某个线程运行到某个点上之后。该线程即停止运行。直到全部的线程都到达了这个点，全部线程才又一次运行；CountDownLatch则不是。某线程运行到某个点上之后。仅仅是给某个数值-1而已。该线程继续运行
• CyclicBarrier仅仅能唤起一个任务。CountDownLatch能够唤起多个任务
• CyclicBarrier可重用，CountDownLatch不可重用，计数值为0该CountDownLatch就不可再用了

java中的++操作符线程安全么?

不是线程安全的操作。它涉及到多个指令，如读取变量值。添加，然后存储回内存，这个过程可能会出现多个线程交差

你有哪些多线程开发良好的实践?

1. 给线程命名
2. 最小化同步范围
3. 优先使用volatile
4. 尽可能使用更高层次的并发工具而非wait和notify()来实现线程通信,如BlockingQueue,Semeaphore
5. 优先使用并发容器而非同步容器.
6. 考虑使用线程池

---

关于volatile关键字

能够创建Volatile数组吗?

Java 中能够创建 volatile类型数组，只是仅仅是一个指向数组的引用。而不是整个数组。

假设改变引用指向的数组，将会受到volatile 的保护。可是假设多个线程同一时候改变数组的元素。volatile标示符就不能起到之前的保护作用了

volatile能使得一个非原子操作变成原子操作吗?

一个典型的样例是在类中有一个 long 类型的成员变量。假设你知道该成员变量会被多个线程訪问，如计数器、价格等。你最好是将其设置为 volatile。为什么？由于 Java 中读取 long 类型变量不是原子的。须要分成两步。假设一个线程正在改动该 long 变量的值，还有一个线程可能仅仅能看到该值的一半（前 32 位）。可是对一个 volatile 型的 long 或 double 变量的读写是原子。

一种实践是用 volatile 修饰 long 和 double 变量，使其能按原子类型来读写。double 和 long 都是64位宽，因此对这两种类型的读是分为两部分的。第一次读取第一个 32 位。然后再读剩下的 32 位，这个过程不是原子的，但 Java 中 volatile 型的 long 或 double 变量的读写是原子的。

volatile 修复符的还有一个作用是提供内存屏障（memory barrier），比如在分布式框架中的应用。简单的说，就是当你写一个 volatile 变量之前，Java 内存模型会插入一个写屏障（write barrier）。读一个 volatile 变量之前，会插入一个读屏障（read barrier）。

意思就是说，在你写一个 volatile 域时，能保证不论什么线程都能看到你写的值。同一时候，在写之前。也能保证不论什么数值的更新对全部线程是可见的。由于内存屏障会将其它全部写的值更新到缓存。

volatile类型变量提供什么保证?

volatile 主要有双方面的作用:1.避免指令重排2.可见性保证.比如。JVM 或者 JIT为了获得更好的性能会对语句重排序，可是 volatile 类型变量即使在没有同步块的情况下赋值也不会与其它语句重排序。 volatile 提供 happens-before 的保证，确保一个线程的改动能对其它线程是可见的。

某些情况下，volatile 还能提供原子性，如读 64 位数据类型。像 long 和 double 都不是原子的(低32位和高32位)。但 volatile 类型的 double 和 long 就是原子的.

---

关于集合

Java中的集合及其继承关系

关于集合的体系是每一个人都应该烂熟于心的,尤其是对我们经常使用的List,Map的原理更该如此.这里我们看这张图就可以:

很多其它内容可见集合类总结

poll()方法和remove()方法差别?

poll() 和 remove() 都是从队列中取出一个元素。可是 poll() 在获取元素失败的时候会返回空。可是 remove() 失败的时候会抛出异常。

LinkedHashMap和PriorityQueue的差别

PriorityQueue 是一个优先级队列,保证最高或者最低优先级的的元素总是在队列头部。可是 LinkedHashMap 维持的顺序是元素插入的顺序。当遍历一个 PriorityQueue 时，没有不论什么顺序保证。可是 LinkedHashMap 课保证遍历顺序是元素插入的顺序。

WeakHashMap与HashMap的差别是什么?

WeakHashMap 的工作与正常的 HashMap 相似，可是使用弱引用作为 key，意思就是当 key 对象没有不论什么引用时。key/value 将会被回收。

ArrayList和LinkedList的差别?

最明显的差别是 ArrrayList底层的数据结构是数组，支持随机訪问，而 LinkedList 的底层数据结构是双向循环链表。不支持随机訪问。

使用下标訪问一个元素，ArrayList 的时间复杂度是 O(1)，而 LinkedList 是 O(n)。

ArrayList和Array有什么差别?

1. Array能够容纳基本类型和对象，而ArrayList仅仅能容纳对象。
2. Array是指定大小的，而ArrayList大小是固定的

ArrayList和HashMap默认大小?

在 Java 7 中，ArrayList 的默认大小是 10 个元素，HashMap 的默认大小是16个元素（必须是2的幂）。这就是 Java 7 中 ArrayList 和 HashMap 类的代码片段

private static final int DEFAULT_CAPACITY = 10;

 //from HashMap.java JDK 7
 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

Comparator和Comparable的差别?

Comparable 接口用于定义对象的自然顺序，而 comparator 通经常使用于定义用户定制的顺序。

Comparable 总是仅仅有一个。可是能够有多个 comparator 来定义对象的顺序。

怎样实现集合排序?

你能够使用有序集合，如 TreeSet 或 TreeMap，你也能够使用有顺序的的集合。如 list，然后通过 Collections.sort() 来排序。

怎样打印数组内容

你能够使用 Arrays.toString() 和 Arrays.deepToString() 方法来打印数组。由于数组没有实现 toString() 方法。所以假设将数组传递给 System.out.println() 方法，将无法打印出数组的内容，可是 Arrays.toString() 能够打印每一个元素。

LinkedList的是单向链表还是双向?

双向循环列表,详细实现自行查阅源代码.

TreeMap是实现原理

採用红黑树实现,详细实现自行查阅源代码.

遍历ArrayList时怎样正确移除一个元素

该问题的关键在于面试者使用的是 ArrayList 的 remove() 还是 Iterator 的 remove()方法。这有一段演示样例代码。是使用正确的方式来实如今遍历的过程中移除元素，而不会出现 ConcurrentModificationException 异常的演示样例代码。

什么是ArrayMap?它和HashMap有什么差别?

ArrayMap是Android SDK中提供的,非Android开发人员能够略过.
ArrayMap是用两个数组来模拟map,更少的内存占用空间,更高的效率.
详细參考这篇文章:ArrayMap VS HashMap

HashMap的实现原理

1 HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。

此实现提供全部可选的映射操作。并同意使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
2 HashMap的数据结构： 在java编程语言中。最主要的结构就是两种，一个是数组，另外一个是模拟指针（引用），全部的数据结构都能够用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

当我们往Hashmap中put元素时,首先依据key的hashcode又一次计算hash值,根绝hash值得到这个元素在数组中的位置(下标),假设该数组在该位置上已经存放了其它元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.假设数组中该位置没有元素,就直接将该元素放到数组的该位置上.

须要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个之后,该链表会转为红黑树来提高查询效率,从原来的O(n)到O(logn)

你了解Fail-Fast机制吗

Fail-Fast即我们常说的快速失败,很多其它内容參看fail-fast机制

Fail-fast和Fail-safe有什么差别

Iterator的fail-fast属性与当前的集合共同起作用，因此它不会受到集合中不论什么改动的影响。Java.util包中的全部集合类都被设计为fail->fast的，而java.util.concurrent中的集合类都为fail-safe的。当检測到正在遍历的集合的结构被改变时。Fail-fast迭代器抛出ConcurrentModificationException，而fail-safe迭代器从不抛出ConcurrentModificationException。

---

关于日期

SimpleDateFormat是线程安全的吗?

非常不幸。DateFormat 的全部实现。包括 SimpleDateFormat 都不是线程安全的，因此你不应该在多线程序中使用，除非是在对外线程安全的环境中使用。如 将 SimpleDateFormat 限制在 ThreadLocal 中。假设你不这么做，在解析或者格式化日期的时候，可能会获取到一个不对的结果。因此，从日期、时间处理的全部实践来说，我强力推荐 joda-time 库。

怎样格式化日期?

Java 中，能够使用 SimpleDateFormat 类或者 joda-time 库来格式日期。DateFormat 类同意你使用多种流行的格式来格式化日期。

參见答案中的演示样例代码，代码中演示了将日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。

---

关于异常

简单描写叙述java异常体系

相比没有人不了解异常体系,关于异常体系的很多其它信息能够见:白话异常机制

什么是异常链

详情直接參见白话异常机制,不做解释了.

throw和throws的差别

throw用于主动抛出java.lang.Throwable 类的一个实例化对象，意思是说你能够通过关键字 throw 抛出一个 Error 或者 一个Exception，如：throw new IllegalArgumentException(“size must be multiple of 2″),
而throws 的作用是作为方法声明和签名的一部分，方法被抛出相应的异常以便调用者能处理。

Java 中。不论什么未处理的受检查异常强制在 throws 子句中声明。

---

关于序列化

Java 中，Serializable 与 Externalizable 的差别

Serializable 接口是一个序列化 Java 类的接口。以便于它们能够在网络上传输或者能够将它们的状态保存在磁盘上，是 JVM 内嵌的默认序列化方式，成本高、脆弱而且不安全。

Externalizable 同意你控制整个序列化过程，指定特定的二进制格式，添加安全机制。

---

关于JVM

JVM特性

平台无关性.
Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。

一般的高级语言假设要在不同的平台上运行，至少须要编译成不同的目标代码。

而引入Java语言虚拟机后，Java语言在不同平台上运行时不须要又一次编译。Java语言使用模式Java虚拟机屏蔽了与详细平台相关的信息，使得Java语言编译程序仅仅需生成在Java虚拟机上运行的目标代码（字节码），就能够在多种平台上不加改动地运行。Java虚拟机在运行字节码时，把字节码解释成详细平台上的机器指令运行。

简单解释一下类载入器

有关类载入器通常会问你四种类载入器的应用场景以及双亲委派模型,很多其它的内容參看深入理解JVM载入器

简述堆和栈的差别

VM 中堆和栈属于不同的内存区域。使用目的也不同。

栈经常使用于保存方法帧和局部变量，而对象总是在堆上分配。栈通常都比堆小，也不会在多个线程之间共享，而堆被整个 JVM 的全部线程共享。

简述JVM内存分配

1. 基本数据类型比变量和对象的引用都是在栈分配的
2. 堆内存用来存放由new创建的对象和数组
3. 类变量（static修饰的变量）。程序在一载入的时候就在堆中为类变量分配内存，堆中的内存地址存放在栈中
4. 实例变量：当你使用java关键字new的时候。系统在堆中开辟并不一定是连续的空间分配给变量，是依据零散的堆内存地址，通过哈希算法换算为一长串数字以表征这个变量在堆中的”物理位置”,实例变量的生命周期–当实例变量的引用丢失后，将被GC（垃圾回收器）列入可回收“名单”中，但并非马上就释放堆中内存
5. 局部变量: 由声明在某方法。或某代码段里（比方for循环），运行到它的时候在栈中开辟内存，当局部变量一但脱离作用域。内存马上释放

---

其它

java其中採用的是大端还是小端?

XML解析的几种方式和特点

DOM,SAX,PULL三种解析方式:

• DOM:消耗内存：先把xml文档都读到内存中，然后再用DOM API来訪问树形结构，并获取数据。

  这个写起来非常easy，可是非常消耗内存。要是数据过大，手机不够牛逼，可能手机直接死机

• SAX:解析效率高，占用内存少，基于事件驱动的：更加简单地说就是对文档进行顺序扫描，当扫描到文档(document)開始与结束、元素(element)開始与结束、文档(document)结束等地方时通知事件处理函数，由事件处理函数做相应动作。然后继续同样的扫描，直至文档结束。

• PULL:与 SAX 相似，也是基于事件驱动。我们能够调用它的next（）方法，来获取下一个解析事件（就是開始文档，结束文档，開始标签。结束标签），当处于某个元素时能够调用XmlPullParser的getAttributte()方法来获取属性的值。也可调用它的nextText()获取本节点的值。

JDK 1.7特性

然 JDK 1.7 不像 JDK 5 和 8 一样的大版本号，可是，还是有非常多新的特性。如 try-with-resource 语句，这样你在使用流或者资源的时候，就不须要手动关闭，Java 会自己主动关闭。Fork-Join 池某种程度上实现 Java 版的 Map-reduce。同意 Switch 中有 String 变量和文本。菱形操作符(<>)用于类型推断，不再须要在变量声明的右边申明泛型。因此能够写出可读写更强、更简洁的代码

JDK 1.8特性

java 8 在 Java 历史上是一个开创新的版本号，下面 JDK 8 中 5 个主要的特性：
Lambda 表达式。同意像对象一样传递匿名函数
Stream API，充分利用现代多核 CPU，能够写出非常简洁的代码
Date 与 Time API。终于。有一个稳定、简单的日期和时间库可供你使用
扩展方法，如今，接口中能够有静态、默认方法。
反复注解，如今你能够将同样的注解在同一类型上使用多次。

Maven和ANT有什么差别?

尽管两者都是构建工具。都用于创建 Java 应用。可是 Maven 做的事情很多其它，在基于“约定优于配置”的概念下。提供标准的Java 项目结构，同一时候能为应用自己主动管理依赖（应用中所依赖的 JAR 文件.

JDBC最佳实践

• 优先使用批量操作来插入和更新数据
• 使用PreparedStatement来避免SQL漏洞
• 使用数据连接池
• 通过列名来获取结果集

IO操作最佳实践

1. 使用有缓冲的IO类,不要单独读取字节或字符
2. 使用NIO和NIO 2或者AIO,而非BIO
3. 在finally中关闭流
4. 使用内存映射文件获取更快的IO