Java面试题全集（二）

51、类ExampleA继承Exception，类ExampleB继承ExampleA。
有如下代码片断：

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

请问执行此段代码的输出是什么？
答：输出：ExampleA。（根据里氏代换原则[能使用父类型的地方一定能使用子类型]，抓取ExampleA类型异常的catch块能够抓住try块中抛出的ExampleB类型的异常）

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

classAnnoyance extendsException {}classSneeze extendsAnnoyance {} classHuman {     publicstatic void main(String[] args)         throwsException {        try{            try{                thrownew Sneeze();            }            catch( Annoyance a ) {                System.out.println("Caught Annoyance");                throwa;            }        }        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：

publicclass Student implementsComparable<Student> {    privateString name;        // 姓名    privateint age;            // 年龄     publicStudent(String name, intage) {        this.name = name;        this.age = age;    }     @Override    publicString toString() {        return"Student [name=" + name + ", age=" + age + "]";    }     @Override    publicint compareTo(Student o) {        returnthis.age - o.age; // 比较年龄(年龄的升序)    } }

importjava.util.Set;importjava.util.TreeSet; classTest01 {     publicstatic void main(String[] args) {        Set<Student> set = newTreeSet<>();     // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)        set.add(newStudent("Hao LUO",33));        set.add(newStudent("XJ WANG",32));        set.add(newStudent("Bruce LEE",60));        set.add(newStudent("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：

publicclass Student {    privateString name;    // 姓名    privateint age;        // 年龄     publicStudent(String name, intage) {        this.name = name;        this.age = age;    }     /**     * 获取学生姓名     */    publicString getName() {        returnname;    }     /**     * 获取学生年龄     */    publicint getAge() {        returnage;    }     @Override    publicString toString() {        return"Student [name=" + name + ", age=" + age + "]";    } }

importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.List; classTest02 {     publicstatic void main(String[] args) {        List<Student> list = newArrayList<>();     // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)        list.add(newStudent("Hao LUO",33));        list.add(newStudent("XJ WANG",32));        list.add(newStudent("Bruce LEE",60));        list.add(newStudent("Bob YANG",22));         // 通过sort方法的第二个参数传入一个Comparator接口对象        // 相当于是传入一个比较对象大小的算法到sort方法中        // 由于Java中没有函数指针、仿函数、委托这样的概念        // 因此要将一个算法传入一个方法中唯一的选择就是通过接口回调        Collections.sort(list,newComparator<Student> () {             @Override            publicint compare(Student o1, Student o2) {                returno1.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 骆昊 * */publicclass Account {    privatedouble balance;     // 账户余额     /**     * 存款     * @param money 存入金额     */    publicvoid deposit(doublemoney) {        doublenewBalance = balance + money;        try{            Thread.sleep(10);  // 模拟此业务需要一段处理时间        }        catch(InterruptedException ex) {            ex.printStackTrace();        }        balance = newBalance;    }     /**     * 获得账户余额     */    publicdouble getBalance() {        returnbalance;    }}

• 存钱线程类：

/** * 存钱线程 * @author 骆昊 * */publicclass AddMoneyThread implementsRunnable {    privateAccount account;    // 存入账户    privatedouble money;       // 存入金额     publicAddMoneyThread(Account account, doublemoney) {        this.account = account;        this.money = money;    }     @Override    publicvoid run() {        account.deposit(money);    } }

• 测试类：

importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors; publicclass Test01 {     publicstatic void main(String[] args) {        Account account = newAccount();        ExecutorService service = Executors.newFixedThreadPool(100);         for(inti = 1; i <= 100; i++) {            service.execute(newAddMoneyThread(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 骆昊 * */publicclass Account {    privatedouble balance;     // 账户余额     /**     * 存款     * @param money 存入金额     */    publicsynchronized void deposit(doublemoney) {        doublenewBalance = balance + money;        try{            Thread.sleep(10);  // 模拟此业务需要一段处理时间        }        catch(InterruptedException ex) {            ex.printStackTrace();        }        balance = newBalance;    }     /**     * 获得账户余额     */    publicdouble getBalance() {        returnbalance;    }}

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

/** * 存钱线程 * @author 骆昊 * */publicclass AddMoneyThread implementsRunnable {    privateAccount account;    // 存入账户    privatedouble money;       // 存入金额     publicAddMoneyThread(Account account, doublemoney) {        this.account = account;        this.money = money;    }     @Override    publicvoid run() {        synchronized(account) {            account.deposit(money);        }    } }

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

importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock; /** * 银行账户 * * @author 骆昊 * */publicclass Account {    privateLock accountLock = newReentrantLock();    privatedouble balance; // 账户余额     /**     * 存款     *     * @param money     *            存入金额     */    publicvoid deposit(doublemoney) {        accountLock.lock();        try{            doublenewBalance = balance + money;            try{                Thread.sleep(10);// 模拟此业务需要一段处理时间            }            catch(InterruptedException ex) {                ex.printStackTrace();            }            balance = newBalance;        }        finally{            accountLock.unlock();        }    }     /**     * 获得账户余额     */    publicdouble getBalance() {        returnbalance;    }}

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

61、编写多线程程序有几种实现方式？
答：Java 5以前实现多线程有两种实现方法：一种是继承Thread类；另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为，推荐使用后者，因为Java中的继承是单继承，一个类有一个父类，如果继承了Thread类就无法再继承其他类了，显然使用Runnable接口更为灵活。

补充：Java 5以后创建线程还有第三种方式：实现Callable接口，该接口中的call方法可以在线程执行结束时产生一个返回值，代码如下所示：

importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.Callable;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;importjava.util.concurrent.Future; classMyTask implementsCallable<Integer> {    privateint upperBounds;     publicMyTask(intupperBounds) {        this.upperBounds = upperBounds;    }     @Override    publicInteger call() throwsException {        intsum = 0;        for(inti = 1; i <= upperBounds; i++) {            sum += i;        }        returnsum;    } } classTest {     publicstatic void main(String[] args) throwsException {        List<Future<Integer>> list = newArrayList<>();        ExecutorService service = Executors.newFixedThreadPool(10);        for(inti = 0; i < 10; i++) {            list.add(service.submit(newMyTask((int) (Math.random() * 100))));        }         intsum = 0;        for(Future<Integer> future : list) {            // while(!future.isDone()) ;            sum += future.get();        }         System.out.println(sum);    }}

62、synchronized关键字的用法？
答：synchronized关键字可以将对象或者方法标记为同步，以实现对对象和方法的互斥访问，可以用synchronized(对象) { … }定义同步代码块，或者在声明方法时将synchronized作为方法的修饰符。在第60题的例子中已经展示了synchronized关键字的用法。

63、举例说明同步和异步。
答：如果系统中存在临界资源（资源数量少于竞争资源的线程数量的资源），例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就必须进行同步存取（数据库操作中的排他锁就是最好的例子）。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。事实上，所谓的同步就是指阻塞式操作，而异步就是非阻塞式操作。

64、启动一个线程是调用run()还是start()方法？
答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM 调度并执行，这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调（callback）的方法。

65、什么是线程池（thread pool）？
答：在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。
Java 5+中的Executor接口定义一个执行线程的工具。它的子类型即线程池接口是ExecutorService。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，因此在工具类Executors面提供了一些静态工厂方法，生成一些常用的线程池，如下所示：
- newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
- newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
- newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
- newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
- newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

第60题的例子中演示了通过Executors工具类创建线程池并使用线程池执行线程的代码。如果希望在服务器上使用线程池，强烈建议使用newFixedThreadPool方法来创建线程池，这样能获得更好的性能。

66、线程的基本状态以及状态之间的关系？
答：

说明：其中Running表示运行状态，Runnable表示就绪状态（万事俱备，只欠CPU），Blocked表示阻塞状态，阻塞状态又有多种情况，可能是因为调用wait()方法进入等待池，也可能是执行同步方法或同步代码块进入等锁池，或者是调用了sleep()方法或join()方法等待休眠或其他线程结束，或是因为发生了I/O中断。

67、简述synchronized 和java.util.concurrent.locks.Lock的异同？
答：Lock是Java 5以后引入的新的API，和关键字synchronized相比主要相同点：Lock 能完成synchronized所实现的所有功能；主要不同点：Lock有比synchronized更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且最好在finally 块中释放（这是释放外部资源的最好的地方）。

68、Java中如何实现序列化，有什么意义？
答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题（如果不进行序列化可能会存在数据乱序的问题）。
要实现序列化，需要让一个类实现Serializable接口，该接口是一个标识性接口，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出（即保存其状态）；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外，还能够用于对象的深度克隆（可以参考第29题）。

69、Java中有几种类型的流？
答：字节流和字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。关于Java的I/O需要注意的有两点：一是两种对称性（输入和输出的对称性，字节和字符的对称性）；二是两种设计模式（适配器模式和装潢模式）。另外Java中的流不同于C#的是它只有一个维度一个方向。

面试题 - 编程实现文件拷贝。（这个题目在笔试的时候经常出现，下面的代码给出了两种实现方案）

importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;importjava.nio.ByteBuffer;importjava.nio.channels.FileChannel; publicfinal class MyUtil {     privateMyUtil() {        thrownew AssertionError();    }     publicstatic void fileCopy(String source, String target) throwsIOException {        try(InputStream in = newFileInputStream(source)) {            try(OutputStream out = newFileOutputStream(target)) {                byte[] buffer = newbyte[4096];                intbytesToRead;                while((bytesToRead = in.read(buffer)) != -1) {                    out.write(buffer,0, bytesToRead);                }            }        }    }     publicstatic void fileCopyNIO(String source, String target) throwsIOException {        try(FileInputStream in = newFileInputStream(source)) {            try(FileOutputStream out = newFileOutputStream(target)) {                FileChannel inChannel = in.getChannel();                FileChannel outChannel = out.getChannel();                ByteBuffer buffer = ByteBuffer.allocate(4096);                while(inChannel.read(buffer) != -1) {                    buffer.flip();                    outChannel.write(buffer);                    buffer.clear();                }            }        }    }}

注意：上面用到Java 7的TWR，使用TWR后可以不用在finally中释放外部资源 ，从而让代码更加优雅。

70、写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。
答：代码如下：

importjava.io.BufferedReader;importjava.io.FileReader; publicfinal class MyUtil {     // 工具类中的方法都是静态方式访问的因此将构造器私有不允许创建对象(绝对好习惯)    privateMyUtil() {        thrownew AssertionError();    }     /**     * 统计给定文件中给定字符串的出现次数     *     * @param filename  文件名     * @param word 字符串     * @return 字符串在文件中出现的次数     */    publicstatic int countWordInFile(String filename, String word) {        intcounter = 0;        try(FileReader fr = newFileReader(filename)) {            try(BufferedReader br = newBufferedReader(fr)) {                String line = null;                while((line = br.readLine()) != null) {                    intindex = -1;                    while(line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {                        counter++;                        line = line.substring(index + word.length());                    }                }            }        }catch(Exception ex) {            ex.printStackTrace();        }        returncounter;    } }

71、如何用Java代码列出一个目录下所有的文件？
答：
如果只要求列出当前文件夹下的文件，代码如下所示：

importjava.io.File; classTest12 {     publicstatic void main(String[] args) {        File f = newFile("/Users/Hao/Downloads");        for(File temp : f.listFiles()) {            if(temp.isFile()) {                System.out.println(temp.getName());            }        }    }}

如果需要对文件夹继续展开，代码如下所示：

importjava.io.File; classTest12 {     publicstatic void main(String[] args) {        showDirectory(newFile("/Users/Hao/Downloads"));    }     publicstatic void showDirectory(File f) {        _walkDirectory(f,0);    }     privatestatic void _walkDirectory(File f, intlevel) {        if(f.isDirectory()) {            for(File temp : f.listFiles()) {                _walkDirectory(temp, level + 1);            }        }        else{            for(inti = 0; i < level - 1; i++) {                System.out.print("\t");            }            System.out.println(f.getName());        }    }}

在Java 7中可以使用NIO.2的API来做同样的事情，代码如下所示：

classShowFileTest {     publicstatic void main(String[] args) throwsIOException {        Path initPath = Paths.get("/Users/Hao/Downloads");        Files.walkFileTree(initPath,newSimpleFileVisitor<Path>() {             @Override            publicFileVisitResult visitFile(Path file, BasicFileAttributes attrs)                     throwsIOException {                System.out.println(file.getFileName().toString());                returnFileVisitResult.CONTINUE;            }         });    }}

72、用Java的套接字编程实现一个多线程的回显（echo）服务器。
答：

importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.PrintWriter;importjava.net.ServerSocket;importjava.net.Socket; publicclass EchoServer {     privatestatic final int ECHO_SERVER_PORT = 6789;     publicstatic void main(String[] args) {                try(ServerSocket server = newServerSocket(ECHO_SERVER_PORT)) {            System.out.println("服务器已经启动...");            while(true) {                Socket client = server.accept();                newThread(newClientHandler(client)).start();            }        }catch(IOException e) {            e.printStackTrace();        }    }     privatestatic class ClientHandler implementsRunnable {        privateSocket client;         publicClientHandler(Socket client) {            this.client = client;        }         @Override        publicvoid run() {            try(BufferedReader br = newBufferedReader(newInputStreamReader(client.getInputStream()));                    PrintWriter pw = newPrintWriter(client.getOutputStream())) {                String msg = br.readLine();                System.out.println("收到"+ client.getInetAddress() + "发送的: " + msg);                pw.println(msg);                pw.flush();            }catch(Exception ex) {                ex.printStackTrace();            }finally{                try{                    client.close();                }catch(IOException e) {                    e.printStackTrace();                }            }        }    } }

注意：上面的代码使用了Java 7的TWR语法，由于很多外部资源类都间接的实现了AutoCloseable接口（单方法回调接口），因此可以利用TWR语法在try结束的时候通过回调的方式自动调用外部资源类的close()方法，避免书写冗长的finally代码块。此外，上面的代码用一个静态内部类实现线程的功能，使用多线程可以避免一个用户I/O操作所产生的中断影响其他用户对服务器的访问，简单的说就是一个用户的输入操作不会造成其他用户的阻塞。当然，上面的代码使用线程池可以获得更好的性能，因为频繁的创建和销毁线程所造成的开销也是不可忽视的。

下面是一段回显客户端测试代码：

importjava.io.BufferedReader;importjava.io.InputStreamReader;importjava.io.PrintWriter;importjava.net.Socket;importjava.util.Scanner; publicclass EchoClient {     publicstatic void main(String[] args) throwsException {        Socket client = newSocket("localhost",6789);        Scanner sc = newScanner(System.in);        System.out.print("请输入内容: ");        String msg = sc.nextLine();        sc.close();        PrintWriter pw = newPrintWriter(client.getOutputStream());        pw.println(msg);        pw.flush();        BufferedReader br = newBufferedReader(newInputStreamReader(client.getInputStream()));        System.out.println(br.readLine());        client.close();    }}

如果希望用NIO的多路复用套接字实现服务器，代码如下所示。NIO的操作虽然带来了更好的性能，但是有些操作是比较底层的，对于初学者来说还是有些难于理解。

importjava.io.IOException;importjava.net.InetSocketAddress;importjava.nio.ByteBuffer;importjava.nio.CharBuffer;importjava.nio.channels.SelectionKey;importjava.nio.channels.Selector;importjava.nio.channels.ServerSocketChannel;importjava.nio.channels.SocketChannel;importjava.util.Iterator; publicclass EchoServerNIO {     privatestatic final int ECHO_SERVER_PORT = 6789;    privatestatic final int ECHO_SERVER_TIMEOUT = 5000;    privatestatic final int BUFFER_SIZE = 1024;     privatestatic ServerSocketChannel serverChannel = null;    privatestatic Selector selector = null;   // 多路复用选择器    privatestatic ByteBuffer buffer = null;   // 缓冲区     publicstatic void main(String[] args) {        init();        listen();    }     privatestatic void init() {        try{            serverChannel = ServerSocketChannel.open();            buffer = ByteBuffer.allocate(BUFFER_SIZE);            serverChannel.socket().bind(newInetSocketAddress(ECHO_SERVER_PORT));            serverChannel.configureBlocking(false);            selector = Selector.open();            serverChannel.register(selector, SelectionKey.OP_ACCEPT);        }catch(Exception e) {            thrownew RuntimeException(e);        }    }     privatestatic void listen() {        while(true) {            try{                if(selector.select(ECHO_SERVER_TIMEOUT) != 0) {                    Iterator<SelectionKey> it = selector.selectedKeys().iterator();                    while(it.hasNext()) {                        SelectionKey key = it.next();                        it.remove();                        handleKey(key);                    }                }            }catch(Exception e) {                e.printStackTrace();            }        }    }     privatestatic void handleKey(SelectionKey key) throwsIOException {        SocketChannel channel = null;         try{            if(key.isAcceptable()) {                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();                channel = serverChannel.accept();                channel.configureBlocking(false);                channel.register(selector, SelectionKey.OP_READ);            }elseif (key.isReadable()) {                channel = (SocketChannel) key.channel();                buffer.clear();                if(channel.read(buffer) > 0) {                    buffer.flip();                    CharBuffer charBuffer = CharsetHelper.decode(buffer);                    String msg = charBuffer.toString();                    System.out.println("收到"+ channel.getRemoteAddress() + "的消息："+ msg);                    channel.write(CharsetHelper.encode(CharBuffer.wrap(msg)));                }else{                    channel.close();                }            }        }catch(Exception e) {            e.printStackTrace();            if(channel != null) {                channel.close();            }        }    } }

importjava.nio.ByteBuffer;importjava.nio.CharBuffer;importjava.nio.charset.CharacterCodingException;importjava.nio.charset.Charset;importjava.nio.charset.CharsetDecoder;importjava.nio.charset.CharsetEncoder; publicfinal class CharsetHelper {    privatestatic final String UTF_8 = "UTF-8";    privatestatic CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder();    privatestatic CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder();     privateCharsetHelper() {    }     publicstatic ByteBuffer encode(CharBuffer in) throwsCharacterCodingException{        returnencoder.encode(in);    }     publicstatic CharBuffer decode(ByteBuffer in) throwsCharacterCodingException{        returndecoder.decode(in);    }}

73、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？
答：XML文档定义分为DTD和Schema两种形式，二者都是对XML语法的约束，其本质区别在于Schema本身也是一个XML文件，可以被XML解析器解析，而且可以为XML承载的数据定义类型，约束能力较之DTD更强大。对XML的解析主要有DOM（文档对象模型，Document Object Model）、SAX（Simple API for XML）和StAX（Java 6中引入的新的解析XML的方式，Streaming API for XML），其中DOM处理大型文件时其性能下降的非常厉害，这个问题是由DOM树结构占用的内存较多造成的，而且DOM解析方式必须在解析文件之前把整个文档装入内存，适合对XML的随机访问（典型的用空间换取时间的策略）；SAX是事件驱动型的XML解析方式，它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过事件回调代码来处理XML文件，适合对XML的顺序访问；顾名思义，StAX把重点放在流上，实际上StAX与其他解析方式的本质区别就在于应用程序能够把XML作为一个事件流来处理。将XML作为一组事件来处理的想法并不新颖（SAX就是这样做的），但不同之处在于StAX允许应用程序代码把这些事件逐个拉出来，而不用提供在解析器方便时从解析器中接收事件的处理程序。

74、你在项目中哪些地方用到了XML？
答：XML的主要作用有两个方面：数据交换和信息配置。在做数据交换时，XML将数据用标签组装成起来，然后压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再从XML文件中还原相关信息进行处理，XML曾经是异构系统间交换数据的事实标准，但此项功能几乎已经被JSON（JavaScript Object Notation）取而代之。当然，目前很多软件仍然使用XML来存储配置信息，我们在很多项目中通常也会将作为配置信息的硬代码写在XML文件中，Java的很多框架也是这么做的，而且这些框架都选择了dom4j作为处理XML的工具，因为Sun公司的官方API实在不怎么好用。

补充：现在有很多时髦的软件（如Sublime）已经开始将配置文件书写成JSON格式，我们已经强烈的感受到XML的另一项功能也将逐渐被业界抛弃。

75、阐述JDBC操作数据库的步骤。
答：下面的代码以连接本机的Oracle数据库为例，演示JDBC操作数据库的步骤。

• 加载驱动。

Class.forName("oracle.jdbc.driver.OracleDriver");

• 创建连接。

Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl","scott","tiger");

• 创建语句。

PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");ps.setInt(1,1000);ps.setInt(2,3000);

• 执行语句。

ResultSet rs = ps.executeQuery();

• 处理结果。

while(rs.next()) {    System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));}

• 关闭资源。

finally{    if(con != null) {        try{            con.close();        }catch(SQLException e) {            e.printStackTrace();        }    }}

提示：关闭外部资源的顺序应该和打开的顺序相反，也就是说先关闭ResultSet、再关闭Statement、在关闭Connection。上面的代码只关闭了Connection（连接），虽然通常情况下在关闭连接时，连接上创建的语句和打开的游标也会关闭，但不能保证总是如此，因此应该按照刚才说的顺序分别关闭。此外，第一步加载驱动在JDBC 4.0中是可以省略的（自动从类路径中加载驱动），但是我们建议保留。

76、Statement和PreparedStatement有什么区别？哪个性能更好？
答：与Statement相比，①PreparedStatement接口代表预编译的语句，它主要的优势在于可以减少SQL的编译错误并增加SQL的安全性（减少SQL注射攻击的可能性）；②PreparedStatement中的SQL语句是可以带参数的，避免了用字符串连接拼接SQL语句的麻烦和不安全；③当批量处理SQL或频繁执行相同的查询时，PreparedStatement有明显的性能上的优势，由于数据库可以将编译优化后的SQL语句缓存起来，下次执行相同结构的语句时就会很快（不用再次编译和生成执行计划）。

补充：为了提供对存储过程的调用，JDBC API中还提供了CallableStatement接口。存储过程（Stored Procedure）是数据库中一组为了完成特定功能的SQL语句的集合，经编译后存储在数据库中，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。虽然调用存储过程会在网络开销、安全性、性能上获得很多好处，但是存在如果底层数据库发生迁移时就会有很多麻烦，因为每种数据库的存储过程在书写上存在不少的差别。

77、使用JDBC操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能？
答：要提升读取数据的性能，可以指定通过结果集（ResultSet）对象的setFetchSize()方法指定每次抓取的记录数（典型的空间换时间策略）；要提升更新数据的性能可以使用PreparedStatement语句构建批处理，将若干SQL语句置于一个批处理中执行。

78、在进行数据库编程时，连接池有什么作用？
答：由于创建连接和释放连接都有很大的开销（尤其是数据库服务器不在本地时，每次建立连接都需要进行TCP的三次握手，释放连接需要进行TCP四次握手，造成的开销是不可忽视的），为了提升系统访问数据库的性能，可以事先创建若干连接置于连接池中，需要时直接从连接池获取，使用结束时归还连接池而不必关闭连接，从而避免频繁创建和释放连接所造成的开销，这是典型的用空间换取时间的策略（浪费了空间存储连接，但节省了创建和释放连接的时间）。池化技术在Java开发中是很常见的，在使用线程时创建线程池的道理与此相同。基于Java的开源数据库连接池主要有：C3P0、Proxool、DBCP、BoneCP、Druid等。

补充：在计算机系统中时间和空间是不可调和的矛盾，理解这一点对设计满足性能要求的算法是至关重要的。大型网站性能优化的一个关键就是使用缓存，而缓存跟上面讲的连接池道理非常类似，也是使用空间换时间的策略。可以将热点数据置于缓存中，当用户查询这些数据时可以直接从缓存中得到，这无论如何也快过去数据库中查询。当然，缓存的置换策略等也会对系统性能产生重要影响，对于这个问题的讨论已经超出了这里要阐述的范围。

79、什么是DAO模式？
答：DAO（Data Access Object）顾名思义是一个为数据库或其他持久化机制提供了抽象接口的对象，在不暴露底层持久化方案实现细节的前提下提供了各种数据访问操作。在实际的开发中，应该将所有对数据源的访问操作进行抽象化后封装在一个公共API中。用程序设计语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口，在逻辑上该类对应一个特定的数据存储。DAO模式实际上包含了两个模式，一是Data Accessor（数据访问器），二是Data Object（数据对象），前者要解决如何访问数据的问题，而后者要解决的是如何用对象封装数据。