Java2019大总结

ゝ一世哀愁。 2022-05-30 00:40 128阅读 0赞

## 2018java面试题总结 ##

### 基础篇 ###

*  **强引用，软引用，弱引用，虚引用。不同的引用类型主要体现在GC上:**

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

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

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

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

### Web篇 ###

*  **重定向和转发的区别：**  
    转发在服务器端完成的；重定向是在客户端完成的  
    转发的速度快；重定向速度慢  
    转发的是同一次请求；重定向是两次不同请求  
    转发不会执行转发后的代码；重定向会执行重定向之后的代码  
    转发地址栏没有变化；重定向地址栏有变化  
    转发必须是在同一台服务器下完成；重定向可以在不同的服务器下完成
 *  **jsp和servlet的区别和联系：**  
    1.jsp经编译后就变成了Servlet.  
    (JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)  
    2.jsp更擅长表现于页面显示,servlet更擅长于逻辑控制.  
    3.Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到.  
    Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。  
    而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。

联系：  
JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。  
Servlet和JSP最主要的不同点在于：  
Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。  
而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。  
JSP侧重于视图，Servlet主要用于控制逻辑  
Servlet更多的是类似于一个Controller，用来做控制。

### 多线程篇 ###

1.  什么是线程？  
    　　线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。欲了解更多详细信息请点击这里。
2.  线程和进程有什么区别？  
    定义方面：进程是程序在某个数据集合上的一次运行活动；线程是进程中的一个执行路径。（进程可以创建多个线程）  
    角色方面：在支持线程机制的系统中，进程是系统资源分配的单位，线程是CPU调度的单位。  
    资源共享方面：进程之间不能共享资源，而线程共享所在进程的地址空间和其它资源。同时线程还有自己的栈和栈指针，程序计数器等寄存器。  
    独立性方面：进程有自己独立的地址空间，而线程没有，线程必须依赖于进程而存在。  
    开销方面。进程切换的开销较大。线程相对较小。（前面也提到过，引入线程也出于了开销的考虑。）
3.  如何在Java中实现线程？  
    　　在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。更多详细信息请点击这里.
4.  用Runnable还是Thread？  
    　　这个问题是上题的后续，大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程，问题是，那个方法更好呢？什么情况下使用它？这个问题很容易回答，如果你知道Java不支持类的多重继承，但允许你调用多个接口。所以如果你要继承其他类，当然是调用Runnable接口好了。更多详细信息请点击这里。
5.  Thread 类中的start() 和 run() 方法有什么区别？  
    　　这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。更多讨论请点击这里
6.  Java中Runnable和Callable有什么不同？  
    　　Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。我的博客有更详细的说明。
7.  Java中CyclicBarrier 和 CountDownLatch有什么不同？  
    　　CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是，CountdownLatch 不能重新使用。点此查看更多信息和示例代码。
8.  Java内存模型是什么？  
    　　Java内存模型规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为。它在多线程的情况下尤其重要。Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰。比如，先行发生关系确保了：

线程内的代码能够按先后顺序执行，这被称为程序次序规则。  
对于同一个锁，一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前，也叫做管程锁定规则。  
前一个对volatile的写操作在后一个volatile的读操作之前，也叫volatile变量规则。  
一个线程内的任何操作必需在这个线程的start()调用之后，也叫作线程启动规则。  
一个线程的所有操作都会在线程终止之前，线程终止规则。  
一个对象的终结操作必需在这个对象构造完成之后，也叫对象终结规则。  
可传递性  
　　我强烈建议大家阅读《Java并发编程实践》第十六章来加深对Java内存模型的理解。

1.  Java中的volatile 变量是什么？  
    　　volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生，就是上一题的volatile变量规则。点击这里查看更多volatile的相关内容。
2.  什么是线程安全？Vector是一个线程安全类吗？ （详见这里)  
    　　如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。很显然你可以将集合类分成两组，线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。
3.  Java中什么是竞态条件？ 举个例子说明。  
    　　竞态条件会导致程序在并发情况下出现一些bugs。多线程对一些资源的竞争的时候就会产生竞态条件，如果首先要执行的程序竞争失败排到后面执行了，那么整个程序就会出现一些不确定的bugs。这种bugs很难发现而且会重复出现，因为线程间的随机竞争。一个例子就是无序处理，详见答案。
4.  Java中如何停止一个线程？  
    　　Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。点击这里查看示例代码。
5.  一个线程运行时发生异常会怎样？  
    　　这是我在一次面试中遇到的一个很刁钻的Java面试题, 简单的说，如果异常没有被捕获该线程将会停止执行。Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。

15） 如何在两个线程间共享数据？  
　　你可以通过共享对象来实现这个目的，或者是使用像阻塞队列这样并发的数据结构。这篇教程《Java线程间通信》(涉及到在两个线程间共享对象)用wait和notify方法实现了生产者消费者模型。

1.  Java中notify 和 notifyAll有什么区别？  
    　　这又是一个刁钻的问题，因为多线程可以等待单监控锁，Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们，但是这些方法没有完全实现。notify()方法不能唤醒某个具体的线程，所以只有一个线程在等待的时候它才有用武之地。而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。我的博客有更详细的资料和示例代码。
2.  为什么wait, notify 和 notifyAll这些方法不在thread类里面？  
    　　这是个设计相关的问题，它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法。回答这些问题的时候，你要说明为什么把这些方法放在Object类里是有意义的，还有不把它放在Thread类里的原因。一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。简单的说，由于wait，notify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象。你也可以查看这篇文章了解更多。
3.  什么是ThreadLocal变量？  
    　　ThreadLocal是Java里一种特殊的变量。每个线程都有一个ThreadLocal就是每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了。它是为创建代价高昂的对象获取线程安全的好方法，比如你可以用ThreadLocal让SimpleDateFormat变成线程安全的，因为那个类创建代价高昂且每次调用都需要创建不同的实例所以不值得在局部范围使用它，如果为每个线程提供一个自己独有的变量拷贝，将大大提高效率。首先，通过复用减少了代价高昂的对象的创建个数。其次，你在没有使用高代价的同步或者不变性的情况下获得了线程安全。线程局部变量的另一个不错的例子是ThreadLocalRandom类，它在多线程环境中减少了创建代价高昂的Random对象的个数。查看答案了解更多。
4.  什么是FutureTask？  
    　　在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装，由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。
5.  Java中interrupted 和 isInterruptedd方法的区别？  
    　　interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。Java多线程的中断机制是用内部标识来实现的，调用Thread.interrupt()来中断一个线程就会设置中断标识为true。当中断线程调用静态方法Thread.interrupted()来检查中断状态时，中断状态会被清零。而非静态方法isInterrupted()用来查询其它线程的中断状态且不会改变中断状态标识。简单的说就是任何抛出InterruptedException异常的方法都会将中断状态清零。无论如何，一个线程的中断状态有有可能被其它线程调用中断来改变。
6.  为什么wait和notify方法要在同步块中调用？  
    　　主要是因为Java API强制要求这样做，如果你不这么做，你的代码会抛出IllegalMonitorStateException异常。还有一个原因是为了避免wait和notify之间产生竞态条件。
7.  为什么你应该在循环中检查等待条件?  
    　　处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。因此，当一个等待线程醒来时，不能认为它原来的等待状态仍然是有效的，在notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用wait()方法效果更好的原因，你可以在Eclipse中创建模板调用wait和notify试一试。如果你想了解更多关于这个问题的内容，我推荐你阅读《Effective Java》这本书中的线程和同步章节。
8.  Java中的同步集合与并发集合有什么区别？  
    　　同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。更多内容详见答案。

24） Java中堆和栈有什么不同？  
　　为什么把这个问题归类在多线程和并发面试题里？因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存，用于存储本地变量，方法参数和栈调用，一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到自己的栈，如果多个线程使用该变量就可能引发问题，这时volatile 变量就可以发挥作用了，它要求线程从主存中读取变量的值。 更多内容详见答案。

25） 什么是线程池？ 为什么要使用它？  
　　创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）。更多内容详见这篇文章。

26） 如何写代码来解决生产者消费者问题？  
　　在现实中你解决的许多线程问题都属于生产者消费者模型，就是一个线程生产任务供其它线程进行消费，你必须知道怎么进行线程间通信来解决这个问题。比较低级的办法是用wait和notify来解决这个问题，比较赞的办法是用Semaphore 或者 BlockingQueue来实现生产者消费者模型，这篇教程有实现它。

27） 如何避免死锁？  
　　Java多线程中的死锁 死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。这是一个严重的问题，因为死锁会让你的程序挂起无法完成任务，死锁的发生必须满足以下四个条件：

互斥条件：一个资源每次只能被一个进程使用。  
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。  
不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。  
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。  
避免死锁最简单的方法就是阻止循环等待条件，将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁。这篇教程有代码示例和避免死锁的讨论细节。

1.  Java中活锁和死锁有什么区别？  
    　　这是上题的扩展，活锁和死锁类似，不同之处在于处于活锁的线程或进程的状态是不断改变的，活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个人在狭小的走廊碰到，两个人都试着避让对方好让彼此通过，但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是，活锁和死锁的主要区别是前者进程的状态可以改变但是却不能继续执行。

29） 怎么检测一个线程是否拥有锁？  
　　我一直不知道我们竟然可以检测一个线程是否拥有锁，直到我参加了一次电话面试。在java.lang.Thread中有一个方法叫holdsLock()，它返回true如果当且仅当当前线程拥有某个具体对象的锁。你可以查看这篇文章了解更多。

1.  你如何在Java中获取线程堆栈？  
    　　对于不同的操作系统，有多种方法来获得Java进程的线程堆栈。当你获取线程堆栈时，JVM会把所有线程的状态存到日志文件或者输出到控制台。在Windows你可以使用Ctrl + Break组合键来获取线程堆栈，Linux下用kill -3命令。你也可以用jstack这个工具来获取，它对线程id进行操作，你可以用jps这个工具找到id。
2.  JVM中哪个参数是用来控制线程的栈堆栈小的  
    　　这个问题很简单， -Xss参数用来控制线程的堆栈大小。你可以查看JVM配置列表来了解这个参数的更多信息。

32） Java中synchronized 和 ReentrantLock 有什么不同？  
　　Java在过去很长一段时间只能通过synchronized关键字来实现互斥，它有一些缺点。比如你不能扩展锁之外的方法或者块边界，尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性。你可以查看这篇文章了解更多

33） 有三个线程T1，T2，T3，怎么确保它们按顺序执行？  
　　在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3最后完成。你可以查看这篇文章了解更多。

1.  Thread类中的yield方法有什么作用？  
    　　Yield方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行。点击这里查看更多yield方法的相关内容。

35） Java中ConcurrentHashMap的并发度是什么？  
　　ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的，它是ConcurrentHashMap类构造函数的一个可选参数，默认值为16，这样在多线程情况下就能避免争用。欲了解更多并发度和内部大小调整请阅读我的文章How ConcurrentHashMap works in Java。

36） Java中Semaphore是什么？  
　　Java中的Semaphore是一种新的同步类，它是一个计数信号。从概念上讲，从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release()添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore只对可用许可的号码进行计数，并采取相应的行动。信号量常常用于多线程的代码中，比如数据库连接池。更多详细信息请点击这里。

37）如果你提交任务时，线程池队列已满。会时发会生什么？  
　　这个问题问得很狡猾，许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度执行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常。

1.  Java线程池中submit() 和 execute()方法有什么区别？  
    　　两个方法都可以向线程池提交任务，execute()方法的返回类型是void，它定义在Executor接口中, 而submit()方法可以返回持有计算结果的Future对象，它定义在ExecutorService接口中，它扩展了Executor接口，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。更多详细信息请点击这里。
2.  什么是阻塞式方法？  
    　　阻塞式方法是指程序会一直等待该方法完成期间不做其他事情，ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。更多详细信息请点击这里。
3.  Swing是线程安全的吗？ 为什么？  
    　　你可以很肯定的给出回答，Swing不是线程安全的，但是你应该解释这么回答的原因即便面试官没有问你为什么。当我们说swing不是线程安全的常常提到它的组件，这些组件不能在多线程中进行修改，所有对GUI组件的更新都要在AWT线程中完成，而Swing提供了同步和异步两种回调方法来进行更新。点击这里查看更多swing和线程安全的相关内容。

41） Java中invokeAndWait 和 invokeLater有什么区别？  
　　这两个方法是Swing API 提供给Java开发者用来从当前线程而不是事件派发线程更新GUI组件用的。InvokeAndWait()同步更新GUI组件，比如一个进度条，一旦进度更新了，进度条也要做出相应改变。如果进度被多个线程跟踪，那么就调用invokeAndWait()方法请求事件派发线程对组件进行相应更新。而invokeLater()方法是异步调用更新组件的。更多详细信息请点击这里。

1.  Swing API中那些方法是线程安全的？  
    　　这个问题又提到了swing和线程安全，虽然组件不是线程安全的但是有一些方法是可以被多线程安全调用的，比如repaint(), revalidate()。 JTextComponent的setText()方法和JTextArea的insert() 和 append() 方法也是线程安全的。
2.  如何在Java中创建Immutable对象？  
    　　这个问题看起来和多线程没什么关系， 但不变性有助于简化已经很复杂的并发程序。Immutable对象可以在没有同步的情况下共享，降低了对该对象进行并发访问时的同步化开销。可是Java没有@Immutable这个注解符，要创建不可变类，要实现下面几个步骤：通过构造方法初始化所有成员、对变量不要提供setter方法、将所有的成员声明为私有的，这样就不允许直接访问这些成员、在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝。我的文章how to make an object Immutable in Java有详细的教程，看完你可以充满自信。

44） Java中的ReadWriteLock是什么？  
　　一般而言，读写锁是用来提升并发程序性能的锁分离技术的成果。Java中的ReadWriteLock是Java 5 中新增的一个接口，一个ReadWriteLock维护一对关联的锁，一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的，你可以使用JDK中的ReentrantReadWriteLock来实现这个规则，它最多支持65535个写锁和65535个读锁。

1.  多线程中的忙循环是什么?  
    　　忙循环就是程序员用循环让一个线程等待，不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制，而忙循环不会放弃CPU，它就是在运行一个空循环。这么做的目的是为了保留CPU缓存，在多核系统中，一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。你可以查看这篇文章获得更多信息。

46）volatile 变量和 atomic 变量有什么不同？  
　　这是个有趣的问题。首先，volatile 变量和 atomic 变量看起来很像，但功能却不一样。Volatile变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。

1.  如果同步块内的线程抛出异常会发生什么？  
    　　这个问题坑了很多Java程序员，若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的，里面的线程都会释放锁，所以对比锁接口我更喜欢同步块，因为它不用我花费精力去释放锁，该功能可以在finally block里释放锁实现。

48） 单例模式的双检锁是什么？  
　　这个问题在Java面试中经常被问到，但是面试官对回答此问题的满意度仅为50%。一半的人写不出双检锁还有一半的人说不出它的隐患和Java1.5是如何对它修正的。它其实是一个用来创建线程安全的单例的老方法，当单例实例第一次被创建时它试图用单个锁进行性能优化，但是由于太过于复杂在JDK1.4中它是失败的，我个人也不喜欢它。无论如何，即便你也不喜欢它但是还是要了解一下，因为它经常被问到。你可以查看how double checked locking on Singleton works这篇文章获得更多信息。

49） 如何在Java中创建线程安全的Singleton？  
　　这是上面那个问题的后续，如果你不喜欢双检锁而面试官问了创建Singleton类的替代方法，你可以利用JVM的类加载和静态变量初始化特征来创建Singleton实例，或者是利用枚举类型来创建Singleton，我很喜欢用这种方法。你可以查看这篇文章获得更多信息。

1.  写出3条你遵循的多线程最佳实践  
    　　这种问题我最喜欢了，我相信你在写并发代码来提升性能的时候也会遵循某些最佳实践。以下三条最佳实践我觉得大多数Java程序员都应该遵循：

给你的线程起个有意义的名字。 这样可以方便找bug或追踪。OrderProcessor, QuoteProcessor or TradeProcessor 这种名字比 Thread-1. Thread-2 and Thread-3 好多了，给线程起一个和它要完成的任务相关的名字，所有的主要框架甚至JDK都遵循这个最佳实践。  
避免锁定和缩小同步的范围 锁花费的代价高昂且上下文切换更耗费时间空间，试试最低限度的使用同步和锁，缩小临界区。因此相对于同步方法我更喜欢同步块，它给我拥有对锁的绝对控制权。  
多用同步类少用wait 和 notify 首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用wait和notify很难实现对复杂控制流的控制。其次，这些类是由最好的企业编写和维护在后续的JDK中它们还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。  
多用并发集合少用同步集合 这是另外一个容易遵循且受益巨大的最佳实践，并发集合比同步集合的可扩展性更好，所以在并发编程时使用并发集合效果更好。如果下一次你需要用到map，你应该首先想到用ConcurrentHashMap。我的文章Java并发集合有更详细的说明。  
51) 如何强制启动一个线程？  
　　这个问题就像是如何强制进行Java垃圾回收，目前还没有觉得方法，虽然你可以使用System.gc()来进行垃圾回收，但是不保证能成功。在Java里面没有办法强制启动一个线程，它是被线程调度器控制着且Java没有公布相关的API。

1.  Java中的fork join框架是什么？  
    　　fork join框架是JDK7中出现的一款高效的工具，Java开发人员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的，目的是将所有可用的处理能力用来提升程序的性能。fork join框架一个巨大的优势是它使用了工作窃取算法，可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。你可以查看这篇文章获得更多信息。

53） Java多线程中调用wait() 和 sleep()方法有什么不同？  
　　Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。  
\#\#\#集合篇

*  **在迭代一个集合的时候，如何避免ConcurrentModificationException?**  
    在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。
 *  **fail-fast与fail-safe有什么区别？**  
    每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动，它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的（ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外）。
 *  **Iterater和ListIterator之间有什么区别？**  
    （1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。  
    （2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。  
    （3）ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。
 *  **HashSet和TreeSet有什么区别？**  
    HashSet是由一个哈希表来实现的，元素无，add()，remove()，contains()方法的时间复杂度是O(1)。  
    另一方面，TreeSet是由一个树形结构（平衡二叉排序树）来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。
 *  **Enumeration接口和Iterator接口的区别有哪些？**  
    Enumeration速度是Iterator的2倍，同时占用更少的内存。  
    但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。
 *  **ArrayList和LinkedList有什么区别？**  
    两者都实现了List接口，他们有以下不同点：  
    数据结构上：  
    ArrayList是基于索引的数组形式，可随机访问元素， 时间复杂度O(1)；  
    LinkedList是元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。  
    操作上：  
    ArrayList添加，删除操作比较慢，重新计算大小或者是更新索引。  
    LinkedList的插入，添加，删除操作速度更快，不需要更新索引。  
    内存上：  
    LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
 *  **Collection 和 Collections的区别：**  
    Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。  
    Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
 *  **Map接口**  
    |–Hashtable：底层是哈希散列表数据结构，线程同步。不可以存储null键，null值。不可序列化，使用bucket结构体表示单个元素，使用双重散列法（闭散列法）解决冲突（二度哈希，size>length时要进行模运算）。
    
    |–HashMap：底层是哈希表数据结构（链地址法解决冲突），线程不同步。可存一个null键和多个null值。替代了Hashtable. 但可通过Map m = Collections.synchronizeMap(hashMap)实现同步；  
    |–LinkedHashMap，采用双向链表数据结构连接起来所有的entry，保证了存入和取出顺序一致，即链表有序；线程不同步。
    
    |–TreeMap：底层是二叉树结构（平衡二叉排序树），可以对map集合中的键进行指定顺序的排序
 *  **TreeSet集合排序有两种方式，Comparable和Comparator区别：**  
    1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。  
    2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。第二种方式较为灵活。
 *  **ArrayList，LinkedList，Vector的区别**  
    List：有序(元素存入集合的顺序和取出的顺序一致)元素都有索引。元素可以重复。（有序可重复）  
    |–ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。默认大小10，1.5倍长度扩容。  
    |–LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。  
    |–Vector：底层的数据结构就是数组，线程同步，Vector无论查询和增删都巨慢。默认大 小10，2倍长度扩容
 *  **集合和数组的区别：**  
    1：数组是固定长度的；集合可变长度的。  
    2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。  
    3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。
 *  **ArrayList 和 LinkedList 有什么区别。**  
    ArrayList和LinkedList都实现了List接口，有以下的不同点：  
    1、ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。  
    2、相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。  
    3、LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素  
    \#\#\#多线程篇
 *  透彻理解 Java synchronized 对象锁和类锁的区别  
    \#\#\#Hibernate
 *  1、什么是Hibernate的并发机制？怎么去处理并发问题？  
    Hibernate并发机制：  
    a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工作单元(即单个事务,单个线程),它通常只使用一次, 然后就丢弃。  
    如果一个Session 实例允许共享的话，那些支持并发运行的,例如Http request,session beans将会导致出现资源争用。  
    如果在Http Session中有hibernate的Session的话,就可能会出现同步访问Http Session。只要用户足够快的点击浏览器的“刷新”, 就会导致两个并发运行的线程使用同一个Session。  
    1  
    2  
    3  
    4  
    b、多个事务并发访问同一块资源,可能会引发第一类丢失更新，脏读，幻读，不可重复读，第二类丢失更新一系列的问题。  
    解决方案：设置事务隔离级别。  
    Serializable：串行化。隔离级别最高  
    Repeatable Read：可重复读  
    Read Committed：已提交数据读  
    Read Uncommitted：未提交数据读。隔离级别最差  
    设置锁：乐观锁和悲观锁。  
    乐观锁：使用版本号或时间戳来检测更新丢失,在的映射中设置 optimistic-lock=”all”可以在没有版本或者时间戳属性映射的情况下实现 版本检查，此时Hibernate将比较一行记录的每个字段的状态 行级悲观锁：Hibernate总是使用数据库的锁定机制，从不在内存中锁定对象！只要为JDBC连接指定一下隔 离级别，然后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不同的锁定级别：LockMode.UPGRADE,LockMode.UPGRADE\_NOWAIT,LockMode.READ;
 *  2、update和saveOrUpdate的区别？  
    update()和saveOrUpdate()是用来对跨Session的PO进行状态管理的。  
    update()方法操作的对象必须是持久化了的对象。也就是说，如果此对象在数据库中不存在的话，就不能使用update()方法。  
    saveOrUpdate()方法操作的对象既可以使持久化了的，也可以使没有持久化的对象。如果是持久化了的对象调用saveOrUpdate()则会 更新数据库中的对象；如果是未持久化的对象使用此方法,则save到数据库中。
 *  3、hibernate的三种状态之间如何转换  
    当对象由瞬时状态(Transient)一save()时，就变成了持久化状态；  
    当我们在Session里存储对象的时候，实际是在Session的Map里存了一份， 也就是它的缓存里放了一份，然后，又到数据库里存了一份，在缓存里这一份叫持久对象(Persistent)。 Session 一 Close()了,它的缓存也都关闭了,整个Session也就失效了,这个时候，这个对象变成了游离状态(Detached)，但数据库中还是存在的。  
    当游离状态(Detached)update()时，又变为了持久状态(Persistent)。  
    当持久状态(Persistent)delete()时，又变为了瞬时状态(Transient), 此时，数据库中没有与之对应的记录。
 *  4、比较hibernate的三种检索策略优缺点  
    1立即检索；  
    优点： 对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象；  
    缺点： 1.select语句太多；2.可能会加载应用程序不需要访问的对象白白浪费许多内存空间；  
    2延迟检索：  
    优点： 由应用程序决定需要加载哪些对象，可以避免可执行多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并且能节省内存空间；  
    缺点： 应用程序如果希望访问游离状态代理类实例，必须保证他在持久化状态时已经被初始化；
 *  3 迫切左外连接检索  
    优点： 1对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便地冲一个对象导航到与它关联的对象。2使用了外连接，select语句数目少；  
    缺点： 1 可能会加载应用程序不需要访问的对象，白白浪费许多内存空间；2复杂的数据库表连接也会影响检索性能；
 *  5、如何在控制台看到hibernate生成并执行的sql  
    在定义数据库和数据库属性的文件applicationConfig.xml里面，把hibernate.show\_sql 设置为true  
    这样生成的SQL就会在控制台出现了  
    注意：这样做会加重系统的负担，不利于性能调优
 *  6、hibernate都支持哪些缓存策略  
    Read-only: 这种策略适用于那些频繁读取却不会更新的数据，这是目前为止最简单和最有效的缓存策略

*  Read/write:这种策略适用于需要被更新的数据，比read-only更耗费资源，在非JTA环境下，每个事务需要在session.close和session.disconnect()被调用
 *  Nonstrict read/write: 这种策略不保障两个同时进行的事务会修改同一块数据，这种策略适用于那些经常读取但是极少更新的数据
 *  Transactional: 这种策略是完全事务化得缓存策略，可以用在JTA环境下

*  7、hibernate里面的sorted collection 和ordered collection有什么区别  
    sorted collection是在内存中通过Java比较器进行排序的  
    ordered collection是在数据库中通过order by进行排序的
 *  8、Hibernate工作原理及为什么要用？  
    1.读取并解析配置文件  
    2.读取并解析映射信息，创建SessionFactory  
    3.打开Sesssion  
    4.创建事务Transation  
    5.持久化操作  
    6.提交事务  
    7.关闭Session  
    8.关闭SesstionFactory  
    为什么要用：  
    对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。  
    Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作  
    hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。  
    hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
 *  10、Hibernate是如何延迟加载?  
    当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
 *  11、Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)  
    类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、
 *  12、说下Hibernate的缓存机制  
    内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

二级缓存：  
a) 应用及缓存  
b) 分布式缓存  
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据  
c) 第三方缓存的实现

*  13、Hibernate的查询方式  
    Sql、Criteria,objectcomposition  
    Hql：  
    1、 属性查询  
    2、 参数查询、命名参数查询  
    3、 关联查询  
    4、 分页查询  
    5、 统计函数
 *  14、如何优化Hibernate？  
    1.使用双向一对多关联，不使用单向一对多  
    2.灵活使用单向一对多关联  
    3.不用一对一，用多对一取代  
    4.配置对象缓存，不使用集合缓存  
    5.一对多集合使用Bag,多对多集合使用Set

1.  继承类使用显式多态
2.  表字段要少，表关联不要怕多，有二级缓存撑腰

*  15、Hibernate有哪几种查询数据的方式  
    3种：hql、条件查询QBC(QueryBy Criteria)、原生sql （通过createSQLQuery建立）
 *  16、谈谈Hibernate中inverse的作用  
    inverse属性默认是false,就是说关系的两端都来维护关系。  
    比如Student和Teacher是多对多关系，用一个中间表TeacherStudent维护。Gp)i  
    如果Student这边inverse=”true”, 那么关系由另一端Teacher维护，就是说当插入Student时，不会操作TeacherStudent表（中间表）。只有Teacher插入或删除时才会触发对中间表的操作。所以两边都inverse=”true”是不对的，会导致任何操作都不触发对中间表的影响；当两边都inverse=”false”或默认时，会导致在中间表中插入两次关系。
 *  17、Detached Object（游离对象）有什么好处  
    Detached Object（游离对象）可以传递到任何层直到表现层而不是用任何DTO(DataTransfer Objects). 然后你还可以重新把游离对象赋给另外一个Session.
 *  18、JDBC hibernate 和 ibatis 的区别  
    jdbc:手动  
    手动写sql  
    delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。  
    select:返回的是一个resultset，要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。  
    ibatis的特点:半自动化  
    sql要手动写  
    delete、insert、update:直接传入一个对象  
    select:直接返回一个对象  
    hibernate:全自动  
    不写sql,自动封装  
    delete、insert、update:直接传入一个对象  
    select:直接返回一个对象
 *  19、在数据库中条件查询速度很慢的时候,如何优化?  
    1.建索引  
    2.减少表之间的关联  
    3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面  
    4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据
 *  20、什么是SessionFactory,她是线程安全么？  
    SessionFactory 是Hibrenate单例数据存储和线程安全的，以至于可以多线程同时访问。一个SessionFactory 在启动的时候只能建立一次。SessionFactory应该包装各种单例以至于它能很简单的在一个应用代码中储存.
 *  21、Hibernate的五个核心接口  
    Configuration 接口：配置Hibernate，根据其启动hibernate，创建  
    SessionFactory 对象；  
    SessionFactory 接口：初始化Hibernate，充当数据存储源的代理，创建  
    session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应  
    用的多个线程共享，是重量级、二级缓存；  
    Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，  
    避免多个线程共享同一个session，是轻量级、一级缓存；  
    Transaction 接口：管理事务；  
    Query 和Criteria 接口：执行数据库的查询
 *  22.Hibernate的查询方式有哪些？  
    本地SQL查询、Criteria、Hql  
    5.如何优化Hibernate？  
    1.使用双向一对多关联，不使用单向一对多  
    2.灵活使用单向一对多关联  
    3.不用一对一，用多对一取代  
    4.配置对象缓存，不使用集合缓存  
    5.一对多集合使用Bag,多对多集合使用Set

1.  继承类使用显式多态
2.  表字段要少，表关联不要怕多，有二级缓存撑腰

*  23.Hibernate中GET和LOAD的区别？  
    请注意如果没有匹配的数据库记录，load()方法可能抛出无法恢复的异常(unrecoverable exception)。 如果类的映射使用了代理(proxy)，load()方法会返回一个未初始化的代理，直到你调用该代理的某方法时才会去访问数据库。若你希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上的了。 如果为相应类映射关系设置了batch-size， 那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象的数据）。 如果你不确定是否有匹配的行存在，应该使用 get()方法，它会立刻访问数据库，如果没有对应的行，会返回null。  
    session.get 方法， 查询立即执行 ， 返回Customer类对象  
    session.load 方法，默认采用延迟加载数据方式，不会立即查询，返回 Customer类子类对象 （动态生成代理对象）

*  如果 PO类使用final修饰，load无法创建代理对象，返回目标对象本身 （load效果和 get效果 相同 ）

*  24.说说在 hibernate中使用Integer做映射和使用int做映射之间有什么差别？  
    Integer code和int code的区别:  
    Integer是对象. code=null; 对象可以为空.  
    int 是普通类型, 不可能=null.  
    根据你的数据库code是可以空的,故应该映射成Integer.  
    你没理由hbm.xml里写 Integer,类里却写int
 *  .25SQL和HQL有什么区别？  
    sql 面向数据库表查询  
    hql 面向对象查询  
    hql：from 后面跟的 类名＋类对象 where 后 用 对象的属性做条件  
    sql：from 后面跟的是表名 where 后 用表中字段做条件  
    查询  
    在Hibernate中使用查询时，一般使用Hql查询语句。  
    HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。  
    使用HQL时需要注意以下几点：  
    1.大小写敏感  
    因为HQL是面向对象的，而对象类的名称和属性都是大小写敏感的，所以HQL是大小写敏感的。  
    HQL语句：from Cat as cat where [cat.id][] > 1;与from Cat as cat where [cat.ID][] > 1;是不一样的，这点与SQL不同。  
    2.from子句  
    from Cat，该句返回Cat对象实例，开发人员也可以给其加上别名，eg. from Cat as cat，对于多表查询的情况，可参考如下：  
    from Cat as cat, Dog as dog  
    其它方面都与SQL类似，在此不再赘述。
 *  .26Hibernate的分页查询  
    例如：从数据库中的第20000条数据开始查后面100条记录  
    Query q = session.createQuery(“from Cat as c”);;  
    q.setMaxResults(100);;  
    List l = q.list();;  
    q.setFirstResult(20000);
 *  27.Hibernate中Java对象的状态以及对应的特征有哪些？  
    持久化对象的三种状态  
    持久化对象PO和OID  
    PO=POJO + hbm映射配置  
    编写规则  
    ①必须提供无参数public构造器  
    ②所有属性private，提供public的getter和setter方法  
    ③必须提供标识属性，与数据表中主键对应，例如Customer类 id属性  
    ④PO类属性应尽量使用基本数据类型的包装类型(区分空值) 例如int—Integer long—Long  
    ⑤不要用final修饰（将无法生成代理对象进行优化）  
    OID 指与数据表中主键对应 PO类中属性，例如 Customer类 id属性  
    Hibernate框架使用OID来区分不同PO对象  
    \* 例如内存中有两个PO对象，只要具有相同 OID， Hibernate认为同一个对象
    
     *  Hibernate 不允许缓存同样OID的两个不同对象  
        ①瞬时态(临时态、自由态)：不存在持久化标识OID，尚未与Hibernate Session关联对象，被认为处于瞬时态，失去引用将被JVM回收  
        ②持久态：存在持久化标识OID，与当前session有关联，并且相关联的session没有关闭 ,并且事务未提交  
        ③脱管态(离线态、游离态)：存在持久化标识OID，但没有与当前session关联，脱管状态改变hibernate不能检测到  
        区分三种状态：判断对象是否有OID，判断对象是否与session关联(被一级缓存引用)  
        // 获得Session  
        Session session =HibernateUtils.openSession();  
        // 开启事务  
        Transaction transaction = session.beginTransaction();  
        Book book =newBook();// 瞬时态(没有OID，未与Session关联)  
        book.setName(“hibernate精通”);  
        book.setPrice(56d);  
        session.save(book);// 持久态(具有OID，与Session关联)  
        // 提交事务，关闭Session  
        transaction.commit();  
        session.close();  
        System.out.println(book.getId());// 脱管态(具有 OID，与Session断开关联)  
        持久化对象状态转换  
        ①瞬时态对象：通过new获得  
        瞬时----->持久 save、saveOrUpdate(都是session)  
        瞬时----->脱管 book.setId(1) 为瞬时对象设置OID  
        ②持久态对象：通过get/load 、Query查询获得  
        持久----->瞬时 delete （被删除持久化对象 不建议再次使用 ）  
        持久----->脱管 evict(清除一级缓存中某一个对象)、close(关闭Session，清除一级缓存)、clear(清除一级缓存所有对象 )  
        ③脱管态对象 无法直接获得  
        脱管----->瞬时 book.setId(null); 删除对象OID  
        脱管----->持久 update、saveOrUpdate、 lock(过时  
        \#\#\#Struts  
        \#\#\#Spring  
        \#\#\#SQL  
        数据库建立索引的原则  
        1，确定针对该表的操作是大量的查询操作还是大量的增删改操作。

2，尝试建立索引来帮助特定的查询。检查自己的sql语句，为那些频繁在where子句中出现的字段建立索引。

3，尝试建立复合索引来进一步提高系统性能。修改复合索引将消耗更长时间，同时，复合索引也占磁盘空间。

4，对于小型的表，建立索引可能会影响性能

5，应该避免对具有较少值的字段进行索引。

6，避免选择大型数据类型的列作为索引。

索引建立的原则

索引查询是数据库中重要的记录查询方法，要不要进入索引以及在那些字段上建立索引都要和实际数据库系统的查询要求结合来考虑，下面给出实际中的一些通用的原则：

1.  在经常用作过滤器的字段上建立索引；
2.  在SQL语句中经常进行GROUP BY、ORDER BY的字段上建立索引；
3.  在不同值较少的字段上不必要建立索引，如性别字段；
4.  对于经常存取的列避免建立索引；
5.  用于联接的列（主健/外健）上建立索引；
6.  在经常存取的多个列上建立复合索引，但要注意复合索引的建立顺序要按照使用的频度来确定；
7.  缺省情况下建立的是非簇集索引，但在以下情况下最好考虑簇集索引，如：含有有限数目（不是很少）唯一的列；进行大范围的查询；充分的利用索引可以减少表扫描I/0的次数，有效的避免对整表的搜索。当然合理的索引要建立在对各种查询的分析和预测中，也取决于DBA的所设计的数据库结构。  
    \#\#\#异常

*  请列出 5 个运行时异常。
 *  我们比较熟悉的Checked异常有  
    Java.lang.ClassNotFoundException  
    Java.lang.NoSuchMetodException  
    java.io.IOException  
    我们比较熟悉的RumtimeException类的子类有  
    Java.lang.ArithmeticException  
    Java.lang.ArrayStoreExcetpion  
    Java.lang.ClassCastException  
    Java.lang.IndexOutOfBoundsException  
    Java.lang.NullPointerException  
    \#\#\#反射  
    \#\#\#基础
 *  **什么是JDK？什么是JRE?**  
    JDK：java development kit：java开发工具包，是开发人员所需要安装的环境  
    JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境
 *  **Java的数据结构有那些**  
    线性表（ArrayList）  
    链表（LinkedList）  
    栈（Stack）  
    队列（Queue）  
    图（Map）  
    树（Tree）
 *  **Static关键字有什么作用？**  
    Static可以修饰内部类、方法、变量、代码块  
    Static修饰的类是静态内部类  
    Static修饰的方法是静态方法，表示该方法属于当前类的，而不属于某个对象的，静态方法也不能被重写，可以直接使用类名来调用。在static方法中不能使用this或者super关键字。  
    Static修饰变量是静态变量或者叫类变量，静态变量被所有实例所共享，不会依赖于对象。静态变量在内存中只有一份拷贝，在JVM加载类的时候，只为静态分配一次内存。  
    Static修饰的代码块叫静态代码块，通常用来做程序优化的。静态代码块中的代码在整个类加载的时候只会执行一次。静态代码块可以有多个，如果有多个，按照先后顺序依次执行
 *  **内部类与静态内部类的区别？**  
    静态内部类相对与外部类是独立存在的，在静态内部类中无法直接访问外部类中变量、方法。如果要访问的话，必须要new一个外部类的对象，使用new出来的对象来访问。但是可以直接访问静态的变量、调用静态的方法；  
    普通内部类作为外部类一个成员而存在，在普通内部类中可以直接访问外部类属性，调用外部类的方法。  
    如果外部类要访问内部类的属性或者调用内部类的方法，必须要创建一个内部类的对象，使用该对象访问属性或者调用方法。  
    如果其他的类要访问普通内部类的属性或者调用普通内部类的方法，必须要在外部类中创建一个普通内部类的对象作为一个属性，外同类可以通过该属性调用普通内部类的方法或者访问普通内部类的属性  
    如果其他的类要访问静态内部类的属性或者调用静态内部类的方法，直接创建一个静态内部类对象即可。
 *  **String， Stringbuffer， StringBuilder 的区别。**  
    String 字符串常量(final修饰，不可被继承)，String是常量，当创建之后即不能更改。(可以通过StringBuffer和StringBuilder创建String对象(常用的两个字符串操作类)。)  
    StringBuffer 字符串变量（线程安全）,其也是final类别的，不允许被继承，其中的绝大多数方法都进行了同步处理，包括常用的Append方法也做了同步处理(synchronized修饰)。其自jdk1.0起就已经出现。其toString方法会进行对象缓存，以减少元素复制开销。  
    public synchronized String toString() \{  
    if (toStringCache == null) \{  
    toStringCache = Arrays.copyOfRange(value, 0, count);  
    \}  
    return new String(toStringCache, true);  
    \}  
    StringBuilder 字符串变量（非线程安全）其自jdk1.5起开始出现。与StringBuffer一样都继承和实现了同样的接口和类，方法除了没使用synch修饰以外基本一致，不同之处在于最后toString的时候，会直接返回一个新对象。  
    public String toString() \{  
    // Create a copy, don’t share the array  
    return new String(value, 0, count);  
    \}
 *  **抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。**  
    1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。  
    2、抽象类要被子类继承，接口要被类实现。  
    3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现  
    4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。  
    5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。  
    6、抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc()\{\}。  
    7、抽象类里可以没有抽象方法  
    8、如果一个类里有抽象方法，那么这个类只能是抽象类  
    9、抽象方法要被实现，所以不能是静态的，也不能是私有的。  
    10、接口可继承接口，并可多继承接口，但类只能单根继承。
 *  **继承和聚合的区别在哪。**  
    **继承**指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；  
    **聚合**是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

[cat.id]: http://cat.id
[cat.ID]: http://cat.ID