花了近十年的时间，整理出史上最全面Java面试题

1、string 是最基本的数据类型吗？

不是。java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型（reference type）。

2、float f=3.4;是否正确？

不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4f;。

3、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？

对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

4、int和integer有什么区别？

java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是integer，从java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

java 为每个原始类型提供了包装类型：

• 原始类型: boolean，char，byte，short，int，long，float，double
• 包装类型：boolean，character，byte，short，integer，long，float，double

5、&和&&的区别？

&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &&!username.equals(“”)，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生nullpointerexception异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

6、math.round(11.5) 等于多少？math.round(-11.5)等于多少？

math.round(11.5)的返回值是12，math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

7、switch 是否能作用在byte 上，是否能作用在long,float 上，是否能作用在string上？

在java 5以前，switch(expr)中，expr只能是byte、short、char、int。从java 5开始，java中引入了枚举类型，expr也可以是enum类型，从java 7开始，expr还可以是字符串（string），但是长整型（long）,浮点数（float）在目前所有的版本中都是不可以的。

8、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？

不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。

java对于eqauls方法和hashcode方法是这样规定的：

(1)如果两个对象相同（equals方法返回true），那么它们的hashcode值一定要相同；

(2)如果两个对象的hashcode相同，它们并不一定相同。当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在set集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

补充：关于equals和hashcode方法，很多java程序都知道，但很多人也就是仅仅知道而已，在joshua bloch的大作《effective java》（很多软件公司，《effective java》、《java编程思想》以及《重构：改善既有代码质量》是java程序员必看书籍，如果你还没看过，那就赶紧去亚马逊买一本吧）中是这样介绍equals方法的：首先equals方法必须满足自反性（x.equals(x)必须返回true）、对称性（x.equals(y)返回true时，y.equals(x)也必须返回true）、传递性（x.equals(y)和y.equals(z)都返回true时，x.equals(z)也必须返回true）和一致性（当x和y引用的对象信息没有被修改时，多次调用x.equals(y)应该得到同样的返回值），而且对于任何非null值的引用x，x.equals(null)必须返回false。

实现高质量的equals方法的诀窍包括：

1. 使用==操作符检查”参数是否为这个对象的引用”；
2. 使用instanceof操作符检查”参数是否为正确的类型”；
3. 对于类中的关键属性，检查参数传入对象的属性是否与之相匹配；
4. 编写完equals方法后，问自己它是否满足对称性、传递性、一致性；
5. 重写equals时总是要重写hashcode；
6. 不要将equals方法参数中的object对象替换为其他的类型，在重写时不要忘掉@override注解。

当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

是值传递。java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的。c++和c#中可以通过传引用或传输出参数来改变传入的参数的值。

string和stringbuilder、stringbuffer的区别？

java平台提供了两种类型的字符串：string和stringbuffer/stringbuilder，它们可以储存和操作字符串。其中string是只读字符串，也就意味着string引用的字符串内容是不能被改变的。而stringbuffer/stringbuilder类表示的字符串对象可以直接进行修改。stringbuilder是java 5中引入的，它和stringbuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比stringbuffer要高。

9、抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized修饰？

都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如c代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

10、阐述静态变量和实例变量的区别。

静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

补充：在java开发中，上下文类和工具类中通常会有大量的静态成员。

11、object中有哪些公共方法？

• equals()
• clone()
• getclass()
• notify(),notifyall(),wait()
• tostring()

12、是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？

不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并没有被初始化。

13、深拷贝和浅拷贝的区别是什么？

浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

14、如何实现对象克隆？

有两种方式：

1. 实现cloneable接口并重写object类中的clone()方法；
2. 实现serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

代码如下：

import java.io.bytearrayinputstream;
import java.io.bytearrayoutputstream;
import java.io.objectinputstream;
import java.io.objectoutputstream;

public class myutil {

    private myutil() {
        throw new assertionerror();
    }

    public static <t> t clone(t obj) throws exception {
        bytearrayoutputstream bout = new bytearrayoutputstream();
        objectoutputstream oos = new objectoutputstream(bout);
        oos.writeobject(obj);

        bytearrayinputstream bin = new bytearrayinputstream(bout.tobytearray());
        objectinputstream ois = new objectinputstream(bin);
        return (t) ois.readobject();

        // 说明：调用bytearrayinputstream或bytearrayoutputstream对象的close方法没有任何意义
        // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
    }
}

 

下面是测试代码：

import java.io.serializable;

/**
 * 人类
 * @author 骆昊
 *
 */
class person implements serializable {
    private static final long serialversionuid = -9102017020286042305l;

    private string name;    // 姓名
    private int age;        // 年龄
    private car car;        // 座驾

    public person(string name, int age, car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public string getname() {
        return name;
    }

    public void setname(string name) {
        this.name = name;
    }

    public int getage() {
        return age;
    }

    public void setage(int age) {
        this.age = age;
    }

    public car getcar() {
        return car;
    }

    public void setcar(car car) {
        this.car = car;
    }

    @override
    public string tostring() {
        return "person [name=" + name + ", age=" + age + ", car=" + car + "]";
    }

}
/**
 * 小汽车类
 * @author 骆昊
 *
 */
class car implements serializable {
    private static final long serialversionuid = -5713945027627603702l;

    private string brand;       // 品牌
    private int maxspeed;       // 最高时速

    public car(string brand, int maxspeed) {
        this.brand = brand;
        this.maxspeed = maxspeed;
    }

    public string getbrand() {
        return brand;
    }

    public void setbrand(string brand) {
        this.brand = brand;
    }

    public int getmaxspeed() {
        return maxspeed;
    }

    public void setmaxspeed(int maxspeed) {
        this.maxspeed = maxspeed;
    }

    @override
    public string tostring() {
        return "car [brand=" + brand + ", maxspeed=" + maxspeed + "]";
    }

}
class clonetest {

    public static void main(string[] args) {
        try {
            person p1 = new person("hao luo", 33, new car("benz", 300));
            person p2 = myutil.clone(p1);   // 深度克隆
            p2.getcar().setbrand("byd");
            // 修改克隆的person对象p2关联的汽车对象的品牌属性
            // 原来的person对象p1关联的汽车不会受到任何影响
            // 因为在克隆person对象时其关联的汽车对象也被克隆了
            system.out.println(p1);
        } catch (exception e) {
            e.printstacktrace();
        }
    }
}

 

注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。

15、string s = new string(“xyz”);创建了几个字符串对象？

两个对象，一个是静态区的”xyz”，一个是用new创建在堆上的对象。

16、java中==和eqauls()的区别,equals()和`hashcode的区别

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

17、a==b与a.equals(b)有什么区别

如果a 和b 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，string 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。

18、接口是否可继承（extends）接口？抽象类是否可实现（implements）接口？抽象类是否可继承具体类（concrete class）？

接口可以继承接口，而且支持多重继承。抽象类可以实现(implements)接口，抽象类可继承具体类也可以继承抽象类。

19、java 中的final关键字有哪些用法？

(1)修饰类：表示该类不能被继承；

(2)修饰方法：表示方法不能被重写；

(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

20、throw和throws的区别

throw用于主动抛出java.lang.throwable 类的一个实例化对象，意思是说你可以通过关键字 throw 抛出一个 error 或者 一个exception，如：throw new illegalargumentexception(“size must be multiple of 2′)。

throws 的作用是作为方法声明和签名的一部分，方法被抛出相应的异常以便调用者能处理。java 中，任何未处理的受检查异常强制在 throws 子句中声明。

21、error和exception有什么区别？

error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；

exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

22、java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别如何使用？

java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在java中，每个异常都是一个对象，它是throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。

java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。

一般情况下是用try来执行一段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行代码块（finally）来处理； try用来指定一块预防所有异常的程序； catch子句紧跟在try块后面，用来指定你想要捕获的异常的类型； throw语句用来明确地抛出一个异常； throws用来声明一个方法可能抛出的各种异常（当然声明异常时允许无病呻吟）； finally为确保一段代码不管发生什么异常状况都要被执行；

try语句可以嵌套，每当遇到一个try语句，异常的结构就会被放入异常栈中，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，异常栈就会执行出栈操作，直到遇到有处理这种异常的try语句或者最终将异常抛给jvm。

23、运行时异常与受检异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要程序设计得没有问题通常就不会发生。受检异常跟程序运行的上下文环境有关，即使程序设计无误，仍然可能因使用的问题而引发。java编译器要求方法必须声明抛出可能发生的受检异常，但是并不要求必须声明抛出未被捕获的运行时异常。

异常和继承一样，是面向对象程序设计中经常被滥用的东西，在effective java中对异常的使用给出了以下指导原则：

• 不要将异常处理用于正常的控制流（设计良好的api不应该强迫它的调用者为了正常的控制流而使用异常）
• 对可以恢复的情况使用受检异常，对编程错误使用运行时异常
• 避免不必要的使用受检异常（可以通过一些状态检测手段来避免异常的发生）
• 优先使用标准的异常
• 每个方法抛出的异常都要有文档
• 保持异常的原子性
• 不要在catch中忽略掉捕获到的异常

24、列出一些你常见的运行时异常？

• arithmeticexception（算术异常）
• classcastexception （类转换异常）
• illegalargumentexception （非法参数异常）
• indexoutofboundsexception （下标越界异常）
• nullpointerexception （空指针异常）
• securityexception （安全异常）

25、阐述final、finally、finalize的区别

• final：修饰符（关键字）有三种用法：如果一个类被声明为final，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。将变量声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用，不能在子类中被重写。
• finally：通常放在try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要jvm不关闭都能执行，可以将释放外部资源的代码写在finally块中。
• finalize：object类中定义的方法，java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

26、java当中的四种引用

强引用,软引用,弱引用,虚引用.不同的引用类型主要体现在gc上:

强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，jvm也不会回收它，而是抛出 outofmemoryerror 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，jvm在合适的时间就会回收该对象

软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。

弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 jvm 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象

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

更多了解参见深入对象引用： http://blog.csdn.net/dd864140130/article/details/49885811

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

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

利用软引用和弱引用解决oom问题：用一个hashmap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，jvm会自动回收这些缓存图片对象所占用的空间，从而有效地避免了oom的问题.

通过软引用实现java对象的高速缓存:比如我们创建了一person的类，如果每次需要查询一个人的信息,哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这将引起大量person对象的消耗,并且由于这些对象的生命周期相对较短,会引起多次gc影响性能。此时,通过软引用和 hashmap 的结合可以构建高速缓存,提供性能.

28、内部类的作用

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

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

29、simpledateformat是线程安全的吗？

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

30、如何格式化日期？

java 中，可以使用 simpledateformat 类或者 joda-time 库来格式日期。dateformat 类允许你使用多种流行的格式来格式化日期。参见答案中的示例代码，代码中演示了将日期格式化成不同的格式，如 dd-mm-yyyy 或 ddmmyyyy。

31、说出几条 java 中方法重载的最佳实践？

下面有几条可以遵循的方法重载的最佳实践来避免造成自动装箱的混乱。

• 不要重载这样的方法：一个方法接收 int 参数，而另个方法接收 integer 参数。
• 不要重载参数数量一致，而只是参数顺序不同的方法。
• 如果重载的方法参数个数多于 5 个，采用可变参数。

32、说说反射的用途及实现

反射机制是java语言中一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部成员进行操作。

反射机制提供的功能主要有：得到一个对象所属的类；获取一个类的所有成员变量和方法；在运行时创建对象；在运行时调用对象的方法；

33、说说自定义注解的场景及实现

登陆、权限拦截、日志处理，以及各种 java 框架，如 spring，hibernate，junit 提到注解就不能不说反射，java 自定义注解是通过运行时靠反射获取注解。

实际开发中，例如我们要获取某个方法的调用日志，可以通过 aop（动态代理机制）给方法添加切面，通过反射来获取方法包含的注解，如果包含日志注解，就进行日志记录。 反射的实现在 java 应用层面上讲，是通过对 class 对象的操作实现的，class 对象为我们提供了一系列方法对类进行操作。在 jvm 这个角度来说，class 文件是一组以 8 位字节为基础单位的二进制流，各个数据项目按严格的顺序紧凑的排列在 class 文件中，里面包含了类、方法、字段等等相关数据。

 

本人免费整理了java高级资料，涵盖了java、redis、mongodb、mysql、zookeeper、spring cloud、dubbo高并发分布式等教程，一共30g，需要自己领取。
传送门：https://mp.weixin.qq.com/s/jzddfh-7ynudmkjt0irl8q