java面试题搞一波

457 05-27

1、请你说一下Java中的IO流？以及他们的分类和作用？

IO 流的分类：

按照数据流的方向的不同，可以分为输入流和输出流；
按照处理数据单位的不同，可以划分为字节流和字符流；
按照流的实现功能的不同，可以划分为节点流和处理流；

Java Io流共涉及40多个类，这40多个类都是从如下4个抽象类基类中派生出来的：

InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

按操作方式分类结构图：

这里我们重点提一下转换流和缓冲流：

转换流：实现字节流和字符流之间的转换。

InputStreamReader：将一个字节输入流转换为字符输入流。
OutputStreamWriter：将一个字符输出流转换为字节流。

缓冲流：增加缓冲功能，避免频繁读写硬盘。

如：BufferedInputStrean 、BufferedOutputStream、 BufferedReader、 BufferedWriter

我们来看一个转换流和缓冲流配合使用的案例：

// 获取键盘录入对象:
InputStream in = System.in;
// 将字节流对象转成字符流对象，使用转换流: InputStreamReader
InputStreamReader isr = new InputStreamReader(in);	
// 为了提高效率，将字符串进行缓冲区技术高效操作,使用：BufferedReader
BufferedReader bufr = new BufferedReader(isr);		

// 最常见写法：
// BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));	
// --------------------------------------------------------------------------------------

// 同理输出流转换亦是如此：
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bufw = new BufferedWriter(osw);

// 最常见写法：
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

流使用结束后记得关闭流，关闭的顺序遵循如下几个规则：

① 先开后关，先开的输入流，再开的输出流，通过读取输入流写入输出流中，那么应该先关输出流，再关输入流，但是一般关闭输入输出流操作都是在读写完成后的finally中执行的，所以即使先关输入流，再关输出流也不会任何问题，因为读写操作没有进行了。
② 先关外层，再关内层。如BufferedInputStream包装了一个FileInputStream，那么先关BufferedInputStream，再关FileInputStream。但要注意的是由于一般处理流持有节点流引用，处理流都会在自己的close方法中去关闭节点流，因此我们只要关闭外层的处理流即可，如果多此一举的关闭节点流反而会报错。如BufferedInputStream包装了FileInputStream，我们只要关闭BufferedInputStream即可。
只关处理流，不关节点流，原因见上述第二条。

2、请你说一说BIO、NIO、AIO 有什么区别?

在对比这三者的区别之前，先了解一下什么是同步/异步、阻塞/非阻塞：

同步，一个任务的完成之前不能做其他操作，必须等待（相当于在打电话）。
异步，一个任务的完成之前，可以进行其他操作（相当于在聊QQ）。
阻塞，是相对于CPU来说的，挂起当前线程，不能做其他操作只能等待。
非阻塞，无须挂起当前线程，也可以去执行其他操作。

BIO、NIO、AIO的区别：

BIO：同步阻塞，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。每当有一个客户端向服务器发起请求时，服务器都要启动一个线程，如图所示：

无论客户端是否响应，线程都必须一直等待。
NIO：同步非阻塞，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。服务器用一个线程来处理多个请求，客户端发送的请求会注册到多路复用器(selector选择器)上，有I/O请求的客户端分配线程处理，如图：
AIO：异步非阻塞，是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。客户端发送的请求先交给操作系统处理，OS 处理后再通知线程。

文章参考：Java面试之BIO,NIO和AIO的区别

3、请你说一下Error 和 Exception 区别是什么？

Error 和 Exception 都是 Throwable 的子类，用于表示程序出现了不正常的情况。区别在于：

Error 是程序错误，通常为虚拟机相关错误，如系统崩溃，内存不足，堆栈溢出等，编译器不会对这类错误进行检测，JAVA 应用程序也不应对这类错误进行捕获，一旦这类错误发生，通常应用程序会被终止，仅靠应用程序本身无法恢复；
Exception 是程序异常，是可以在应用程序中进行捕获并处理的，是一种设计或实现问题，也就是说，它表示如果程序运行正常，从不会发生的情况。

4、请问 try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

答案：会执行，在 return 前执行。

代码如下：

public static int getInt() {
    int a = 10;
    try {
        System.out.println(a / 0);
        a = 20;
    } catch (ArithmeticException e) {
        a = 30;
        return a;
    } finally {
        a = 40;
        // 结果直接返回40
        return a; 
    }
}

总结：

不管有没有异常，finally 中的代码都会执行。
当try、catch中有return 时，finally 中的代码依然会继续执行。
如果 return 的数据是引用数据类型，而在 finally 中对该引用数据类型的属性值的改变起作用，try 中的return 语句返回的就是在 finally中改变后的该属性的值。
finally 代码中最好不要包含 return，程序会提前退出，也就是说返回的值不是 try 或 catch 中的值。
finally 是在 return 后面的表达式运算之后执行的，此时并没有返回运算之后的值，而是把值保存起来，不管finally 对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算之前就确定了的。

5、请你说一下：String str = new String(“abc”) 创建了几个字符串对象？

答案：1 个或者 2 个。

Ⅰ 如果字符串常量池中已经有"abc"存在，这种情况只需要新建1个对象，否则就需要新建2个对象。
Ⅱ 当字符串常量池没有 "abc"，此时会创建如下两个对象：
- 一个是字符串字变量 "abc" 所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，此时该实例也是在堆中，字符串常量池只存放引用。
- 另一个是通过 new String() 创建并初始化的，内容与"abc"相同的实例，也是在堆中。

总结： new String("xxx"); 如果字符串常量池intern中没有对应的xxx 那么就需要在字符串常量池新建，然后再在堆上new 一个对象。

6、请问 String str = “xyz” 和 String str = new String(“xyz”) 区别？

两个语句都会先去字符串常量池中检查是否已经存在 “xyz”，如果有则直接使用，如果没有则会在常量池中创建 “xyz” 对象。
另外，String s = new String(“xyz”) 还会通过 new String() 在堆里创建一个内容与 “xyz” 相同的对象实例。所以前者其实理解为被后者的所包含。

7、Java中的128陷阱有了解过吗？

先来看一个例子：

public static void main(String[] args) {
        Integer a=127,b=127;
        Integer c=128,d=128;
        System.out.println(a==b);// true
        System.out.println(c==d);// false
}

为什么出现这种情况呢？

我们都知道Integer 是基本类型int 的包装类型。
在Java设计之初，设计者认为，开发者可能经常用到的数字范围都在 100 以内，而每次使用这些数字的包装类型都要开辟新空间的话，可能会占用大量的资源。
因此他们规定在-128~127之间的Integer类型的变量，直接指向常量池中的缓存地址，不再使用new去开辟出新的空间。

执行 Integer c = 128，相当于执行：Integer c = Integer.valueOf(128)，基本类型自动转换为包装类的过程称为，自动装箱（autoboxing）。
这也是出现上述代码两次比较结果不同的原因！下面我们看下valueOf() 源码去体会下：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在Integer 中引入了IntegerCache 来缓存一定范围的值，默认情况下范围为：-128~127。

因此：上述代码中的 127 命中了 IntegerCache，所以 a 和 b 是相同对象，而 128 则没有命中，所以 c 和 d 是不同对象。

那么，如果想要正确比较的话 c 与 d 的话，就需要拆箱比较，即在变量后加intValue()方法：

public static void main(String[] args) {
        Integer a=127,b=127;
        Integer c=128,d=128;
        System.out.println(a==b);// true
        System.out.println(c.intValue()==d.intValue());// true
}

可以直接记住下面的表格，道理都是一样的：

在这里插入图片描述

8、Java中的深拷贝和浅拷贝有了解过吗？

深拷贝和浅拷贝区别是什么？

数据分为基本数据类型和引用数据类型。基本数据类型：数据直接存储在栈中；引用数据类型：存储在栈中的是对象的引用地址，真实的对象数据存放在堆内存里。
浅拷贝：对于基础数据类型：直接复制数据值；对于引用数据类型：只是复制了对象的引用地址，新旧对象指向同一个内存地址，修改其中一个对象的值，另一个对象的值随之改变。
深拷贝：对于基础数据类型：直接复制数据值；对于引用数据类型：开辟新的内存空间，在新的内存空间里复制一个一模一样的对象，新老对象不共享内存，修改其中一个对象的值，不会影响另一个对象。
深拷贝相比于浅拷贝速度较慢并且花销较大。

深拷贝/浅拷贝分析案例

浅拷贝实现 Cloneable，深拷贝是通过实现 Serializable 读取二进制流

深拷贝实现：

首先Person 对象实现 Serializable 接口，然后自定义深拷贝方法 deepClone()：

/**
 * 深拷贝
 * 
 * 注意：要实现序列化接口
 * @return
 */
public Person deepClone() {
    try {
        // 输出 (序列化)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(this);
        // 输入 (反序列化)
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        Person person = (Person) ois.readObject();
        return person;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

接下来验证一下深拷贝是否成功：

@Test
public void testPropotype() throws CloneNotSupportedException {
    Person person1 = new Person();
    person1.setAge(22);
    person1.setName("csp");
    // 初始化list 并为其加入数据
    person1.setList(new ArrayList<>());
    person1.getList().add("aaa");
    person1.getList().add("bbb");
    System.out.println("person1:"+person1);
    //-----------------------------浅拷贝-------------------------------
    //Person person2 = person1.clone();
    //-----------------------------深拷贝-------------------------------
    Person person2 = person1.deepClone();
    person2.setName("hzw");
    // 给peron2 中的list添加一条数据
    person2.getList().add("ccc");
    System.out.println("person2"+person2);
    System.out.println("person1:"+person1);
    boolean flag1 = person1 == person2;
    System.out.println("person1 和 person2 的 引用地址是否相同: " +  flag1);
    boolean flag2 = person1.getList() == person2.getList();
    System.out.println("person1 和 person2 的 list 引用地址是否相同: " +  flag2);
}

输出结果：

空参构造函数调用...
person1:Person{name='csp', age=22, list=[aaa, bbb]}
person2Person{name='hzw', age=22, list=[aaa, bbb, ccc]}
person1:Person{name='csp', age=22, list=[aaa, bbb]}
person1 和 person2 的 引用地址是否相同: false
person1 和 person2 的 list 引用地址是否相同: false

由结果可得出：深拷贝 person2 所得到的 list 内存地址和原来person1 中的内存地址是不同的，深拷贝成功！

9、Java中子父类继承情况下构造函数/代码块/静态代码块执行顺序你知道吗？

实例来源：《Java编程思想》，博客链接：Java编程思想1-15章笔记

案例代码：

class A{
    public A()
    {
        System.out.println("1.父类A的构造方法");
    }
    {
        System.out.println("2.父类A的构造代码块");
    }
    static{
        System.out.println("3.父类A的静态代码块");
    }
}
public class B extends A{
    public B()
    {
        System.out.println("4.子类B的构造方法");
    }
    {
        System.out.println("5.子类B的构造代码块");
    }
    static{
        System.out.println("6.子类B的静态代码块");
    }
    //测试
    public static void main(String[] args)
    {
        System.out.println("7.start......");
        new B();
        System.out.println("8.end.....");
    }
}

输出结果：

>>> 3.父类A的静态代码块
>>> 6.子类B的静态代码块
>>> 7.start......
>>> 2.父类A的构造代码块
>>> 1.父类A的构造方法
>>> 5.子类B的构造代码块
>>> 4.子类B的构造方法
>>> 8.end.....

主类B中的静态块优先于主方法执行，所以6应该在7前面执行，且B类继承于A类，所以先执行A类的静态块3，所以进入主方法前的执行顺序为：3 6
进入主方法后执行7，new B()之后应先执行A的构造方法然后执行B的构造方法，但由于A类和B类均有构造代码块块，构造代码块又优先于构造方法执行即 2 1（A的构造家族） 5 4（B的构造家族），有多少个对象，构造家族就执行几次，题目中有两个对象所以执行顺序为：3 6 7 2 1 5 4 2 1 5 4 8

这里有个更具体的案例：一道有意思的“初始化”面试题

10、Java中静态变量/成员变量、静态内部类/成员内部类的区别你知道吗？

静态内部类和内部类的关系

只有内部类才能被声明为静态类，即静态内部类;
只能在内部类中定义静态类;
静态内部类与外层类绑定，即使没有创建外层类的对象，它一样存在;
静态类的方法可以是静态的方法也可以是非静态的方法，静态的方法可以在外层通过静态类调用，而非静态的方法必须要创建类的对象之后才能调用;
静态内部类只能引用外部类的static成员变量（也就是类变量）
如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态的；

总结：

是否能拥有静态成员：静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)
访问外部类的成员是否有限制：静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的所有成员(方法，属性)
静态内部类和非静态内部类在创建时有区别：

// 假设类A有静态内部类B和非静态内部类C，创建B和C的区别为：
A a=new A();
A.B b=new A.B();
A.C c=a.new C();

静态变量/成员变量

成员变量存在于堆内存中。
静态变量存在于方法区中。
成员变量与对象共存亡，随着对象创建而存在，随着对象被回收而释放。
静态变量与类共存亡，随着类的加载而存在，随着类的消失而消失。
成员变量所属于对象，所以也称为实例变量。
静态变量所属于类，所以也称为类变量。
成员变量只能被对象所调用。
静态变量可以被对象调用，也可以被类名调用。