Java面试题全集（6）

白玉 IT哈哈

51、类ExampleA继承Exception，类ExampleB继承ExampleA。

有如下代码片断：

try {    throw new ExampleB("b")} catch（ExampleA e）{    System.out.println("ExampleA");} catch（Exception e）{    System.out.println("Exception");}

请问执行此段代码的输出是什么？

答：输出：ExampleA。（根据里氏代换原则[能使用父类型的地方一定能使用子类型]，抓取ExampleA类型异常的catch块能够抓住try块中抛出的ExampleB类型的异常）

面试题 - 说出下面代码的运行结果。（此题的出处是《Java编程思想》一书）

class Annoyance extends Exception {}class Sneeze extends Annoyance {}class Human {    public static void main(String[] args)         throws Exception {        try {            try {                throw new Sneeze();            }             catch ( Annoyance a ) {                System.out.println("Caught Annoyance");                throw a;            }        }         catch ( Sneeze s ) {            System.out.println("Caught Sneeze");            return ;        }        finally {            System.out.println("Hello World!");        }    }}

52、List、Set、Map是否继承自Collection接口？

答：List、Set 是，Map 不是。Map是键值对映射容器，与List和Set有明显的区别，而Set存储的零散的元素且不允许有重复元素（数学中的集合也是如此），List是线性结构的容器，适用于按数值索引访问元素的情形。

53、阐述ArrayList、Vector、LinkedList的存储性能和特性。

答：ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector中的方法由于添加了synchronized修饰，因此Vector是线程安全的容器，但性能上较ArrayList差，因此已经是Java中的遗留容器。LinkedList使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。Vector属于遗留容器（Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器），已经不推荐使用，但是由于ArrayList和LinkedListed都是非线程安全的，如果遇到多个线程操作同一个容器的场景，则可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用（这是对装潢模式的应用，将已有对象传入另一个类的构造器中创建新的对象来增强实现）。

补充：遗留容器中的Properties类和Stack类在设计上有严重的问题，Properties是一个键和值都是字符串的特殊的键值对映射，在设计上应该是关联一个Hashtable并将其两个泛型参数设置为String类型，但是Java API中的Properties直接继承了Hashtable，这很明显是对继承的滥用。这里复用代码的方式应该是Has-A关系而不是Is-A关系，另一方面容器都属于工具类，继承工具类本身就是一个错误的做法，使用工具类最好的方式是Has-A关系（关联）或Use-A关系（依赖）。同理，Stack类继承Vector也是不正确的。Sun公司的工程师们也会犯这种低级错误，让人唏嘘不已。

54、Collection和Collections的区别？

答：Collection是一个接口，它是Set、List等容器的父接口；Collections是个一个工具类，提供了一系列的静态方法来辅助容器操作，这些方法包括对容器的搜索、排序、线程安全化等等。

55、List、Map、Set三个接口存取元素时，各有什么特点？

答：List以特定索引来存取元素，可以有重复元素。Set不能存放重复元素（用对象的equals()方法来区分元素是否重复）。Map保存键值对（key-value pair）映射，映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树的两种实现版本，基于哈希存储的版本理论存取时间复杂度为O(1)，而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。

56、TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？

答：TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections工具类的sort方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较；第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用（Java中对函数式编程的支持）。
例子1：

public class Student implements Comparable<Student> {    private String name;        // 姓名    private int age;            // 年龄    public Student(String name, int age) {        this.name = name;        this.age = age;    }    @Override    public String toString() {        return "Student [name=" + name + ", age=" + age + "]";    }    @Override    public int compareTo(Student o) {        return this.age - o.age; // 比较年龄(年龄的升序)    }}import java.util.Set;import java.util.TreeSet;class Test01 {    public static void main(String[] args) {   // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)        Set<Student> set = new TreeSet<>();          set.add(new Student("Hao LUO", 33));        set.add(new Student("XJ WANG", 32));        set.add(new Student("Bruce LEE", 60));        set.add(new Student("Bob YANG", 22));        for(Student stu : set) {            System.out.println(stu);        }//      输出结果: //      Student [name=Bob YANG, age=22]//      Student [name=XJ WANG, age=32]//      Student [name=Hao LUO, age=33]//      Student [name=Bruce LEE, age=60]    }}

例子2：

public class Student {    private String name;    // 姓名    private int age;        // 年龄    public Student(String name, int age) {        this.name = name;        this.age = age;    }    /**     * 获取学生姓名     */    public String getName() {        return name;    }    /**     * 获取学生年龄     */    public int getAge() {        return age;    }    @Override    public String toString() {        return "Student [name=" + name + ", age=" + age + "]";    }}import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;class Test02 {    public static void main(String[] args) {        List<Student> list = new ArrayList<>();     // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)        list.add(new Student("Hao LUO", 33));        list.add(new Student("XJ WANG", 32));        list.add(new Student("Bruce LEE", 60));        list.add(new Student("Bob YANG", 22));        // 通过sort方法的第二个参数传入一个Comparator接口对象        // 相当于是传入一个比较对象大小的算法到sort方法中        // 由于Java中没有函数指针、仿函数、委托这样的概念        // 因此要将一个算法传入一个方法中唯一的选择就是通过接口回调        Collections.sort(list, new Comparator<Student> () {            @Override            public int compare(Student o1, Student o2) {                return o1.getName().compareTo(o2.getName());    // 比较学生姓名            }        });        for(Student stu : list) {            System.out.println(stu);        }//      输出结果: //      Student [name=Bob YANG, age=22]//      Student [name=Bruce LEE, age=60]//      Student [name=Hao LUO, age=33]//      Student [name=XJ WANG, age=32]    }}

57、Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别?

答：sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态，请参考第66题中的线程状态转换图）。wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。

补充：可能不少人对什么是进程，什么是线程还比较模糊，对于为什么需要多线程编程也不是特别理解。简单的说：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位；线程是进程的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位。线程的划分尺度小于进程，这使得多线程程序的并发性高；进程在执行时通常拥有独立的内存单元，而线程之间可以共享内存。使用多线程的编程通常能够带来更好的性能和用户体验，但是多线程的程序对于其他程序是不友好的，因为它可能占用了更多的CPU资源。当然，也不是线程越多，程序的性能就越好，因为线程之间的调度和切换也会浪费CPU时间。时下很时髦的Node.js就采用了单线程异步I/O的工作模式。

58、线程的sleep()方法和yield()方法有什么区别？

答：
① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
④ sleep()方法比yield()方法（跟操作系统CPU调度相关）具有更好的可移植性。

59、当一个线程进入一个对象的synchronized方法A之后，其它线程是否可进入此对象的synchronized方法B？

答：不能。其它线程只能访问该对象的非同步方法，同步方法则不能进入。因为非静态方法上的synchronized修饰符要求执行方法时要获得对象的锁，如果已经进入A方法说明对象锁已经被取走，那么试图进入B方法的线程就只能在等锁池（注意不是等待池哦）中等待对象的锁。

60、请说出与线程同步以及线程调度相关的方法。

答：

wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常；
notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；
notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

提示：关于Java多线程和并发编程的问题，建议大家看我的另一篇文章《关于Java并发编程的总结和思考》。
补充：Java 5通过Lock接口提供了显式的锁机制（explicit lock），增强了灵活性以及对线程的协调。Lock接口中定义了加锁（lock()）和解锁（unlock()）的方法，同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象；此外，Java 5还提供了信号量机制（semaphore），信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前，线程必须得到信号量的许可（调用Semaphore对象的acquire()方法）；在完成对资源的访问后，线程必须向信号量归还许可（调用Semaphore对象的release()方法）。

下面的例子演示了100个线程同时向一个银行账户中存入1元钱，在没有使用同步机制和使用同步机制情况下的执行情况。
银行账户类：

/** * 银行账户 * @author 骆昊 * */public class Account {    private double balance;     // 账户余额    /**     * 存款     * @param money 存入金额     */    public void deposit(double money) {        double newBalance = balance + money;        try {            Thread.sleep(10);   // 模拟此业务需要一段处理时间        }        catch(InterruptedException ex) {            ex.printStackTrace();        }        balance = newBalance;    }    /**     * 获得账户余额     */    public double getBalance() {        return balance;    }}

存钱线程类：

/** * 存钱线程 * @author 骆昊 * */public class AddMoneyThread implements Runnable {    private Account account;    // 存入账户    private double money;       // 存入金额    public AddMoneyThread(Account account, double money) {        this.account = account;        this.money = money;    }    @Override    public void run() {        account.deposit(money);    }}

测试类：

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class Test01 {    public static void main(String[] args) {        Account account = new Account();        ExecutorService service = Executors.newFixedThreadPool(100);        for(int i = 1; i <= 100; i++) {            service.execute(new AddMoneyThread(account, 1));        }        service.shutdown();        while(!service.isTerminated()) {}        System.out.println("账户余额: " + account.getBalance());    }}

在没有同步的情况下，执行结果通常是显示账户余额在10元以下，出现这种状况的原因是，当一个线程A试图存入1元的时候，另外一个线程B也能够进入存款的方法中，线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额，因此也是在原来的余额0上面做了加1元的操作，同理线程C也会做类似的事情，所以最后100个线程执行结束时，本来期望账户余额为100元，但实际得到的通常在10元以下（很可能是1元哦）。解决这个问题的办法就是同步，当一个线程对银行账户存钱时，需要将此账户锁定，待其操作完成后才允许其他的线程进行操作，代码有如下几种调整方案：

在银行账户的存款（deposit）方法上同步（synchronized）关键字

/** * 银行账户 * @author 骆昊 * */public class Account {    private double balance;     // 账户余额    /**     * 存款     * @param money 存入金额     */    public synchronized void deposit(double money) {        double newBalance = balance + money;        try {            Thread.sleep(10);   // 模拟此业务需要一段处理时间        }        catch(InterruptedException ex) {            ex.printStackTrace();        }        balance = newBalance;    }    /**     * 获得账户余额     */    public double getBalance() {        return balance;    }}

在线程调用存款方法时对银行账户进行同步

/** * 存钱线程 * @author 骆昊 * */public class AddMoneyThread implements Runnable {    private Account account;    // 存入账户    private double money;       // 存入金额    public AddMoneyThread(Account account, double money) {        this.account = account;        this.money = money;    }    @Override    public void run() {        synchronized (account) {            account.deposit(money);         }    }}

通过Java 5显示的锁机制，为每个银行账户创建一个锁对象，在存款操作进行加锁和解锁的操作

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * 银行账户 * * @author 骆昊 * */public class Account {    private Lock accountLock = new ReentrantLock();    private double balance; // 账户余额    /**     * 存款     *     * @param money     *            存入金额     */    public void deposit(double money) {        accountLock.lock();        try {            double newBalance = balance + money;            try {                Thread.sleep(10); // 模拟此业务需要一段处理时间            }            catch (InterruptedException ex) {                ex.printStackTrace();            }            balance = newBalance;        }        finally {            accountLock.unlock();        }    }    /**     * 获得账户余额     */    public double getBalance() {        return balance;    }}

按照上述三种方式对代码进行修改后，重写执行测试代码Test01，将看到最终的账户余额为100元。当然也可以使用Semaphore或CountdownLatch来实现同步。

Java面试题全集（6）