2018年Java面试题
参考答案：https://blog.csdn.net/matry521/article/details/52210139
1. String类为什么是final的。
答：主要是为了“效率” 和 “安全性” 的缘故。若 String允许被继承, 由于它的高度被使用率, 可能会降低程序的性能，所以String被定义成final。
1、 从设计安全)上讲，
1)、确保它们不会在子类中改变语义。String类是final类，这意味着不允许任何人定义String的子类。换言之，如果有一个String的引用，它引用的一定是一个String对象，而不可能是其他类的对象。
2)、String 一旦被创建是不能被修改的，因为 java 设计者将String 为可以共享的
2、从效率上讲：
1)、设计成final，JVM才不用对相关方法在虚函数表中查询，而直接定位到String类的相关方法上，提高了执行效率。
2)、Java设计者认为共享带来的效率更高。
2. HashMap的源码，实现原理，底层结构。
HashMap：按照特性来说明一下，储存的是键值对，线程不安全，非Synchronied，储存的比较快，能够接受null。按照工作原理来叙述一下，Map的put（key，value）来储存元素，通过get（key）来得到value值，通过hash算法来计算hascode值，根据hashcode值来决定bucket（桶），储存结构就算哈希表。
提问：两个hashcode相同的时候会发生说明？
hashcode相同，bucket的位置会相同，也就是说会发生碰撞，哈希表中的结构其实有链表（LinkedList），这种冲突通过将元素储存到LinkedList中，解决碰撞。储存顺序是仿在表头。
如果两个键的hashcode相同，如何获取值对象？
如果两个键的hashcode相同，我们通过key.equals（）找到LinkedList中正确的节点。
如果HashMap的大小超过了负载因子？怎么办？
默认的HashMap里面的负载因子大小是0.75，将会重新创建一个原来HashMap大小的两倍bucket数组。
重新调整的话会出现什么问题？
多线程情况下会出现竞争问题，因为你在调节的时候，LinkedList储存是按照顺序储存，调节的时候回将原来最先储存的元素（也就是最下面的）遍历，多线程就好试图重新调整，这个时候就会出现死循环。
为什么要用String、Wrapper类，来作为键值对？
因为他们一般是不可变的，源码上面final，使用不可变类，而且重写了equals和hashcode方法，避免了键值对改写。提高HashMap性能。 使用CocurrentHashMap代替Hashtable？ 可以，但是Hashtable提供的线程更加安全。
参考：https://blog.csdn.net/anneqiqi/article/details/51584493
3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯。。。
1、Interface Iterable
迭代器接口，这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有"foreach可遍历性"。这个Iterable接口只有一个方法: iterator()。它返回一个代表当前集合对象的泛型
1.1 Collection
Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。Collection是一个接口，用以提供规范定义，不能被实例化使用
1) Set
Set集合类似于一个罐子，"丢进"Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素(记住，这是整个Set类层次的共有属性)。Set判断两个对象相同不是使用"=="运算符，而是根据equals方法。也就是说，我们在加入一个新元素的时候，如果这个新元素对象和Set中已有对象进行注意equals比较都返回false，则Set就会接受这个新元素对象，否则拒绝。因为Set的这个制约，在使用Set集合的时候，应该注意两点：1) 为Set集合里的元素的实现类实现一个有效的equals(Object)方法、2) 对Set的构造函数，传入的Collection参数不能包含重复的元素
1.1) HashSet
HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等
1.1.1) LinkedHashSet
LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)
1.2) SortedSet
此接口主要用于排序操作，即实现此接口的子类都属于排序的子类
1.2.1) TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态
1.3) EnumSet
EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序
2) List
List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引
2.1) ArrayList
ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。
2.2) Vector
Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将Vector改为实现List接口，统一归入集合框架体系中
2.2.1) Stack
Stack是Vector提供的一个子类，用于模拟"栈"这种数据结构(LIFO后进先出)
2.3) LinkedList
implements List
3) Queue
Queue用于模拟"队列"这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部，访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。结合生活中常见的排队就会很好理解这个概念
3.1) PriorityQueue
PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以看出来
3.2) Deque
Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用
3.2.1) ArrayDeque
是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重新分配一个Object[]数组来存储集合元素
3.2.2) LinkedList
1.2 Map
Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)
1) HashMap
和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、同时两个key的hashCode值也必须相等
1.1) LinkedHashMap
LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区分)
2) Hashtable
是一个古老的Map实现类
2.1) Properties
Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文
件中，也可以把属性文件中的"属性名-属性值"加载到Map对象中
3) SortedMap
正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类
3.1) TreeMap
TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的
key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序
4) WeakHashMap
WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的"强引用"，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。
但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃
圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对
5) IdentityHashMap
IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等
6) EnumMap
EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序
(即枚举值在枚举类中的定义顺序)
4. 描述一下ArrayList和LinkedList各自实现和区别
ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
ArrayList和LinkedList都实现了List接口，有以下的不同点：
1、ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。
2、相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。
3、LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
5. Java中的队列都有哪些，有什么区别。
种类：普通队列、阻塞队列、非阻塞队列
6. 反射中，Class.forName和classloader的区别
答：共同点
1. 两者都会将用户指定的类加载到内存JVM中，供用户使用
不同点：
Class.forName还会对类进行解释，执行类中的static块方法，还有要不要初始static变量的参数，而ClassLoader.loadClass()没有；Class.forName的重载方法是静态的，而ClassLoader.loadClass不是。
7. Java7、Java8的新特性(baidu问的,好BT)
Java7：
switch中可以使用字符串了
运用List
语法上支持集合，而不一定是数组
final List
新增一些取环境信息的工具方法
Java8：
Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法
lambda表达式
函数式接口
参考：https://blog.csdn.net/samjustin1/article/details/52268004
8. Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高
答：数组在随机访问数据、随机增加数据、随机删除数据的执行效率上比链表的效率高，数据量越小，两者之间效率的差距越小，数据量越大差距越大。
9. Java内存泄露的问题调查定位：
jmap，jstack的使用等等
参考：https://blog.csdn.net/kingmax54212008/article/details/51858923
10. string、stringbuilder、stringbuffer区别
String 字符串常量(final修饰，不可被继承)，String是常量，当创建之后即不能更改。(可以通过StringBuffer和StringBuilder创建String对象(常用的两个字符串操作类)。)
StringBuffer 字符串变量（线程安全）,其也是final类别的，不允许被继承，其中的绝大多数方法都进行了同步处理，包括常用的Append方法也做了同步处理(synchronized修饰)。其自jdk1.0起就已经出现。其toString方法会进行对象缓存，以减少元素复制开销。
StringBuilder 字符串变量（非线程安全）其自jdk1.5起开始出现。与StringBuffer一样都继承和实现了同样的接口和类，方法除了没使用synch修饰以外基本一致，不同之处在于最后toString的时候，会直接返回一个新对象。
11. hashtable和hashmap的区别
相同点：
一: 存储方式相同，利用一个内部类，实现的是Map.Entity接口，内部实现不一样，但是都是以节点方式进行存储的。是一种单向链表，链表是基于数组的
不同点：
一: HashMap可以允许key为null，value为null，HashTable都不允许为null
二: 继承的类不一样
三: 同步机制不一样
四: HashMap中没有contains（）方法。
五: 它们的数组初始化大小和扩容方式不一样，HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。
13 .异常的结构，运行时异常和非运行时异常，各举个例子
（1）运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
（2）非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
14. String a= “abc” String b = “abc” String c = newString(“abc”) String d = “ab” + “c” .他们之间用 == 比较的结果
a 和 b true
c 和 d false
15. String 类的常用方法
**字符串查找,查找h首次出现在字符串的位置 **
int i=str.indexOf("h") ; 返回值类型int型
字符串查找，查找h最后一次出现的位置
int i=str.LastIndexOf("h");同上
**PS:若LastIndexOf的参数为"",返回结果与length()相同 **
** 获取指定索引位置的字符 ** ，返回值类型char
char i=str.charAt(3)；
字符串截取，beginIndex为开始截取的位置；
String i=str.substring(int beginIndex);
字符串截取，beginIndex为开始截取的位置，endIndex为结束位的前一位（不包括结束位）
String i=str.substring(int beginIndex,intendIndex);
去掉前尾部空格
String i=str.trim();
字符串替换 PS:如要替换的字符串内有空格，则无法替换；若要替换的字符出现多次，则全部替换
Stringi=str.replace("hel","HLE");
判断字符串开始与结尾 返回值布尔型
boolean i=str.startsWith("hel");
boolean i=str.endsWith("o");
** 判断字符是否相等 ** 返回值布尔型
boolean i=str.equals(str1);
equalsIgnoreCase()判断时忽略字符串内大小写
** 字母大小写转换 ** 数字和非字符不受影响，若没有需要转换的，则将原字符串返回
str.toLowerCase; 大转小
str.toUpperCase; 小转大
16. Java 的引用类型有哪几种
强引用、软引用、弱引用、虚引用四种
· 强引用:类似Object a=new Object()这类,永远不会被回收。
· 软引用:SoftReference,当系统快要发生内存溢出异常时，将会把这些对象列入回收范围进行二次回收，如果这次回收还是没有足够内存，则抛出内存溢出异常。
· 弱引用：比软引用更弱，活不过下一次gc。无论当前内存是否足够，下一次gc都会被回收掉。
· 虚引用：又叫幻引用，最弱，一个对象时候有虚引用的存在，不会对它的生存时间构成影响，唯一目的就是能在这对象被回收以后收到一个系统通知。
17. 抽象类和接口的区别
接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。
第一点． 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
第二点． 接口可以多继承，抽象类不行
第三点． 接口定义方法，不能实现，而抽象类可以实现部分方法。
第四点． 接口中基本数据类型为static 而抽类象不是的。
当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的
所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。
18. java的基础类型和字节大小。
19. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题（建议熟悉 jdk 源码，才能从容应答）
HashMap 是否是线程安全的，如何在线程安全的前提下使用 HashMap,其实也就是HashMap，Hashtable，ConcurrentHashMap 和 synchronizedMap 的原理和区别。当时有些紧张只是简单说了下HashMap不是线程安全的；Hashtable 线程安全，但效率低，因为是 Hashtable 是使用synchronized 的，所有线程竞争同一把锁；而ConcurrentHashMap 不仅线程安全而且效率高，因为它包含一个segment 数组，将数据分段存储，给每一段数据配一把锁，也就是所谓的锁分段技术。当时忘记了 synchronized Map 和解释一下 HashMap 为什么线程不安全。面试结束后问了下面试官哪里有些不足，面试官说上面这个问题的回答算过关，但可以在深入一些或者自己动手尝试一下。so~~~虽然拿到了 offer，但还是再整理一下，不能得过且过啊。
参考：https://www.cnblogs.com/huajiezh/p/6411695.html
https://www.cnblogs.com/grefr/p/6094888.html
20. 如果不让你用Java Jdk提供的工具，你自己实现一个Map，你怎么做。说了好久，说了HashMap源代码，如果我做，就会借鉴HashMap的原理，说了一通HashMap实现
同HashMap原理
参考：http://www.cnblogs.com/xwdreamer/archive/2012/05/14/2499339.html
21. Hash冲突怎么办？哪些解决散列冲突的方法？
使用链表
参考：http://xiaolu123456.iteye.com/blog/1485349
22. HashMap冲突很厉害，最差性能，你会怎么解决?从O（n）提升到log（n）咯，用二叉排序树的思路说了一通
参考： http://www.2cto.com/kf/201505/399352.html
理解了hashmap的实现，聪明的人肯定已经知道怎么更加高性能的使用hashmap。不过在此之前还是先说明下初始容量和负载因子的含义。
Hashmap的设想是在O(1)的时间复杂度存取数据，根据我们的分析，在最坏情况下，时间复杂度很可能是o(n)，但这肯定极少出现。但是某个链表中存在多个元素还是有相当大的可能的。当hashmap中的元素数量越接近数组长度，这个几率就越大。为了保证hashmap的性能，我们对元素数量/数组长度的值做了上限，此值就是负载因子。当比值大于负载因子时，就需要对内置数组进行扩容，从而提高读写性能。但这也正是问题的所在，对数组扩容，代价较大，时间复杂度时O(n)。
故我们在hashmap需要存放的元素数量可以预估的情况下，预先设定一个初始容量，来避免自动扩容的操作来提高性能。
23. rehash
在介绍HashMap的内部实现机制时提到了两个参数，DEFAULT_INITIAL_CAPACITY和DEFAULT_LOAD_FACTOR，DEFAULT_INITIAL_CAPACITY是table数组的容量，DEFAULT_LOAD_FACTOR则是为了最大程度避免哈希冲突，提高HashMap效率而设置的一个影响因子，将其乘以DEFAULT_INITIAL_CAPACITY就得到了一个阈值threshold，当HashMap的容量达到threshold时就需要进行扩容，这个时候就要进行ReHash操作了，可以看到下面addEntry函数的实现，当size达到threshold时会调用resize函数进行扩容。
在扩容的过程中需要进行ReHash操作，而这是非常耗时的，在实际中应该尽量避免。
24. hashCode() 与 equals() 生成算法、方法怎么重写
参考： http://blog.csdn.net/jiangwei0910410003/article/details/22739953
25. 讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。
参考：http://blog.csdn.net/zxman660/article/details/7875799
26. 讲讲NIO。
参考：http://blog.jobbole.com/88984/
27. String 编码UTF-8 和GBK的区别?
参考：http://blog.csdn.net/chruan/article/details/8812110
28. 什么时候使用字节流、什么时候使用字符流?
参考：http://blog.csdn.net/zj8692286/article/details/12650731
29. 递归读取文件夹下的文件，代码怎么实现
privateList
File[] files = file.listFiles();
if(files==null)return resultFileName;//判断目录下是不是空的
for (File f : files) {
if(f.isDirectory()){// 判断是否文件夹
resultFileName.add(f.getPath());
ergodic(f,resultFileName);// 调用自身,查找子目录
}else
resultFileName.add(f.getPath());
}
return resultFileName;
}
30. session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。
cookie和session 的区别：
1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
考虑到安全应当使用session。
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能
考虑到减轻服务器性能方面，应当使用COOKIE。
4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
cookie 和session 的联系：
session是通过cookie来工作的
session和cookie之间是通过$_COOKIE['PHPSESSID']来联系的，通过$_COOKIE['PHPSESSID']可以知道session的id，从而获取到其他的信息。
在购物网站中通常将用户加入购物车的商品联通session_id记录到数据库中，当用户再次访问是，通过sessionid就可以查找到用户上次加入购物车的商品。因为sessionid是唯一的，记录到数据库中就可以根据这个查找了。
生命周期：
Session存储在服务器端，一般为了防止在服务器的内存中（为了高速存取），Sessinon在用户访问第一次访问服务器时创建，需要注意只有访问JSP、Servlet等程序时才会创建Session，只访问HTML、IMAGE等静态资源并不会创建Session，可调用request.getSession(true)强制生成Session。
Session什么时候失效？
1. 服务器会把长时间没有活动的Session从服务器内存中清除，此时Session便失效。Tomcat中Session的默认失效时间为20分钟。
2. 调用Session的invalidate方法。
多个服务部署时session管理
三种方式：
1. Session复制，Web服务器之间同步session信息。
2. 负载均衡支持会话亲和，相同的会话请求发送给同一个Web服务器。
3. Session不存在Web服务器本地，而是放在缓存服务器如Redis上。
31. servlet的一些相关问题
32.webservice相关问题
33.jdbc连接，forname方式的步骤，怎么声明使用一个事务。举例并具体代码
34. 无框架下配置web.xml的主要配置内容
35.jsp和servlet的区别
36. Java的内存模型以及GC算法
参考：http://www.cnblogs.com/AloneSword/p/4262255.html
JVM内存模型中分两大块，一块是NEW Generation, 另一块是Old Generation. 在NewGeneration中，有一个叫Eden的空间，主要是用来存放新生的对象，还有两个Survivor Spaces（from,to）, 它们用来存放每次垃圾回收后存活下来的对象。在Old Generation中，主要存放应用程序中生命周期长的内存对象，还有个Permanent Generation，主要用来放JVM自己的反射对象，比如类对象和方法对象等。
在New Generation块中，垃圾回收一般用Copying的算法，速度快。每次GC的时候，存活下来的对象首先由Eden拷贝到某个SurvivorSpace, 当SurvivorSpace空间满了后, 剩下的live对象就被直接拷贝到OldGeneration中去。因此，每次GC后，Eden内存块会被清空。在Old Generation块中，垃圾回收一般用mark-compact的算法，速度慢些，但减少内存要求.
垃圾回收分多级，0级为全部(Full)的垃圾回收，会回收OLD段中的垃圾；1级或以上为部分垃圾回收，只会回收NEW中的垃圾，内存溢出通常发生于OLD段或Perm段垃圾回收后，仍然无内存空间容纳新的Java对象的情况。
1,outof memory 只发生在jvm对old和perm generation 回收后还不能获足够内存的情况.
当一个URL被访问时，内存申请过程如下：
A. JVM会试图为相关Java对象在Eden中初始化一块内存区域
B. 当Eden空间足够时，内存申请结束。否则到下一步
C. JVM试图释放在Eden中所有不活跃的对象（这属于1或更高级的垃圾回收）, 释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区
D. Survivor区被用来作为Eden及OLD的中间交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区
E. 当OLD区空间不够时，JVM会在OLD区进行完全的垃圾收集（0级）
F. 完全垃圾收集后，若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现”outof memory错误”
造成full gc的原因:
new了很多对象,没有即时在主动释放掉->Eden内存不够用->不断把对象往old迁移->old满了->full gc
fullgc 如何预防,:
1,使用了缓存
访问有两种,第一种是缓存命中率不高的访问,第二种种是缓存命中率很高的访问.对于第一种情况,就没必要缓存了,缓存反而效果不好,浪费内存,没有提升程序效率还浪费空间,特别是如果这种访问量级别很大的时候还会导致full gc.第二种情况,不得不缓存很多对象,不缓存的话就要调用数据库或者其它是要发生io的,所以这时候要不就是想办法减少缓存对象的大小,例如不缓存没必要缓存的数据,或者合并一些数据减少内存的使用.如果还是不行那就加机器,加内存.
总结:在不影响功能的情况下,缓存对象越小越要,命中率越高越好.低命中率的缓存对象还不如不缓存.
2,没使用缓存的情况,貌似不会出现fullgc的情况,除非内存太小,或者设置不对,程序有漏洞.
37. jvm性能调优都做了什么
参考：http://blog.csdn.net/chen77716/article/details/5695893
JVM性能调优有很多设置,这个参考JVM参数即可.
主要调优的目的:
控制GC的行为.GC是一个后台处理,但是它也是会消耗系统性能的,因此经常会根据系统运行的程序的特性来更改GC行为
控制JVM堆栈大小.一般来说,JVM在内存分配上不需要你修改,(举例)但是当你的程序新生代对象在某个时间段产生的比较多的时候,就需要控制新生代的堆大小.同时,还要需要控制总的JVM大小避免内存溢出
控制JVM线程的内存分配.如果是多线程程序,产生线程和线程运行所消耗的内存也是可以控制的,需要通过一定时间的观测后,配置最优结果
38. 介绍JVM中7个区域，然后把每个区域可能造成内存的溢出的情况说明
参考：http://www.codeceo.com/article/jvm-memory-overflow.html
39. 介绍GC 和GCRoot不正常引用。
参考：http://blog.csdn.net/fenglibing/article/details/8928927
40. 自己从classload 加载方式，加载机制说开去，从程序运行时数据区，讲到内存分配，讲到String常量池，讲到JVM垃圾回收机制，算法，hotspot。反正就是各种扩展
类加载机制：http://developer.51cto.com/art/201103/249613.htm
程序运行数据区：http://www.cnblogs.com/lrh-xl/p/5277585.html
内存分配： http://javawebsoa.iteye.com/blog/1558776
string常量池：http://developer.51cto.com/art/201106/266454.htm
hotspot :http://blog.csdn.net/jewes/article/details/42174893
41. jvm 如何分配直接内存， new 对象如何不分配在堆而是栈上，常量池解析
http://blog.chinaunix.net/uid-21880738-id-1813104.html
42. 数组多大放在 JVM 老年代（不只是设置 PretenureSizeThreshold ，问通常多大，没做过一问便知）
参考：http://book.2cto.com/201306/25496.html
43. 老年代中数组的访问方式
参考：http://book.51cto.com/art/201107/278927.htm
44. GC 算法，永久代对象如何 GC ， GC 有环怎么处理
针对HotSpot VM的实现，它里面的GC其实准确分类只有两大种：
PartialGC：并不收集整个GC堆的模式
YoungGC：只收集younggen的GC
OldGC：只收集oldgen的GC。只有CMS的concurrentcollection是这个模式
MixedGC：收集整个younggen以及部分oldgen的GC。只有G1有这个模式
FullGC：收集整个堆，包括younggen、old gen、perm gen（如果存在的话）等所有部分的模式。
MajorGC通常是跟fullGC是等价的，收集整个GC堆。但因为HotSpotVM发展了这么多年，外界对各种名词的解读已经完全混乱了，当有人说“major GC”的时候一定要问清楚他想要指的是上面的full GC还是old gen。
最简单的分代式GC策略，按HotSpot VM的serial GC的实现来看，触发条件是：
youngGC：当young gen中的eden区分配满的时候触发。注意youngGC中有部分存活对象会晋升到oldgen，所以youngGC后old gen的占用量通常会有所升高。
fullGC：当准备要触发一次youngGC时，如果发现统计数据说之前youngGC的平均晋升大小比目前oldgen剩余的空间大，则不会触发youngGC而是转为触发fullGC（因为HotSpotVM的GC里，除了CMS的concurrentcollection之外，其它能收集old gen的GC都会同时收集整个GC堆，包括young gen，所以不需要事先触发一次单独的young GC）；或者，如果有perm gen的话，要在perm gen分配空间但已经没有足够空间时，也要触发一次full GC；或者System.gc()、heap dump带GC，默认也是触发full GC。
HotSpotVM里其它非并发GC的触发条件复杂一些，不过大致的原理与上面说的其实一样。
当然也总有例外。Parallel Scavenge（-XX:+UseParallelGC）框架下，默认是在要触发fullGC前先执行一次youngGC，并且两次GC之间能让应用程序稍微运行一小下，以期降低full GC的暂停时间（因为young GC会尽量清理了young gen的死对象，减少了full GC的工作量）。这是HotSpot VM里的奇葩嗯。
并发GC的触发条件就不太一样。以CMS GC为例，它主要是定时去检查old gen的使用量，当使用量超过了触发比例就会启动一次CMS GC，对old gen做并发收集。（RednaxelaFX——知乎）
Java的GC原理不是引用计数，所以即使有环，只要他是从GC Root不可达的，同样也会被收集。
45. 谁会被 GC ，什么时候 GC
程序认为的死去的对象，也就是不可达对象会被GC。
46. 如果想不被 GC 怎么办
不被GC，创建对象的强引用，并一直不释放
47. 如果想在 GC 中生存 1 次怎么办
生存一次，释放掉对象的引用，但是在对象的finalize方法中重新建立引用，但是有一此方法只会被调用一次，所以能在GC中生存一次
48. hibernate和ibatis的区别
hibernate是当前最流行的o/rmapping框架，它出身于sf.net，现在已经成为jboss的一部分了。
ibatis是另外一种优秀的o/rmapping框架，目前属于apache的一个子项目了。
相对hibernate“o/r”而言，ibatis是一种“sql mapping”的orm实现。
hibernate对数据库结构提供了较为完整的封装，hibernate的o/r mapping实现了pojo 和数据库表之间的映射，以及sql 的自动生成和执行。程序员往往只需定义好了pojo 到数据库表的映射关系，即可通过hibernate 提供的方法完成持久层操作。程序员甚至不需要对sql 的熟练掌握， hibernate/ojb 会根据制定的存储逻辑，自动生成对应的sql 并调用jdbc 接口加以执行。
而ibatis 的着力点，则在于pojo 与sql之间的映射关系。也就是说，ibatis并不会为程序员在运行期自动生成sql 执行。具体的sql 需要程序员编写，然后通过映射配置文件，将sql所需的参数，以及返回的结果字段映射到指定pojo。
使用ibatis 提供的orm机制，对业务逻辑实现人员而言，面对的是纯粹的java对象。
这一层与通过hibernate 实现orm 而言基本一致，而对于具体的数据操作，hibernate会自动生成sql 语句，而ibatis 则要求开发者编写具体的sql 语句。相对hibernate而言，ibatis 以sql开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。
hibernate与ibatis的对比：
1．ibatis非常简单易学，hibernate相对较复杂，门槛较高。
2．二者都是比较优秀的开源产品
3．当系统属于二次开发,无法对数据库结构做到控制和修改,那ibatis的灵活性将比hibernate更适合
4．系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的sql语句（或存储过程）才能达到系统性能设计指标。在这种情况下ibatis会有更好的可控性和表现。
5．ibatis需要手写sql语句，也可以生成一部分，hibernate则基本上可以自动生成，偶尔会写一些hql。同样的需求,ibatis的工作量比hibernate要大很多。类似的，如果涉及到数据库字段的修改，hibernate修改的地方很少，而ibatis要把那些sql mapping的地方一一修改。
6．以数据库字段一一对应映射得到的po和hibernte这种对象化映射得到的po是截然不同的，本质区别在于这种po是扁平化的，不像hibernate映射的po是可以表达立体的对象继承，聚合等等关系的，这将会直接影响到你的整个软件系统的设计思路。
7．hibernate现在已经是主流o/rmapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于ibatis。
49. 讲讲mybatis的连接池。
参考：http://www.tuicool.com/articles/RvqEjeR
50. spring框架中需要引用哪些jar包，以及这些jar包的用途
参考： http://www.cnblogs.com/BensonHe/p/3903050.html
org.springframework.aop-3.0.6.RELEASE |
Spring的面向切面编程,提供AOP(面向切面编程)实现 |
org.springframework.asm- 3.0.6.RELEASE |
Spring独立的asm程序,Spring2.5.6的时候需要asmJar 包3.0.6开始提供他自己独立的asmJar |
org.springframework.aspects- 3.0.6.RELEASE |
Spring提供对AspectJ框架的整合 |
org.springframework.beans-3.0.6.RELEASE |
SpringIoC(依赖注入)的基础实现 |
org.springframework.context.support-3.0.6.RELEASE |
Spring-context的扩展支持,用于MVC方面 |
org.springframework.context-3.0.6.RELEASE |
Spring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的支持，如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以及各种视图层框架的封装等 |
org.springframework.core-3.0.6.RELEASE |
Spring3.0.6的核心工具包 |
org.springframework.expression-3.0.6.RELEASE |
Spring表达式语言 |
org.springframework.instrument.tomcat-3.0.6.RELEASE |
Spring3.0.6对Tomcat的连接池的集成 |
org.springframework.instrument-3.0.6.RELEASE |
Spring3.0.6对服务器的代理接口 |
org.springframework.jdbc-3.0.6.RELEASE |
对JDBC的简单封装 |
org.springframework.jms-3.0.6.RELEASE |
为简化JMS API的使用而作的简单封装 |
org.springframework.orm-3.0.6.RELEASE |
整合第三方的ORM框架，如hibernate,ibatis,jdo，以及 spring的JPA实现 |
org.springframework.oxm-3.0.6.RELEASE |
Spring 对Object/XMl的映射支持,可以让Java与XML之间来回切换 |
org.springframework.test-3.0.6.RELEASE |
对Junit等测试框架的简单封装 |
org.springframework.transaction-3.0.6.RELEASE |
为JDBC、Hibernate、JDO、JPA等提供的一致的声明式和编程式事务管理 |
org.springframework.web.portlet-3.0.6.RELEASE |
基于protlet的MVC实现 |
org.springframework.web.servlet-3.0.6.RELEASE |
基于servlet的MVC实现 |
org.springframework.web.struts-3.0.6.RELEASE |
整合Struts的时候的支持 |
org.springframework.web-3.0.6.RELEASE |
SpringWeb下的工具包 |
做Spring还必须依赖第三方包：
① Spring 工程依赖的公共包
commons-logging-1[1].0.4.jar（只要是做Spring都需要这个包，否则工程起不来）
②使用SpringAOP功能时依赖的包
aspectjweaver-1[1].5.3.jar
aopalliance-1.0.jar (下载：http://mirrors.ibiblio.org/maven2/aopalliance/aopalliance/1.0/)
③使用SpringJDBC功能时依赖的包
commons-dbcp.jar (下载：http://commons.apache.org/dbcp/download_dbcp.cgi)
commons-pool.jar (下载：http://mirrors.ibiblio.org/maven2/commons-pool/commons-pool/)
commons-collections-2.1.1.jar
51. springMVC的原理
参考：http://blog.sina.com.cn/s/blog_7ef0a3fb0101po57.html
答：1. 客户端请求提交到DispatcherServlet
2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller
3.DispatcherServlet将请求提交到Controller
4. Controller调用业务逻辑处理后，返回ModelAndView
5.DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
6. 视图负责将结果显示到客户端
52. springMVC注解的意思
参考： http://aijuans.iteye.com/blog/2160141
答：@Controller
@Controller 负责注册一个bean 到spring 上下文中，bean 的ID 默认为
类名称开头字母小写,你也可以自己指定，如下
方法一：
@Controller
public class TestController {}
方法二：
@Controller("tmpController")
public class TestController {}
@RequestMapping
1.@RequestMapping用来定义访问的URL，你可以为整个类定义一个
@RequestMapping，或者为每个方法指定一个。
把@RequestMapping放在类级别上，这可令它与方法级别上的
@RequestMapping注解协同工作，取得缩小选择范围的效果。
例如：
@RequestMapping("/test")
public class TestController {}
则，该类下的所有访问路径都在/test之下。
2.将@RequestMapping用于整个类不是必须的，如果没有配置，所有的方法
的访问路径配置将是完全独立的，没有任何关联。
3.完整的参数项为：@RequestMapping(value="",method=
{"",""},headers={},params={"",""})，各参数说明如下：
value :String[] 设置访问地址
method: RequestMethod[]设置访问方式，字符数组，查看RequestMethod
类，包括GET,HEAD, POST, PUT, DELETE, OPTIONS, TRACE,常用
RequestMethod.GET，RequestMethod.POST
headers:String[] headers一般结合method = RequestMethod.POST使用
params: String[] 访问参数设置，字符数组 例如：userId=id
4.value的配置还可以采用模版变量的形式 ，例如：@RequestMapping
(value="/owners/{ownerId}", method=RequestMethod.GET)，这点将在介
绍@PathVariable中详细说明。
5.@RequestMapping params的补充说明，你可以通过设置参数条件来限制
访问地址，例如params="myParam=myValue"表达式，访问地址中参数只有
包含了该规定的值"myParam=myValue"才能匹配得上，类似"myParam"之类
的表达式也是支持的，表示当前请求的地址必须有该参数(参数的值可以是
任意)，"!myParam"之类的表达式表明当前请求的地址不能包含具体指定的
参数"myParam"。
6.有一点需要注意的，如果为类定义了访问地址为*.do,*.html之类的，则
在方法级的@RequestMapping，不能再定义value值，否则会报错，例如
Java代码
@RequestMapping("/bbs.do")
public class BbsController {
@RequestMapping(params ="method=getList")
public String getList() {
return "list";
}
@RequestMapping(value= "/spList")
public String getSpecialList() {
return "splist";
}
}
如上例：/bbs.do?method=getList可以访问到方法getList()；而访
问/bbs.do/spList则会报错.
@PathVariable
1.@PathVariable用于方法中的参数，表示方法参数绑定到地址URL的模板
变量。
例如：
Java代码
@RequestMapping(value="/owners/{ownerId}",
method=RequestMethod.GET)
public String findOwner(@PathVariable String ownerId, Model
model) {
Owner owner = ownerService.findOwner(ownerId);
model.addAttribute("owner", owner);
return "displayOwner";
}
2.@PathVariable用于地址栏使用{xxx}模版变量时使用。
如果@RequestMapping没有定义类似"/{ownerId}"，这种变量，则使用在
方法中@PathVariable会报错。
@ModelAttribute
1.应用于方法参数,参数可以在页面直接获取，相当于
request.setAttribute(,)
2.应用于方法,将任何一个拥有返回值的方法标注上@ModelAttribute，使
其返回值将会进入到模型对象的属性列表中.
3.应用于方法参数时@ModelAttribute("xx"),须关联到Object的数据类型
，基本数据类型 如：int,String不起作用
例如：
Java代码
@ModelAttribute("items")//<——①向模型对象中添加一个名为items的
属性
public List
List
lists.add("item1");
lists.add("item2");
return lists;
}
@RequestMapping(params = "method=listAllBoard")
public String listAllBoard(@ModelAttribute("currUser")Useruser,
ModelMap model) {
bbtForumService.getAllBoard();
//<——②在此访问模型中的items属性
System.out.println("model.items:" + ((List
model.get("items")).size());
return"listBoard";
}
在 ① 处，通过使用@ModelAttribute 注解，populateItem() 方法将在
任何请求处理方法执行前调用，SpringMVC 会将该方法返回值以“items
”为名放入到隐含的模型对象属性列表中。
所以在 ② 处，我们就可以通过ModelMap 入参访问到 items 属性，当执
行listAllBoard() 请求处理方法时，② 处将在控制台打印
出“model.items:2”的信息。当然我们也可以在请求的视图中访问到模型
对象中的items 属性。
@ResponseBody
这个注解可以直接放在方法上，表示返回类型将会直接作为HTTP响应字节
流输出(不被放置在Model，也不被拦截为视图页面名称)。可以用于ajax。
@RequestParam
@RequestParam是一个可选参数，例如：@RequestParam("id") 注解，所以
它将和URL所带参数 id进行绑定
如果入参是基本数据类型（如 int、long、float 等），URL 请求参数中
一定要有对应的参数，否则将抛出
org.springframework.web.util.NestedServletException 异常，提示无
法将 null 转换为基本数据类型.
@RequestParam包含3个配置 @RequestParam(required =,value="",
defaultValue = "")
required :参数是否必须，boolean类型,可选项，默认为true
value: 传递的参数名称，String类型,可选项，如果有值，对应到设置方
法的参数
defaultValue:String类型,参数没有传递时为参数默认指定的值
@SessionAttributes session管理
Spring 允许我们有选择地指定ModelMap 中的哪些属性需要转存到
session 中，以便下一个请求属对应的 ModelMap 的属性列表中还能访问
到这些属性。这一功能是通过类定义处标注 @SessionAttributes 注解来
实现的。@SessionAttributes只能声明在类上，而不能声明在方法上。
例如
@SessionAttributes("currUser") // 将ModelMap 中属性名为currUser 的属性
@SessionAttributes({"attr1","attr2"})
@SessionAttributes(types = User.class)
@SessionAttributes(types = {User.class,Dept.class})
@SessionAttributes(types ={User.class,Dept.class},value={"attr1","attr2"})
@CookieValue 获取cookie信息
@RequestHeader 获取请求的头部信息
53. spring中beanFactory和ApplicationContext的联系和区别
答：1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：
a. 国际化支持
b. 资源访问：Resourcers = ctx. getResource(“classpath:config.properties”),“file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件
WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现
54. spring注入的几种方式（循环注入）
参考：http://developer.51cto.com/art/201207/348019.htm
答：1. 接口注入（不推荐）
2. getter，setter方式注入（比较常用）
3. 构造器注入（死的应用）
55. spring如何实现事物管理的
参考： http://michael-softtech.iteye.com/blog/813835
答：Spring+Hibernate的实质：
就是把Hibernate用到的数据源Datasource，Hibernate的SessionFactory实例，事务管理器HibernateTransactionManager，都交给Spring管理。
那么再没整合之前Hibernate是如何实现事务管理的呢？
通过ServletFilter实现数据库事务的管理，这样就避免了在数据库操作中每次都要进行数据库事务处理。
一.事务的4个特性：
原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。
一致性：数据不会因为事务的执行而遭到破坏。
隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。
持久性：一个事务一旦提交，它对数据库的改变将是永久的。
二.事务的实现方式：
实现方式共有两种：编码方式；声明式事务管理方式。
基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。
声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。
三.创建事务的时机：
是否需要创建事务，是由事务传播行为控制的。读数据不需要或只为其指定只读事务，而数据的插入，修改，删除就需要事务管理了。
一种常见的事务管理配置：事务拦截器TransactionInterceptor和事务自动代理BeanNameAutoProxyCreator相结合的方式
尤其注意：如下
***********************************************************************************************************
【以上的事务拦截器和事务自动代理方式实现原理：像Struts2一样，都是凭借强大的拦截器功能对业务逻辑方法的调用进行拦截，然后又BeanNameAutoProxyCreator自动生成事务代理，最后送事务管理器，统一管理】
***********************************************************************************************************
56.springIOC
参考： http://blog.csdn.net/it_man/article/details/4402245
57.spring AOP的原理
参考：http://blog.csdn.net/moreevan/article/details/11977115
答：下面为spring的主要原理：
IoC(Inversionof Control)：IoC就是应用本身不依赖对象的创建和维护而是交给外部容器(这里为spring),这要就把应用和对象之间解耦,控制权交给了外部容器。即Don't call me ,I'll call you！所以IoC也称DI(依赖注入)对象的创建和维护依赖于外部容器.
classUserService{
privateUserDao userDao = new UserDaoImpl(); //让业务层与数据访问层耦合在一起,不利用以后模块的替换.
privateUserDao userDao_IoC = null;
publicvoid SetUserDao(UserDao userDao){
this.userDao_IoC= userDao
}
publicvoid save(User user){
userDao.save(user);
}
}
AOP(AspectOriented Programming)：面向切面编程。就是把一些贯穿在各个模块之间相同的功能抽象出来,然后封装成一个面。
AOP一般都是通过代理来实现,利用代理就有目标对象是什么,拦截哪些点(方法),拦截后要做什么。
JoinPoint(连接点)：被拦截到的点.Advice(通知):拦截JoinPoint之前与之后要做的事。
PointCut(切入点):对joinPoint进行拦截的定义。Target(目标对象)：代理的目标对象。
对于异常处理,日志功能,权限的检查,事务等都是贯穿到各个模块之中,因此进行AOP.
代理技术有面向接口和生成子类.
publicObject getProxy(final Object targetObj) {
Obejctobj = Proxy.newProxyInstance(
targetObj.getClass().getClassLoader(), //被代理类的类加载器
targetObj.getClass().getInterfaces(), //被代理类接口的字节码
newInvocationHandler() { //类似于一个回调函数代理功能就在里面实现
@Override
publicObject invoke(Object proxy, Method method, Object[] args) throws Throwable{
try{
beforeAdvice(); //前置通知
method.invoke(targetObj,args); //拦截的点
afterAdvice(); //后置通知
}catch(Exception e) {
exceptionAdvice(); //异常通知
}finally{
finalAdvice(); //必须执行通知
}
returnobj;
}
});
}
还一个用子类实现的同理要采用CGlib库来实现 JDK6之前未提供,估计JDK以后会提供。
这就是spring的2大原理,自如怎么配置,那就要花点时间去学,原理思想掌握了哪些配置方法随便学下就明白了。
58. hibernate中的1级和2级缓存的使用方式以及区别原理
参考： http://www.jb51.net/article/75161.htm
（Lazy-Load的理解）
答：缓存是介于应用程序和物理数据源之间，其作用是为了降低应用程序对物理数据源访问的频次，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。
缓存的介质一般是内存，所以读写速度很快。但如果缓存中存放的数据量非常大时，也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质，还要考虑到管理缓存的并发访问和缓存数据的生命周期。
Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。SessionFactory的内置缓存和Session的缓存在实现方式上比较相似，前者是SessionFactory对象的一些集合属性包含的数据，后者是指Session的一些集合属性包含的数据。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的拷贝，外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。
Hibernate的这两级缓存都位于持久化层，存放的都是数据库数据的拷贝，那么它们之间的区别是什么呢？为了理解二者的区别，需要深入理解持久化层的缓存的两个特性：缓存的范围和缓存的并发访问策略。
持久化层的缓存的范围
缓存的范围决定了缓存的生命周期以及可以被谁访问。缓存的范围分为三类。
1 事务范围：缓存只能被当前事务访问。缓存的生命周期依赖于事务的生命周期，当事务结束时，缓存也就结束生命周期。在此范围下，缓存的介质是内存。事务可以是数据库事务或者应用事务，每个事务都有独自的缓存，缓存内的数据通常采用相互关联的的对象形式。
2 进程范围：缓存被进程内的所有事务共享。这些事务有可能是并发访问缓存，因此必须对缓存采取必要的事务隔离机制。缓存的生命周期依赖于进程的生命周期，进程结束时，缓存也就结束了生命周期。进程范围的缓存可能会存放大量的数据，所以存放的介质可以是内存或硬盘。缓存内的数据既可以是相互关联的对象形式也可以是对象的松散数据形式。松散的对象数据形式有点类似于对象的序列化数据，但是对象分解为松散的算法比对象序列化的算法要求更快。
3 集群范围：在集群环境中，缓存被一个机器或者多个机器的进程共享。缓存中的数据被复制到集群环境中的每个进程节点，进程间通过远程通信来保证缓存中的数据的一致性，缓存中的数据通常采用对象的松散数据形式。
对大多数应用来说，应该慎重地考虑是否需要使用集群范围的缓存，因为访问的速度不一定会比直接访问数据库数据的速度快多少。
持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据，还可以到进程范围或集群范围的缓存内查询，如果还是没有查到，那么只有到数据库中查询。事务范围的缓存是持久化层的第一级缓存，通常它是必需的；进程范围或集群范围的缓存是持久化层的第二级缓存，通常是可选的。
持久化层的缓存的并发访问策略
当多个并发的事务同时访问持久化层的缓存的相同数据时，会引起并发问题，必须采用必要的事务隔离措施。
在进程范围或集群范围的缓存，即第二级缓存，会出现并发问题。因此可以设定以下四种类型的并发访问策略，每一种策略对应一种事务隔离级别。
事务型：仅仅在受管理环境中适用。它提供了Repeatable Read事务隔离级别。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读和不可重复读这类的并发问题。
读写型：提供了Read Committed事务隔离级别。仅仅在非集群的环境中适用。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读这类的并发问题。
非严格读写型：不保证缓存与数据库中数据的一致性。如果存在两个事务同时访问缓存中相同数据的可能，必须为该数据配置一个很短的数据过期时间，从而尽量避免脏读。对于极少被修改，并且允许偶尔脏读的数据，可以采用这种并发访问策略。 只读型：对于从来不会修改的数据，如参考数据，可以使用这种并发访问策略。
事务型并发访问策略是事务隔离级别最高，只读型的隔离级别最低。事务隔离级别越高，并发性能就越低。
什么样的数据适合存放到第二级缓存中？
1、很少被修改的数据
2、不是很重要的数据，允许出现偶尔并发的数据
3、不会被并发访问的数据
4、参考数据
不适合存放到第二级缓存的数据？
1、经常被修改的数据
2、财务数据，绝对不允许出现并发
3、与其他应用共享的数据。
Hibernate的二级缓存
如前所述，Hibernate提供了两级缓存，第一级是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。第一级缓存是必需的，不允许而且事实上也无法比卸除。在第一级缓存中，持久化类的每个实例都具有唯一的OID。
第二级缓存是一个可插拔的的缓存插件，它是由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此第二级缓存是进程范围或者集群范围的缓存。这个缓存中存放的对象的松散数据。第二级对象有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。缓存适配器用于把具体的缓存实现软件与Hibernate集成。第二级缓存是可选的，可以在每个类或每个集合的粒度上配置第二级缓存。
Hibernate的二级缓存策略的一般过程如下：
1) 条件查询的时候，总是发出一条select *from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。
2) 把获得的所有数据对象根据ID放入到第二级缓存中。
3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。
4) 删除、更新、增加数据的时候，同时更新缓存。
Hibernate的二级缓存策略，是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，Hibernate提供了针对条件查询的Query缓存。
Hibernate的Query缓存策略的过程如下：
1) Hibernate首先根据这些信息组成一个Query Key，QueryKey包括条件查询的请求一般信息：SQL, SQL需要的参数，记录范围（起始位置rowStart，最大记录个数maxRows)，等。
2) Hibernate根据这个Query Key到Query缓存中查找对应的结果列表。如果存在，那么返回这个结果列表；如果不存在，查询数据库，获取结果列表，把整个结果列表根据Query Key放入到Query缓存中。
3) Query Key中的SQL涉及到一些表名，如果这些表的任何数据发生修改、删除、增加等操作，这些相关的Query Key都要从缓存中清空。
59. Hibernate的原理体系架构，五大核心接口，Hibernate对象的三种状态转换，事务管理。
参考： http://www.cnblogs.com/shysunlove/archive/2012/11/21/2780240.html
60. Java创建线程之后，直接调用start()方法和run()的区别
参考： http://www.tuicool.com/articles/7nyEziU
61. 常用的线程池模式以及不同线程池的使用场景
参考： http://www.cnblogs.com/dolphin0520/p/3932921.html
62. newFixedThreadPool此种线程池如果线程数达到最大值后会怎么办，底层原理。
参考： http://www.oschina.net/question/565065_86540
63. 多线程之间通信的同步问题，synchronized锁的是对象，衍伸出和synchronized相关很多的具体问题，例如同一个类不同方法都有synchronized锁，一个对象是否可以同时访问。或者一个类的static构造方法加上synchronized之后的锁的影响。
参考： http://www.cnblogs.com/shipengzhi/articles/2223100.html
64. 了解可重入锁的含义，以及ReentrantLock 和synchronized的区别
http://outofmemory.cn/java/java.util.concurrent/synchronized-locks-Lock-ReentrantLock
65. 同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为什么他是同步的且效率高
参考： http://www.cnblogs.com/ITtangtang/p/3948786.html
66. atomicinteger和Volatile等线程安全操作的关键字的理解和使用
参考： http://www.cnblogs.com/dolphin0520/p/3920373.html
67. 线程间通信，wait和notify
参考： http://www.jb51.net/article/40746.htm
68. 定时线程的使用
参考： http://www.2cto.com/kf/201502/376021.html
69. 场景：在一个主线程中，要求有大量(很多很多)子线程执行完之后，主线程才执行完成。多种方式，考虑效率。
参考： http://www.tuicool.com/articles/ZvAFny
70. 进程和线程的区别
参考： http://www.cnblogs.com/way_testlife/archive/2011/04/16/2018312.html
71. 什么叫线程安全？举例说明
1. 线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题
72. 线程的几种状态
参考： http://lavasoft.blog.51cto.com/62575/99153/
73. 并发、同步的接口或方法
参考： http://blog.csdn.net/woshisap/article/details/43119569
1：线程池
与每次需要时都创建线程相比，线程池可以降低创建线程的开销，这也是因为线程池在线程执行结束后进行的是回收操作，而不是真正的
销毁线程。
2：ReentrantLock
ReentrantLock提供了tryLock方法，tryLock调用的时候，如果锁被其他线程持有，那么tryLock会立即返回，返回结果为false，如果锁没有被
其他线程持有，那么当前调用线程会持有锁，并且tryLock返回的结果是true,
lock.lock();
try {
//do something
} finally {
lock.unlock();
}
3：volatile
保证了同一个变量在多线程中的可见性，所以它更多是用于修饰作为开关状态的变量，因为volatile保证了只有一份主存中的数据。
4：Atomics
public class Count {
private AtomicInteger counter = newAtomicInteger();
public int increase() {
returncounter.incrementAndGet();
}
public int decrease() {
returncounter.decrementAndGet();
}
}
AtomicInteger内部通过JNI的方式使用了硬件支持的CAS指令。
5：CountDownLatch
它是java.util.concurrent包中的一个类，它主要提供的机制是当多个(具体数量等于初始化CountDown时的count参数的值)线程都到达了预期状态
或完成预期工作时触发事件，其他线程可以等待这个事件来出发自己后续的工作，等待的线程可以是多个，即CountDownLatch是可以唤醒多个等待
的线程的，到达自己预期状态的线程会调用CountDownLatch的countDown方法，而等待的线程会调用CountDownLatch的await方法
6：CyclicBarrier
循环屏障，CyclicBarrier可以协同多个线程，让多个线程在这个屏障前等待，直到所有线程都到达了这个屏障时，再一起继续执行后面的动作。
CyclicBarrier和CountDownLatch都是用于多个线程间的协调的，二者的一个很大的差别是，CountDownLatch是在多个线程都进行了latch.countDown
后才会触发事件，唤醒await在latch上的线程，而执行countDown的线程，执行完countDown后，会继续自己线程的工作；
CyclicBarrier是一个栅栏，用于同步所有调用await方法的线程，并且等所有线程都到了await方法，这些线程才一起返回继续各自的工作，因为使用CyclicBarrier的线程都会阻塞在await方法上，所以在线程池中使用CyclicBarrier时要特别小心，如果线程池的线程 数过少，那么就会发生死锁了,
CyclicBarrier可以循环使用，CountDownLatch不能循环使用。
7：Semaphore
是用于管理信号量的，构造的时候传入可供管理的信号量的数值，信号量对量管理的信号就像令牌，构造时传入个数，总数就是控制并发的数量。
semaphore.acquire();
try {
//调用远程通信的方法
} finally () {
semahore.release();
}
8：Exchanger
Exchanger，从名字上讲就是交换，它用于在两个线程之间进行数据交换，线程会阻塞在Exchanger的exchange方法上，直到另一个线程也到了
同一个Exchanger的exchange方法时，二者进行交换，然后两个线程会继续执行自身相关的代码。
9：Future和FutureTask
Future
//do something
HashMap data = (HashMap)future.get();
private Future
return threadPool.submit(newCallable
public HashMap call() {
returngetDataFromRemote();
}
});
}
思路：调用函数后马上返回，然后继续向下执行，急需要数据时再来用，或者说再来等待这个数据，具体实现方式有两种，一个是用Future，另一个使用回调。
74. HashMap 是否线程安全，为何不安全。 ConcurrentHashMap，线程安全，为何安全。底层实现是怎么样的。
参考： http://blog.csdn.net/xuefeng0707/article/details/40834595
75. J.U.C下的常见类的使用。 ThreadPool的深入考察； BlockingQueue的使用。（take，poll的区别，put，offer的区别）；原子类的实现。
参考 ： http://wsmajunfeng.iteye.com/blog/1629354 http://ifeve.com/j-u-c-framework/
76. 简单介绍下多线程的情况，从建立一个线程开始。然后怎么控制同步过程，多线程常用的方法和结构
参考： http://www.jb51.net/article/36553.htm
77. volatile的理解
参考： http://www.infoq.com/cn/articles/java-memory-model-4/
78. 实现多线程有几种方式，多线程同步怎么做，说说几个线程里常用的方法
参考： http://www.jb51.net/article/43417.htm
http://www.cnblogs.com/psjay/archive/2010/04/01/1702465.html
http://blog.csdn.net/you_off3/article/details/7572704
79. http是无状态通信，http的请求方式有哪些，可以自己定义新的请求方式么。
参考： http://www.cnblogs.com/yin-jingyu/archive/2011/08/01/2123548.html
答：HTTP/1.1规定的 HTTP 请求方法有8种CONNECT 、OPTIONS、PUT、DELETE、TRACE、
GET、
HEAD、
POST：包含了 Content-Type 和消息主体编码方式两部分
application/x-www-form-urlencoded
最常见的 POST 提交数据的方式了。浏览器的原生 form 表单，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-
urlencoded 方式提交数据
multipart/form-data
使用表单上传文件时，必须让 form 的 enctyped 等于这个值
自己定义新的数据提交方式：
application/json
现在越来越多的人把它作为请求头，用来告诉服务端消息主体是序列化后的 JSON 字符串。由于 JSON 规范的流行，除了低版本 IE 之外的
各大浏览器都原生支持 JSON.stringify，服务端语言也都有处理 JSON 的函数，使用 JSON 不会遇上什么麻烦。
http中，Get和Post的区别
GET 被强制服务器支持
浏览器对URL的长度有限制，所以GET请求不能代替POST请求发送大量数据
GET请求发送数据更小
GET请求是安全的， 这里的安全指的是在规范的定义下，Get操作不会修改服务器的数据
GET请求是幂等的
POST请求不能被缓存
POST请求相对GET请求是「安全」的，这里所有的「安全」是相对的，因为GET请求有时候会直接反应在浏览器的地址栏，而现在的浏览器大多会记住曾经输入过的URL
80. socket通信，以及长连接，分包，连接异常断开的处理。
参考： http://developer.51cto.com/art/201202/318163.htm
81.socket通信模型的使用，AIO和NIO。
参考：AIO：http://www.52im.net/thread-306-1-1.html
NIO：http://www.cnblogs.com/dolphin0520/p/3916526.html
82. socket框架netty的使用，以及NIO的实现原理，为什么是异步非阻塞。
参考：http://www.importnew.com/15656.html
NIO：http://www.cnblogs.com/dolphin0520/p/3916526.html
83. 同步和异步，阻塞和非阻塞。
参考：http://blog.csdn.net/hguisu/article/details/7453390
84. OSI七层模型，包括TCP,IP的一些基本知识
参考：http://www.2cto.com/net/201307/232200.html
http://blog.csdn.net/ysdaniel/article/details/6636641
85. http中，get post的区别
参考：http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html
86. 说说http,tcp,udp之间关系和区别。
参考：http://www.javalm.com/thread-2259-1-1.html
87. 说说浏览器访问www.taobao.com，经历了怎样的过程。
参考：http://blog.csdn.net/a2796749/article/details/48032341
88. HTTP协议、 HTTPS协议，SSL协议及完整交互过程；
参考：http://blog.csdn.net/dfsaggsd/article/details/50910999
89. tcp的拥塞，快回传，ip的报文丢弃
参考：http://www.cnblogs.com/newwy/p/3254029.html
90. https处理的一个过程，对称加密和非对称加密
参考：http://my.oschina.net/shede333/blog/359290
91. head各个特点和区别
参考：http://www.cnblogs.com/wangwanchao/p/5267164.html
92. 说说浏览器访问www.taobao.com，经历了怎样的过程。
93. MySQL的存储引擎的不同
参考：http://c.biancheng.net/cpp/html/1465.html
答：这个是考虑性能的问题，还有事务的支持，吧百度一下你就知道MyISAM、InnoDB、Heap(Memory)、NDB 貌似一般都是使用 InnoDB的， mysql的存储引擎包括：MyISAM、InnoDB、BDB、MEMORY、MERGE、EXAMPLE、NDBCluster、ARCHIVE、CSV、BLACKHOLE、FEDERATED等，其中InnoDB和BDB提供事务安全表，其他存储引擎都是非事务安全表。最常使用的2种存储引擎:1.Myisam是Mysql的默认存储引擎，当create创建新表时，未指定新表的存储引擎时，默认使用Myisam。每个MyISAM在磁盘上存储成三个文件。文件名都和表名相同，扩展名分别是.frm（存储表定义）、.MYD(MYData，存储数据)、.MYI(MYIndex，存储索引)。数据文件和索引文件可以放置在不同的目录，平均分布io，获得更快的速度。 2.InnoDB存储引擎提供了具有提交、回滚和崩溃恢复能力的事务安全。但是对比Myisam的存储引擎，InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引。
94. 单个索引、联合索引、主键索引
参考：http://blog.csdn.net/u011341352/article/details/47731255
答：Mysql索引概念：
说说Mysql索引，看到一个很少比如：索引就好比一本书的目录，它会让你更快的找到内容，显然目录（索引）并不是越多越好，假如这本书1000页，有500也是目录，它当然效率低，目录是要占纸张的,而索引是要占磁盘空间的。
Mysql索引主要有两种结构：B+树和hash.
hash:hsah索引在mysql比较少用,他以把数据的索引以hash形式组织起来,因此当查找某一条记录的时候,速度非常快.当时因为是hash结构,每个键只对应一个值,而且是散列的方式分布.所以他并不支持范围查找和排序等功能.
B+树:b+tree是mysql使用最频繁的一个索引数据结构,数据结构以平衡树的形式来组织,因为是树型结构,所以更适合用来处理排序,范围查找等功能.相对hash索引,B+树在查找单条记录的速度虽然比不上hash索引,但是因为更适合排序等操作,所以他更受用户的欢迎.毕竟不可能只对数据库进行单条记录的操作.
Mysql常见索引有：主键索引、唯一索引、普通索引、全文索引、组合索引
PRIMARYKEY（主键索引） ALTERTABLE `table_name` ADD PRIMARY KEY ( `column` ) UNIQUE(唯一索引) ALTER TABLE `table_name` ADD UNIQUE (`column`)
INDEX(普通索引) ALTER TABLE `table_name` ADD INDEXindex_name ( `column` ) FULLTEXT(全文索引) ALTER TABLE `table_name`ADD FULLTEXT ( `column` )
组合索引 ALTER TABLE `table_name` ADD INDEX index_name ( `column1`, `column2`, `column3`)
Mysql各种索引区别：
普通索引：最基本的索引，没有任何限制
唯一索引：与"普通索引"类似，不同的就是：索引列的值必须唯一，但允许有空值。
主键索引：它是一种特殊的唯一索引，不允许有空值。
全文索引：仅可用于MyISAM 表，针对较大的数据，生成全文索引很耗时好空间。
组合索引：为了更多的提高mysql效率可建立组合索引，遵循”最左前缀“原则。
95. Mysql怎么分表，以及分表后如果想按条件分页查询怎么办(如果不是按分表字段来查询的话，几乎效率低下，无解)
1)、做mysql集群，例如：利用mysqlcluster ，mysql proxy，mysql replication，drdb等等
优点：扩展性好，没有多个分表后的复杂操作（php代码）
缺点：单个表的数据量还是没有变，一次操作所花的时间还是那么多，硬件开销大。
2)、预先估计会出现大数据量并且访问频繁的表，将其分为若干个表
优点：避免一张表出现几百万条数据，缩短了一条sql的执行时间
缺点：当一种规则确定时，打破这条规则会很麻烦，上面的例子中我用的hash算法是crc32，如果我现在不想用这个算法了，改用md5后，会使同一个用户的消息被存储到不同的表中，这样数
据乱套了。扩展性很差。
3)、利用merge存储引擎来实现分表
优点：扩展性好，并且程序代码改动的不是很大
缺点：这种方法的效果比第二种要差一点
答：当一张的数据达到几百万时，你查询一次所花的时间会变多，如果有联合查询的话，我想有可能会死在那儿了。分表的目的就在于此，减小数据库的负担，缩短查询时间。
根据个人经验，mysql执行一个sql的过程如下：
1,接收到sql;2,把sql放到排队队列中 ;3,执行sql;4,返回执行结果。在这个执行过程中最花时间在什么地方呢？第一，是排队等待的时间，第二，sql的执行时间。其实这二个是一回事，等待的同时，肯定有sql在执行。所以我们要缩短sql的执行时间。
mysql中有一种机制是表锁定和行锁定，为什么要出现这种机制，是为了保证数据的完整性，我举个例子来说吧，如果有二个sql都要修改同一张表的同一条数据，这个时候怎么办呢，是不是二个sql都可以同时修改这条数据呢？很显然mysql对这种情况的处理是，一种是表锁定（myisam存储引擎），一个是行锁定（innodb存储引擎）。表锁定表示你们都不能对这张表进行操作，必须等我对表操作完才行。行锁定也一样，别的sql必须等我对这条数据操作完了，才能对这条数据进行操作。如果数据太多，一次执行的时间太长，等待的时间就越长，这也是我们为什么要分表的原因。
二，分表
1，做mysql集群，例如：利用mysqlcluster ，mysql proxy，mysql replication，drdb等等
有人会问mysql集群，根分表有什么关系吗？虽然它不是实际意义上的分表，但是它启到了分表的作用，做集群的意义是什么呢？为一个数据库减轻负担，说白了就是减少sql排队队列中的sql的数量，举个例子：有10个sql请求，如果放在一个数据库服务器的排队队列中，他要等很长时间，如果把这10个 sql请求，分配到5个数据库服务器的排队队列中，一个数据库服务器的队列中只有2个，这样等待时间是不是大大的缩短了呢？这已经很明显了。所以我把它列到了分表的范围以内，我做过一些mysql的集群：
linux mysql proxy 的安装，配置，以及读写分离
mysqlreplication 互为主从的安装及配置，以及数据同步
优点：扩展性好，没有多个分表后的复杂操作（PHP代码）
缺点：单个表的数据量还是没有变，一次操作所花的时间还是那么多，硬件开销大。
2，预先估计会出现大数据量并且访问频繁的表，将其分为若干个表
这种预估大差不差的，论坛里面发表帖子的表，时间长了这张表肯定很大，几十万，几百万都有可能。聊天室里面信息表，几十个人在一起一聊一个晚上，时间长了，这张表的数据肯定很大。像这样的情况很多。所以这种能预估出来的大数据量表，我们就事先分出个N个表，这个N是多少，根据实际情况而定。以聊天信息表为例：
我事先建100个这样的表，message_00,message_01,message_02……….message_98,message_99.然后根据用户的ID来判断这个用户的聊天信息放到哪张表里面，你可以用hash的方式来获得，可以用求余的方式来获得，方法很多，各人想各人的吧。下面用 hash的方法来获得表名：
1.
2. function get_hash_table($table,$userid) {
3. $str = crc32($userid);
4. if($str<0){
5. $hash = "0".substr(abs($str), 0, 1);
6. }else{
7. $hash = substr($str, 0, 2);
8. }
9.
10. return $table."_".$hash;
11. }
12.
13. echo get_hash_table('message','user18991'); //结果为message_10
14. echo get_hash_table('message','user34523'); //结果为message_13
15. ?>
说明一下，上面的这个方法，告诉我们user18991这个用户的消息都记录在message_10这张表里，user34523这个用户的消息都记录在message_13这张表里，读取的时候，只要从各自的表中读取就行了。
优点：避免一张表出现几百万条数据，缩短了一条sql的执行时间
缺点：当一种规则确定时，打破这条规则会很麻烦，上面的例子中我用的hash算法是crc32，如果我现在不想用这个算法了，改用md5后，会使同一个用户的消息被存储到不同的表中，这样数据乱套了。扩展性很差。
3，利用merge存储引擎来实现分表
我觉得这种方法比较适合，那些没有事先考虑，而已经出现了得，数据查询慢的情况。这个时候如果要把已有的大数据量表分开比较痛苦，最痛苦的事就是改代码，因为程序里面的sql语句已经写好了，现在一张表要分成几十张表，甚至上百张表，这样sql语句是不是要重写呢？举个例子，我很喜欢举子
mysql>showengines;的时候你会发现mrg_myisam其实就是merge。
1. mysql> CREATE TABLE IF NOT EXISTS `user1` (
2. -> `id` int(11) NOT NULL AUTO_INCREMENT,
3. -> `name` varchar(50) DEFAULT NULL,
4. -> `sex` int(1) NOT NULL DEFAULT '0',
5. -> PRIMARY KEY (`id`)
6. -> ) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
7. Query OK, 0 rows affected (0.05 sec)
8.
9. mysql> CREATE TABLE IF NOT EXISTS `user2` (
10. -> `id` int(11) NOT NULL AUTO_INCREMENT,
11. -> `name` varchar(50) DEFAULT NULL,
12. -> `sex` int(1) NOT NULL DEFAULT '0',
13. -> PRIMARY KEY (`id`)
14. -> ) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
15. Query OK, 0 rows affected (0.01 sec)
16.
17. mysql> INSERT INTO `user1` (`name`, `sex`) VALUES('张映', 0);
18. Query OK, 1 row affected (0.00 sec)
19.
20. mysql> INSERT INTO `user2` (`name`, `sex`) VALUES('tank', 1);
21. Query OK, 1 row affected (0.00 sec)
22.
23. mysql> CREATE TABLE IF NOT EXISTS `alluser` (
24. -> `id` int(11) NOT NULL AUTO_INCREMENT,
25. -> `name` varchar(50) DEFAULT NULL,
26. -> `sex` int(1) NOT NULL DEFAULT '0',
27. -> INDEX(id)
28. -> ) TYPE=MERGE UNION=(user1,user2) INSERT_METHOD=LAST AUTO_INCREMENT=1 ;
29. Query OK, 0 rows affected, 1 warning (0.00 sec)
30.
31. mysql> select id,name,sex from alluser;
32. +----+--------+-----+
33. | id | name | sex |
34. +----+--------+-----+
35. | 1 | 张映 | 0 |
36. | 1 | tank | 1 |
37. +----+--------+-----+
38. 2 rows in set (0.00 sec)
39.
40. mysql> INSERT INTO `alluser` (`name`, `sex`) VALUES('tank2', 0);
41. Query OK, 1 row affected (0.00 sec)
42.
43. mysql> select id,name,sex from user2
44. -> ;
45. +----+-------+-----+
46. | id | name | sex |
47. +----+-------+-----+
48. | 1 | tank | 1 |
49. | 2 | tank2 | 0 |
50. +----+-------+-----+
51. 2 rows in set (0.00 sec)
从上面的操作中，我不知道你有没有发现点什么？假如我有一张用户表user，有50W条数据，现在要拆成二张表user1和user2，每张表25W条数据，
INSERTINTO user1(user1.id,user1.name,user1.sex)SELECT(user.id,user.name,user.sex)FROM user where user.id <= 250000
INSERTINTO user2(user2.id,user2.name,user2.sex)SELECT(user.id,user.name,user.sex)FROM user where user.id > 250000
这样我就成功的将一张user表，分成了二个表，这个时候有一个问题，代码中的sql语句怎么办，以前是一张表，现在变成二张表了，代码改动很大，这样给程序员带来了很大的工作量，有没有好的办法解决这一点呢？办法是把以前的user表备份一下，然后删除掉，上面的操作中我建立了一个alluser表，只把这个alluser表的表名改成user就行了。但是，不是所有的mysql操作都能用的
a，如果你使用alter table 来把 merge 表变为其它表类型，到底层表的映射就被丢失了。取而代之的，来自底层 myisam 表的行被复制到已更换的表中，该表随后被指定新类型。
b，网上看到一些说replace不起作用，我试了一下可以起作用的。晕一个先
1. mysql> UPDATE alluser SET sex=REPLACE(sex, 0, 1) where id=2;
2. Query OK, 1 row affected (0.00 sec)
3. Rows matched: 1 Changed: 1 Warnings: 0
4.
5. mysql> select * from alluser;
6. +----+--------+-----+
7. | id | name | sex |
8. +----+--------+-----+
9. | 1 | 张映 | 0 |
10. | 1 | tank | 1 |
11. | 2 | tank2 | 1 |
12. +----+--------+-----+
13. 3 rows in set (0.00 sec)
c，一个merge 表不能在整个表上维持unique 约束。当你执行一个insert，数据进入第一个或者最后一个myisam 表（取决于insert_method 选项的值）。mysql 确保唯一键值在那个 myisam 表里保持唯一，但不是跨集合里所有的表。
d,当你创建一个merge 表之时，没有检查去确保底层表的存在以及有相同的机构。当 merge 表被使用之时，mysql 检查每个被映射的表的记录长度是否相等，但这并不十分可靠。如果你从不相似的 myisam 表创建一个 merge 表，你非常有可能撞见奇怪的问题。
好困睡觉了，c和d在网上看到的，没有测试，大家试一下吧。
优点：扩展性好，并且程序代码改动的不是很大
96. 分表之后想让一个id多个表是自增的，效率实现
参考：http://www.ttlsa.com/mysql/mysql-table-to-solve-the-increment-id-scheme/
答：auto_increment
97. MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离
参考：http://www.cnblogs.com/alvin_xp/p/4162249.html
98. 写SQL语句。。。
99. 索引的数据结构，B+树
参考：http://www.uml.org.cn/sjjm/201107145.asp
100. 事务的四个特性，以及各自的特点（原子、隔离）等等，项目怎么解决这些问题
参考：http://www.w2bc.com/article/129246
101. 数据库的锁：行锁，表锁；乐观锁，悲观锁
mysql中有一种机制是表锁定和行锁定，为什么要出现这种机制，是为了保证数据的完整性
举个例子来说吧，如果有二个sql都要修改同一张表的同一条数据，这个时候怎么办呢，是不是二个sql都可以同时修改这条数据呢？
很显然mysql对这种情况的处理是，一种是表锁定（myisam存储引擎），一个是行锁定（innodb存储引擎）。
表锁定表示你们都不能对这张表进行操作，必须等我对表操作完才行。行锁定一样
102. 数据库事务的几种粒度；
数据库级、表级、记录级（行级）和属性级（字段级）
103. 关系型和非关系型数据库区别
参考：http://my.oschina.net/u/1773689/blog/364548
103.数据库的隔离级别：
脏读: 脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。
不可重复读:是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一
个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。
幻读:第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第
一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。
未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据
提交读(Read Committed)：只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别 (不重复读)
可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读
串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞
104. 单例模式：饱汉、饿汉。以及饿汉中的延迟加载,双重检查
参考：http://blog.csdn.net/nsw911439370/article/details/50456231
105. 工厂模式、装饰者模式、观察者模式。
参考：http://www.cnblogs.com/lyl6796910/p/4337362.html
106. 工厂方法模式的优点（低耦合、高内聚，开放封闭原则）
参考：http://blog.csdn.net/chenssy/article/details/8974868
107. 使用随机算法产生一个数，要求把1-1000W之间这些数全部生成。（考察高效率，解决产生冲突的问题）
参考：http://www.cnblogs.com/Geometry/archive/2011/01/25/1944582.html
108. 两个有序数组的合并排序
参考：http://blog.163.com/l_greatsea/blog/static/204986044201521303816600/
109. 一个数组的倒序
参考：http://k0441258778983.iteye.com/blog/1177353
110. 计算一个正整数的正平方根
111. 说白了就是常见的那些查找、排序算法以及各自的时间复杂度
参考：http://blog.csdn.net/hguisu/article/details/7776068
112. 二叉树的遍历算法
参考：http://ocaicai.iteye.com/blog/1047397
113. DFS,BFS算法
参考：http://www.cnblogs.com/developerY/p/3323264.html
114. 比较重要的数据结构，如链表，队列，栈的基本理解及大致实现。
参考：http://blog.csdn.net/amork/article/details/7258216
115. 排序算法与时空复杂度（快排为什么不稳定，为什么你的项目还在用）
参考：http://blog.csdn.net/hguisu/article/details/7776068
116. 逆波兰计算器
参考：http://blog.csdn.net/java2010czp/article/details/8033031
117. Hoffman 编码
参考：http://www.cnblogs.com/skywang12345/p/3706833.html
118. 查找树与红黑树
参考：http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html
119. 有个每秒钟5k个请求，查询手机号所属地的笔试题(记得不完整，没列出)，如何设计算法?请求再多，比如5w，如何设计整个系统?
120. 高并发情况下，我们系统是如何支撑大量的请求的
认清系统的高并发由3个层面导致：
1. 传输层
大量用户对系统请求后，将会造成网络带宽和Web服务器的I/O瓶颈。
2. 计算层
接收大量用户请求进行计算，将会造成业务服务器和业务支撑服务器的瓶颈。
3. 存储层
传输层和计算层将会产生大量的数据，数据量暴增，将会导致数据库和储存上的瓶颈。
高并发的解决方法有两种，一种是使用缓存、另一种是使用生成静态页面；
1.用分布式应用设计2、分布式缓存数据库3、代码优化。
1.不要频繁的new对象,对于在整个应用中只需要存在一个实例的类使用单例模式.对于String的连接操作,使用StringBuffer或者
StringBuilder.对于utility类型的类通过静态方法来访问。
2. 避免使用错误的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗性能,除非必要不要使用instanceof做条件判
断,尽量使用比的条件判断方式.使用JAVA中效率高的类,比如ArrayList比Vector性能好。)
3、使用静态页面
补充：页面静态化
121. 集群如何同步会话状态
参考：http://blog.csdn.net/shimiso/article/details/8978922
122. 负载均衡的原理
nginx：http://baidutech.blog.51cto.com/4114344/1033718/
http://virtualadc.blog.51cto.com/3027116/615836/
123 .如果有一个特别大的访问量，到数据库上，怎么做优化（DB设计，DBIO，SQL优化，Java优化）
参考：http://blog.sina.com.cn/s/blog_8fb83eec0101cpg7.html
124. 如果出现大面积并发，在不增加服务器的基础上，如何解决服务器响应不及时问题“。
参考：http://www.cnblogs.com/zengjin93/p/5569556.html
http://www.linuxidc.com/Linux/2011-12/50536.htm
125. 假如你的项目出现性能瓶颈了，你觉得可能会是哪些方面，怎么解决问题。
126. 如何查找 造成 性能瓶颈出现的位置，是哪个位置照成性能瓶颈。
参考：http://blog.csdn.net/beijiguangyong/article/details/17684797
127. 你的项目中使用过缓存机制吗？有没用用户非本地缓存
128.常用的Linux下的命令
参考：http://www.jb51.net/LINUXjishu/43335.html
129. 什么是spring?
Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。
130. 使用Spring框架的好处是什么？
§ 轻量：Spring 是轻量的，基本的版本大约2MB。
§ 控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
§ 面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
§ 容器：Spring 包含并管理应用中对象的生命周期和配置。
§ MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
§ 事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
§ 异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。
131. Spring由哪些模块组成?
以下是Spring 框架的基本模块：
§ Core module
§ Bean module
§ Context module
§ Expression Language module
§ JDBC module
§ ORM module
§ OXM module
§ Java Messaging Service(JMS) module
§ Transaction module
§ Web module
§ Web-Servlet module
§ Web-Struts module
§ Web-Portlet module
132. 核心容器（应用上下文) 模块。
这是基本的Spring模块，提供spring 框架的基础功能，BeanFactory 是 任何以spring为基础的应用的核心。Spring 框架建立在此模块之上，它使Spring成为一个容器。
133. BeanFactory – BeanFactory 实现举例。
Bean 工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从正真的应用代码中分离。
最常用的BeanFactory 实现是XmlBeanFactory 类。
134. XMLBeanFactory
最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory ，它根据XML文件中的定义加载beans。该容器从XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。
135. 解释AOP模块
AOP模块用于发给我们的Spring应用做面向切面的开发， 很多支持由AOP联盟提供，这样就确保了Spring和其他AOP框架的共通性。这个模块将元数据编程引入Spring。
136. 解释JDBC抽象和DAO模块。
通过使用JDBC抽象和DAO模块，保证数据库代码的简洁，并能避免数据库资源错误关闭导致的问题，它在各种不同的数据库的错误信息之上，提供了一个统一的异常访问层。它还利用Spring的AOP 模块给Spring应用中的对象提供事务管理服务。
137. 解释对象/关系映射集成模块。
Spring 通过提供ORM模块，支持我们在直接JDBC之上使用一个对象/关系映射映射(ORM)工具，Spring 支持集成主流的ORM框架，如Hiberate,JDO和 iBATIS SQL Maps。Spring的事务管理同样支持以上所有ORM框架及JDBC。
138. 解释WEB 模块。
Spring的WEB模块是构建在application context 模块基础之上，提供一个适合web应用的上下文。这个模块也包括支持多种面向web的任务，如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。它也有对Jakarta Struts的支持。
139. Spring配置文件
Spring配置文件是个XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用。
140. 什么是Spring IOC 容器？
Spring IOC 负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。
141. IOC的优点是什么？
IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试不再需要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。
142. ApplicationContext通常的实现是什么?
§ FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
§ ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
§ WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。
143. Bean 工厂和 Application contexts 有什么区别？
Application contexts提供一种方法处理文本消息，一个通常的做法是加载文件资源（比如镜像），它们可以向注册为监听器的bean发布事件。另外，在容器或容器内的对象上执行的那些不得不由bean工厂以程序化方式处理的操作，可以在Application contexts中以声明的方式处理。Application contexts实现了MessageSource接口，该接口的实现以可插拔的方式提供获取本地化消息的方法。
144. 一个Spring的应用看起来象什么？
§ 一个定义了一些功能的接口。
§ 这实现包括属性，它的Setter，getter 方法和函数等。
§ Spring AOP。
§ Spring 的XML 配置文件。
§ 使用以上功能的客户端程序。
145. 什么是Spring的依赖注入？
依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IOC容器）负责把他们组装起来。
146. 有哪些不同类型的IOC（依赖注入）方式？
§ 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
§ Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。
147. 哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入？
你两种依赖方式都可以使用，构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。
148.什么是Spring beans?
Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中
Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，如果它被赋为TRUE，bean 就是单件，否则就是一个 prototype bean。默认是TRUE，所以所有在Spring框架中的beans 缺省都是单件。
149. 一个 Spring Bean 定义 包含什么？
个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。
150. 如何给Spring 容器提供配置元数据?
这里有三种重要的方法给Spring 容器提供配置元数据。
XML配置文件。
基于注解的配置。
基于java的配置。
151. 你怎样定义类的作用域?
当定义一个
152. 解释Spring支持的几种bean的作用域。
Spring框架支持以下五种bean的作用域：
§ singleton : bean在每个Spring ioc 容器中只有一个实例。
§ prototype：一个bean的定义可以有多个实例。
§ request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
§ session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
§ global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
缺省的Spring bean 的作用域是Singleton.
153. Spring框架中的单例bean是线程安全的吗?
不，Spring框架中的单例bean不是线程安全的。
154. 解释Spring框架中bean的生命周期。
§ Spring容器 从XML 文件中读取bean的定义，并实例化bean。
§ Spring根据bean的定义填充所有的属性。
§ 如果bean实现了BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
§ 如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
§ 如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
§ 如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
§ 如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
§ 如果bean实现了 DisposableBean，它将调用destroy()方法。
155. 哪些是重要的bean生命周期方法？ 你能重载它们吗？
有两个重要的bean 生命周期方法，第一个是setup ， 它是在容器加载bean的时候被调用。第二个方法是 teardown 它是在容器卸载类的时候被调用。
The bean 标签有两个重要的属性（init-method和destroy-method）。用它们你可以自己定制初始化和注销方法。它们也有相应的注解（@PostConstruct和@PreDestroy）。
156. 什么是Spring的内部bean？
当一个bean仅被用作另一个bean的属性时，它能被声明为一个内部bean，为了定义inner bean，在Spring 的 基于XML的 配置元数据中，可以在
157. 在 Spring中如何注入一个java集合？
Spring提供以下几种集合的配置元素：
§ 类型用于注入一列值，允许有相同的值。
§
§
§
158. 什么是bean装配?
装配，或bean 装配是指在Spring 容器中把bean组装到一起，前提是容器需要知道bean的依赖关系，如何通过依赖注入来把它们装配到一起。
159. 什么是bean的自动装配？
Spring 容器能够自动装配相互合作的bean，这意味着容器不需要
160. 解释不同方式的自动装配 。
有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。
§ no：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
§ byName：通过参数名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
§ byType:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
§ constructor：这个方式类似于byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。
161.自动装配有哪些局限性 ?
自动装配的局限性是：
§ 重写： 你仍需用
§ 基本数据类型：你不能自动装配简单的属性，如基本数据类型，String字符串，和类。
§ 模糊特性：自动装配不如显式装配精确，如果有可能，建议使用显式装配。
162. 你可以在Spring中注入一个null 和一个空字符串吗？
可以。
163. 什么是基于Java的Spring注解配置? 给一些注解的例子.
基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。
以@Configuration 注解为例，它用来标记类可以当做一个bean的定义，被Spring IOC容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进Spring应用上下文。
164. 什么是基于注解的容器配置?
相对于XML文件，注解型的配置依赖于通过字节码元数据装配组件，而非尖括号的声明。
开发者通过在相应的类，方法或属性上使用注解的方式，直接组件类中进行配置，而不是使用xml表述bean的装配关系。
165. 怎样开启注解装配？
注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在Spring配置文件中配置
166. @Required 注解
这个注解表明bean的属性必须在配置的时候设置，通过一个bean定义的显式的属性值或通过自动装配，若@Required注解的bean属性未被设置，容器将抛出BeanInitializationException。
167. @Autowired 注解
@Autowired 注解提供了更细粒度的控制，包括在何处以及如何完成自动装配。它的用法和@Required一样，修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法。
168. @Qualifier 注解
当有多个相同类型的bean却只有一个需要自动装配时，将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆，指定需要装配的确切的bean。
169.在Spring框架中如何更有效地使用JDBC?
使用SpringJDBC 框架，资源管理和错误处理的代价都会被减轻。所以开发者只需写statements 和 queries从数据存取数据，JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用，这个模板叫JdbcTemplate （例子见这里here）
170. JdbcTemplate
JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。
171. Spring对DAO的支持
Spring对数据访问对象（DAO）的支持旨在简化它和数据访问技术如JDBC，Hibernate or JDO 结合使用。这使我们可以方便切换持久层。编码时也不用担心会捕获每种技术特有的异常。
172.使用Spring通过什么方式访问Hibernate?
在Spring中有两种方式访问Hibernate：
§ 控制反转 Hibernate Template和 Callback。
§ 继承 HibernateDAOSupport提供一个AOP 拦截器。
173. Spring支持的ORM
Spring支持以下ORM：
§ Hibernate
§ iBatis
§ JPA (Java Persistence API)
§ TopLink
§ JDO (Java Data Objects)
§ OJB
174.如何通过HibernateDaoSupport将Spring和Hibernate结合起来？
用Spring的 SessionFactory 调用 LocalSessionFactory。集成过程分三步：
§ 配置the Hibernate SessionFactory。
§ 继承HibernateDaoSupport实现一个DAO。
§ 在AOP支持的事务中装配。
175. Spring支持的事务管理类型
Spring支持两种类型的事务管理：
§ 编程式事务管理：这意味你通过编程的方式管理事务，给你带来极大的灵活性，但是难维护。
§ 声明式事务管理：这意味着你可以将业务代码和事务管理分离，你只需用注解和XML配置来管理事务。
176. Spring框架的事务管理有哪些优点？
§ 它为不同的事务API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一个不变的编程模式。
§ 它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API如
§ 它支持声明式事务管理。
§ 它和Spring各种数据访问抽象层很好得集成。
177. 你更倾向用那种事务管理类型？
大多数Spring框架的用户选择声明式事务管理，因为它对应用代码的影响最小，因此更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理，虽然比编程式事务管理（这种方式允许你通过代码控制事务）少了一点灵活性。
178. 解释AOP
面向切面的编程，或AOP， 是一种编程技术，允许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。
179. Aspect 切面
AOP核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组API提供横切功能。比如，一个日志模块可以被称作日志的AOP切面。根据需求的不同，一个应用程序可以有若干切面。在Spring AOP中，切面通过带有@Aspect注解的类实现。
180. 在Spring AOP 中，关注点和横切关注的区别是什么？
关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。
横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。
181. 连接点
连接点代表一个应用程序的某个位置，在这个位置我们可以插入一个AOP切面，它实际上是个应用程序执行Spring AOP的位置。
182. 通知
通知是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码段。
Spring切面可以应用五种类型的通知：
§ before：前置通知，在一个方法执行前被调用。
§ after: 在方法执行之后调用的通知，无论方法执行是否成功。
§ after-returning: 仅当方法成功完成后执行的通知。
§ after-throwing: 在方法抛出异常退出时执行的通知。
§ around: 在方法执行之前和之后调用的通知。
183. 切点
切入点是一个或一组连接点，通知将在这些位置执行。可以通过表达式或匹配的方式指明切入点。
184. 什么是引入?
引入允许我们在已存在的类中增加新的方法和属性。
185. 什么是目标对象?
被一个或者多个切面所通知的对象。它通常是一个代理对象。也指被通知（advised）对象。
186. 什么是代理?
代理是通知目标对象后创建的对象。从客户端的角度看，代理对象和目标对象是一样的。
187. 有几种不同类型的自动代理？
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
Metadata autoproxying
188. 什么是织入。什么是织入应用的不同点？
织入是将切面和到其他应用类型或对象连接或创建一个被通知对象的过程。
织入可以在编译时，加载时，或运行时完成。
189. 解释基于XML Schema方式的切面实现。
在这种情况下，切面由常规类以及基于XML的配置实现。
190. 解释基于注解的切面实现
在这种情况下(基于@AspectJ的实现)，涉及到的切面声明的风格与带有java5标注的普通java类一致。
191. 什么是Spring的MVC框架？
Spring 配备构建Web 应用的全功能MVC框架。Spring可以很便捷地和其他MVC框架集成，如Struts，Spring 的MVC框架用控制反转把业务对象和控制逻辑清晰地隔离。它也允许以声明的方式把请求参数和业务对象绑定。
192. DispatcherServlet
Spring的MVC框架是围绕DispatcherServlet来设计的，它用来处理所有的HTTP请求和响应。
193. WebApplicationContext
WebApplicationContext 继承了ApplicationContext 并增加了一些WEB应用必备的特有功能，它不同于一般的ApplicationContext ，因为它能处理主题，并找到被关联的servlet。
194. 什么是Spring MVC框架的控制器？
控制器提供一个访问应用程序的行为，此行为通常通过服务接口实现。控制器解析用户输入并将其转换为一个由视图呈现给用户的模型。Spring用一个非常抽象的方式实现了一个控制层，允许用户创建多种用途的控制器。
195. @Controller 注解
该注解表明该类扮演控制器的角色，Spring不需要你继承任何其他控制器基类或引用Servlet API。
196. @RequestMapping 注解
该注解是用来映射一个URL到一个类或一个特定的方处理法上。
197.求从10到100中能被3或5整除的数的和
intsum = 0; for(int i = 10; i <= 100; i++) if( i % 3 == 0 || i % 5 == 0) sum +=i; System.out.println(sum);
198.将一个字符串逆序，不要使用反转函数
Stringmessage = \"he saw a racecar\"; StringBuilder rev = newStringBuilder(); for(int i = message.length()-1; i >= 0; i--)rev.append(message.charAt(i)); System.out.println(rev.toString());
199.反转一个栈
importjava.util.*;
publicclass MyProgram extends com.ktbyte.submit.Coder {
public static void main(String[] args) {
Stack items = new Stack();
items.push(\"he\"); //he isat the bottom of the stack
items.push(\"saw\");
items.push(\"a\");
items.push(\"racecar\");
reverseStack(items); //now he is at the top
//print in order pushed:
while(items.size()>0) System.out.println(items.pop());
}
public static void reverseStack(Stack stack) {
Queue rev = new LinkedList();
while(stack.size()>0) rev.offer(stack.pop());
while(rev.size()>0) stack.push(rev.poll());
}
}
200.Java集合框架是什么？说出一些集合框架的优点？
每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。集合框架的部分优点如下：
（1）使用核心集合类降低开发成本，而非实现我们自己的集合类。
（2）随着使用经过严格测试的集合框架类，代码质量会得到提高。
（3）通过使用JDK附带的集合类，可以降低代码维护成本。
（4）复用性和可操作性。
201.集合框架中的泛型有什么优点？
Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。
202.Java集合框架的基础接口有哪些？
Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。
Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。
List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。
Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。
一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。
203.为何Collection不从Cloneable和Serializable接口继承？
Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。
当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。
在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。
204.为何Map接口不继承Collection接口？
尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。
如果Map继承Collection接口，那么元素去哪儿？Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。
205.Iterator是什么？
Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。
206.Enumeration和Iterator接口的区别？
Enumeration的速度是Iterator的两倍，也使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。
迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。为了使它的功能更加清晰，迭代器方法名已经经过改善。
207.为何没有像Iterator.add()这样的方法，向集合中添加元素？
语义不明，已知的是，Iterator的协议不能确保迭代的次序。然而要注意，ListIterator没有提供一个add操作，它要确保迭代的顺序。
208.为何迭代器没有一个方法可以直接获取下一个元素，而不需要移动游标？
它可以在当前Iterator的顶层实现，但是它用得很少，如果将它加到接口中，每个继承都要去实现它，这没有意义。
209.Iterater和ListIterator之间有什么区别？
（1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。
（2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。
（3）ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。
210.遍历一个List有哪些不同的方式？
List
使用迭代器更加线程安全，因为它可以确保，在当前遍历的集合元素被更改的时候，它会抛出ConcurrentModificationException。
212.通过迭代器fail-fast属性，你明白了什么？
每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动，它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的（ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外）。
213.fail-fast与fail-safe有什么区别？
Iterator的fail-fast属性与当前的集合共同起作用，因此它不会受到集合中任何改动的影响。Java.util包中的所有集合类都被设计为fail-fast的，而java.util.concurrent中的集合类都为fail-safe的。Fail-fast迭代器抛出ConcurrentModificationException，而fail-safe迭代器从不抛出ConcurrentModificationException。
214.在迭代一个集合的时候，如何避免
在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。
215.为何Iterator接口没有具体的实现？
Iterator接口定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。
这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的。
216.UnsupportedOperationException是什么？
UnsupportedOperationException是用于表明操作不支持的异常。在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在所有add和remove操作中抛出这个异常。
217.在Java中，HashMap是如何工作的？
HashMap在Map.Entry静态内部类实现中存储key-value对。HashMap使用哈希算法，在put和get方法中，它使用hashCode()和equals()方法。当我们通过传递key-value对调用put方法的时候，HashMap使用KeyhashCode()和哈希算法来找出存储key-value对的索引。Entry存储在LinkedList中，所以如果存在entry，它使用equals()方法来检查传递的key是否已经存在，如果存在，它会覆盖value，如果不存在，它会创建一个新的entry然后保存。当我们通过传递key调用get方法时，它再次使用hashCode()来找到数组中的索引，然后使用equals()方法找出正确的Entry，然后返回它的值。下面的图片解释了详细内容。
其它关于HashMap比较重要的问题是容量、负荷系数和阀值调整。HashMap默认的初始容量是32，负荷系数是0.75。阀值是为负荷系数乘以容量，无论何时我们尝试添加一个entry，如果map的大小比阀值大的时候，HashMap会对map的内容进行重新哈希，且使用更大的容量。容量总是2的幂，所以如果你知道你需要存储大量的key-value对，比如缓存从数据库里面拉取的数据，使用正确的容量和负荷系数对HashMap进行初始化是个不错的做法。
218.hashCode()和equals()方法有何重要性？
HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。当我们试着从HashMap中获取值的时候，这些方法也会被用到。如果这些方法没有被正确地实现，在这种情况下，两个不同Key也许会产生相同的hashCode()和equals()输出，HashMap将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。同样的，所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复，所以正确实现它们非常重要。equals()和hashCode()的实现应该遵循以下规则：
（1）如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。
（2）如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。
219.我们能否使用任何类作为Map的key？
我们可以使用任何类作为Map的key，然而在使用它们之前，需要考虑以下几点：
（1）如果类重写了equals()方法，它也应该重写hashCode()方法。
（2）类的所有实例需要遵循与equals()和hashCode()相关的规则。请参考之前提到的这些规则。
（3）如果一个类没有使用equals()，你不应该在hashCode()中使用它。
（4）用户自定义key类的最佳实践是使之为不可变的，这样，hashCode()值可以被缓存起来，拥有更好的性能。不可变的类也可以确保hashCode()和equals()在未来不会改变，这样就会解决与可变相关的问题了。
比如，我有一个类MyKey，在HashMap中使用它。
//传递给MyKey的name参数被用于equals()和hashCode()中MyKey key = new MyKey('Pankaj'); //assume hashCode=1234myHashMap.put(key, 'Value'); // 以下的代码会改变key的hashCode()和equals()值key.setName('Amit'); //assume new hashCode=7890 //下面会返回null，因为HashMap会尝试查找存储同样索引的key，而key已被改变了，匹配失败，返回nullmyHashMap.get(new MyKey('Pankaj'));
那就是为何String和Integer被作为HashMap的key大量使用。
220.Map接口提供了哪些不同的集合视图？
Map接口提供三个集合视图：
（1）Set keyset()：返回map中包含的所有key的一个Set视图。集合是受map支持的，map的变化会在集合中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。
（2）Collection values()：返回一个map中包含的所有value的一个Collection视图。这个collection受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个collection时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。
（3）Set
221.HashMap和HashTable有何不同？
（1）HashMap允许key和value为null，而HashTable不允许。
（2）HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。
（3）在Java1.4中引入了LinkedHashMap，HashMap的一个子类，假如你想要遍历顺序，你很容易从HashMap转向LinkedHashMap，但是HashTable不是这样的，它的顺序是不可预知的。
（4）HashMap提供对key的Set进行遍历，因此它是fail-fast的，但HashTable提供对key的Enumeration进行遍历，它不支持fail-fast。
（5）HashTable被认为是个遗留的类，如果你寻求在迭代的时候修改Map，你应该使用CocurrentHashMap。
222.如何决定选用HashMap还是TreeMap？
对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。
223.ArrayList和Vector有何异同点？
ArrayList和Vector在很多时候都很类似。
（1）两者都是基于索引的，内部由一个数组支持。
（2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。
（3）ArrayList和Vector的迭代器实现都是fail-fast的。
（4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。
以下是ArrayList和Vector的不同点。
（1）Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。
（2）ArrayList比Vector快，它因为有同步，不会过载。
（3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。
224.Array和ArrayList有何区别？什么时候更适合用Array？
Array可以容纳基本类型和对象，而ArrayList只能容纳对象。
Array是指定大小的，而ArrayList大小是固定的。
Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择，但也有些时候Array比较好用。
（1）如果列表的大小已经指定，大部分情况下是存储和遍历它们。
（2）对于遍历基本数据类型，尽管Collections使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。
（3）如果你要使用多维数组，使用[][]比List
225.ArrayList和LinkedList有何区别？
ArrayList和LinkedList两者都实现了List接口，但是它们之间有些不同。
（1）ArrayList是由Array所支持的基于一个索引的数据结构，所以它提供对元素的随机访问，复杂度为O(1)，但LinkedList存储一系列的节点数据，每个节点都与前一个和下一个节点相连接。所以，尽管有使用索引获取元素的方法，内部实现是从起始点开始遍历，遍历到索引的节点然后返回元素，时间复杂度为O(n)，比ArrayList要慢。
（2）与ArrayList相比，在LinkedList中插入、添加和删除一个元素会更快，因为在一个元素被插入到中间的时候，不会涉及改变数组的大小，或更新索引。
（3）LinkedList比ArrayList消耗更多的内存，因为LinkedList中的每个节点存储了前后节点的引用。
226.哪些集合类提供对元素的随机访问？
ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机访问。
227.EnumSet是什么？
java.util.EnumSet是使用枚举类型的集合实现。当集合创建时，枚举集合中的所有元素必须来自单个指定的枚举类型，可以是显示的或隐示的。EnumSet是不同步的，不允许值为null的元素。它也提供了一些有用的方法，比如copyOf(Collection c)、of(Efirst,E…rest)和complementOf(EnumSet s)。
228.哪些集合类是线程安全的？
Vector、HashTable、Properties和Stack是同步类，所以它们是线程安全的，可以在多线程环境下使用。Java1.5并发API包括一些集合类，允许迭代时修改，因为它们都工作在集合的克隆上，所以它们在多线程环境中是安全的。
229.并发集合类是什么？
Java1.5并发包（java.util.concurrent）包含线程安全集合类，允许在迭代时修改集合。迭代器被设计为fail-fast的，会抛出ConcurrentModificationException。一部分类为：CopyOnWriteArrayList、ConcurrentHashMap、CopyOnWriteArraySet。
230.BlockingQueue是什么？
Java.util.concurrent.BlockingQueue是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在添加一个元素时，它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间，或消费者有可用的对象，因为它都在BlockingQueue的实现类中被处理了。Java提供了集中BlockingQueue的实现，比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。
231.队列和栈是什么，列出它们的区别？
栈和队列两者都被用来预存储数据。java.util.Queue是一个接口，它的实现类在Java并发包中。队列允许先进先出（FIFO）检索元素，但并非总是这样。Deque接口允许从两端检索元素。
栈与队列很相似，但它允许对元素进行后进先出（LIFO）进行检索。
Stack是一个扩展自Vector的类，而Queue是一个接口。
232.Collections类是什么？
Java.util.Collections是一个工具类仅包含静态方法，它们操作或返回集合。它包含操作集合的多态算法，返回一个由指定集合支持的新集合和其它一些内容。这个类包含集合框架算法的方法，比如折半搜索、排序、混编和逆序等。
233.Comparable和Comparator接口是什么？
如果我们想使用Array或Collection的排序方法时，需要在自定义类里实现Java提供Comparable接口。Comparable接口有compareTo(T OBJ)方法，它被排序方法所使用。我们应该重写这个方法，如果“this”对象比传递的对象参数更小、相等或更大时，它返回一个负整数、0或正整数。但是，在大多数实际情况下，我们想根据不同参数进行排序。比如，作为一个CEO，我想对雇员基于薪资进行排序，一个HR想基于年龄对他们进行排序。这就是我们需要使用Comparator接口的情景，因为Comparable.compareTo(Object o)方法实现只能基于一个字段进行排序，我们不能根据对象排序的需要选择字段。Comparator接口的compare(Object o1, Object o2)方法的实现需要传递两个对象参数，若第一个参数比第二个小，返回负整数；若第一个等于第二个，返回0；若第一个比第二个大，返回正整数。
234.Comparable和Comparator接口有何区别？
Comparable和Comparator接口被用来对对象集合或者数组进行排序。Comparable接口被用来提供对象的自然排序，我们可以使用它来提供基于单个逻辑的排序。
Comparator接口被用来提供不同的排序算法，我们可以选择需要使用的Comparator来对给定的对象集合进行排序。
235.我们如何对一组对象进行排序？
如果我们需要对一个对象数组进行排序，我们可以使用Arrays.sort()方法。如果我们需要排序一个对象列表，我们可以使用Collection.sort()方法。两个类都有用于自然排序（使用Comparable）或基于标准的排序（使用Comparator）的重载方法sort()。Collections内部使用数组排序方法，所有它们两者都有相同的性能，只是Collections需要花时间将列表转换为数组。
236.当一个集合被作为参数传递给一个函数时，如何才可以确保函数不能修改它？
在作为参数传递之前，我们可以使用Collections.unmodifiableCollection(Collectionc)方法创建一个只读集合，这将确保改变集合的任何操作都会抛出UnsupportedOperationException。
237.我们如何从给定集合那里创建一个synchronized的集合？
我们可以使用Collections.synchronizedCollection(Collectionc)根据指定集合来获取一个synchronized（线程安全的）集合。
238.集合框架里实现的通用算法有哪些？
Java集合框架提供常用的算法实现，比如排序和搜索。Collections类包含这些方法实现。大部分算法是操作List的，但一部分对所有类型的集合都是可用的。部分算法有排序、搜索、混编、最大最小值。
239.大写的O是什么？举几个例子？
大写的O描述的是，就数据结构中的一系列元素而言，一个算法的性能。Collection类就是实际的数据结构，我们通常基于时间、内存和性能，使用大写的O来选择集合实现。比如：例子1：ArrayList的get(index i)是一个常量时间操作，它不依赖list中元素的数量。所以它的性能是O(1)。例子2：一个对于数组或列表的线性搜索的性能是O(n)，因为我们需要遍历所有的元素来查找需要的元素。
240.与Java集合框架相关的有哪些最好的实践？
（1）根据需要选择正确的集合类型。比如，如果指定了大小，我们会选用Array而非ArrayList。如果我们想根据插入顺序遍历一个Map，我们需要使用TreeMap。如果我们不想重复，我们应该使用Set。
（2）一些集合类允许指定初始容量，所以如果我们能够估计到存储元素的数量，我们可以使用它，就避免了重新哈希或大小调整。
（3）基于接口编程，而非基于实现编程，它允许我们后来轻易地改变实现。
（4）总是使用类型安全的泛型，避免在运行时出现ClassCastException。
（5）使用JDK提供的不可变类作为Map的key，可以避免自己实现hashCode()和equals()。
（6）尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性。
241.什么是线程？
线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。
242.线程和进程有什么区别？
线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据
243.如何在Java中实现线程？
在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程
244.用Runnable还是Thread？
这个问题是上题的后续，大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程，问题是，那个方法更好呢？什么情况下使用它？这个问题很容易回答，如果你知道Java不支持类的多重继承，但允许你调用多个接口。所以如果你要继承其他类，当然是调用Runnable接口好了。
245.Thread 类中的start() 和 run() 方法有什么区别？
这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程
246.Java中Runnable和Callable有什么不同？
Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象
247.Java中CyclicBarrier 和 CountDownLatch有什么不同？
CyclicBarrier和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是，CountdownLatch 不能重新使用。
248.Java内存模型是什么？
Java内存模型规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为。它在多线程的情况下尤其重要。Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰。比如，先行发生关系确保了：
§ 线程内的代码能够按先后顺序执行，这被称为程序次序规则。
§ 对于同一个锁，一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前，也叫做管程锁定规则。
§ 前一个对volatile的写操作在后一个volatile的读操作之前，也叫volatile变量规则。
§ 一个线程内的任何操作必需在这个线程的start()调用之后，也叫作线程启动规则。
§ 一个线程的所有操作都会在线程终止之前，线程终止规则。
§ 一个对象的终结操作必需在这个对象构造完成之后，也叫对象终结规则。
249.Java中的volatile 变量是什么？
volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生，就是上一题的volatile变量规则
250.什么是线程安全？Vector是一个线程安全类吗？
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。很显然你可以将集合类分成两组，线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。
251.Java中什么是竞态条件？ 举个例子说明。
竞态条件会导致程序在并发情况下出现一些bugs。多线程对一些资源的竞争的时候就会产生竞态条件，如果首先要执行的程序竞争失败排到后面执行了，那么整个程序就会出现一些不确定的bugs。这种bugs很难发现而且会重复出现，因为线程间的随机竞争。
252.Java中如何停止一个线程？
Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程
253.一个线程运行时发生异常会怎样？
简单的说，如果异常没有被捕获该线程将会停止执行。Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。
254.如何在两个线程间共享数据？
你可以通过共享对象来实现这个目的，或者是使用像阻塞队列这样并发的数据结构。这篇教程《Java线程间通信》(涉及到在两个线程间共享对象)用wait和notify方法实现了生产者消费者模型。
255.Java中notify 和 notifyAll有什么区别？
这又是一个刁钻的问题，因为多线程可以等待单监控锁，Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们，但是这些方法没有完全实现。notify()方法不能唤醒某个具体的线程，所以只有一个线程在等待的时候它才有用武之地。而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。
256.为什么wait, notify 和 notifyAll这些方法不在thread类里面？
这是个设计相关的问题，它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法。回答这些问题的时候，你要说明为什么把这些方法放在Object类里是有意义的，还有不把它放在Thread类里的原因。一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。简单的说，由于wait，notify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象。
257.什么是ThreadLocal变量？
ThreadLocal是Java里一种特殊的变量。每个线程都有一个ThreadLocal就是每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了。它是为创建代价高昂的对象获取线程安全的好方法，比如你可以用ThreadLocal让SimpleDateFormat变成线程安全的，因为那个类创建代价高昂且每次调用都需要创建不同的实例所以不值得在局部范围使用它，如果为每个线程提供一个自己独有的变量拷贝，将大大提高效率。首先，通过复用减少了代价高昂的对象的创建个数。其次，你在没有使用高代价的同步或者不变性的情况下获得了线程安全。线程局部变量的另一个不错的例子是ThreadLocalRandom类，它在多线程环境中减少了创建代价高昂的Random对象的个数
258.什么是FutureTask？
在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装，由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。
259.Java中interrupted 和 isInterruptedd方法的区别？
interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。Java多线程的中断机制是用内部标识来实现的，调用Thread.interrupt()来中断一个线程就会设置中断标识为true。当中断线程调用静态方法Thread.interrupted()来检查中断状态时，中断状态会被清零。而非静态方法isInterrupted()用来查询其它线程的中断状态且不会改变中断状态标识。简单的说就是任何抛出InterruptedException异常的方法都会将中断状态清零。无论如何，一个线程的中断状态有有可能被其它线程调用中断来改变。
260.为什么wait和notify方法要在同步块中调用？
主要是因为Java API强制要求这样做，如果你不这么做，你的代码会抛出IllegalMonitorStateException异常。还有一个原因是为了避免wait和notify之间产生竞态条件。
261.为什么你应该在循环中检查等待条件?
处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。因此，当一个等待线程醒来时，不能认为它原来的等待状态仍然是有效的，在notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用wait()方法效果更好的原因，你可以在Eclipse中创建模板调用wait和notify试一试。
262.Java中的同步集合与并发集合有什么区别？
同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。
263.Java中堆和栈有什么不同？
为什么把这个问题归类在多线程和并发面试题里？因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存，用于存储本地变量，方法参数和栈调用，一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到自己的栈，如果多个线程使用该变量就可能引发问题，这时volatile 变量就可以发挥作用了，它要求线程从主存中读取变量的值。
264.什么是线程池？ 为什么要使用它？
创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）。
265.如何写代码来解决生产者消费者问题？
在现实中你解决的许多线程问题都属于生产者消费者模型，就是一个线程生产任务供其它线程进行消费，你必须知道怎么进行线程间通信来解决这个问题。比较低级的办法是用wait和notify来解决这个问题，比较赞的办法是用Semaphore 或者 BlockingQueue来实现生产者消费者模型
266.如何避免死锁？
Java多线程中的死锁
死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。这是一个严重的问题，因为死锁会让你的程序挂起无法完成任务，死锁的发生必须满足以下四个条件：
§ 互斥条件：一个资源每次只能被一个进程使用。
§ 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
§ 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
§ 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
避免死锁最简单的方法就是阻止循环等待条件，将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁。
267. Java中活锁和死锁有什么区别？
这是上题的扩展，活锁和死锁类似，不同之处在于处于活锁的线程或进程的状态是不断改变的，活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个人在狭小的走廊碰到，两个人都试着避让对方好让彼此通过，但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是，活锁和死锁的主要区别是前者进程的状态可以改变但是却不能继续执行。
268. 怎么检测一个线程是否拥有锁？
我一直不知道我们竟然可以检测一个线程是否拥有锁，直到我参加了一次电话面试。在java.lang.Thread中有一个方法叫holdsLock()，它返回true如果当且仅当当前线程拥有某个具体对象的锁。
269. 你如何在Java中获取线程堆栈？
对于不同的操作系统，有多种方法来获得Java进程的线程堆栈。当你获取线程堆栈时，JVM会把所有线程的状态存到日志文件或者输出到控制台。在Windows你可以使用Ctrl + Break组合键来获取线程堆栈，Linux下用kill -3命令。你也可以用jstack这个工具来获取，它对线程id进行操作，你可以用jps这个工具找到id。
270. JVM中哪个参数是用来控制线程的栈堆栈小的
这个问题很简单， -Xss参数用来控制线程的堆栈大小。
271. Java中synchronized 和 ReentrantLock 有什么不同？
Java在过去很长一段时间只能通过synchronized关键字来实现互斥，它有一些缺点。比如你不能扩展锁之外的方法或者块边界，尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性。
272. 有三个线程T1，T2，T3，怎么确保它们按顺序执行？
在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3最后完成。
273. Thread类中的yield方法有什么作用？
Yield方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行。
274. Java中ConcurrentHashMap的并发度是什么？
ConcurrentHashMap把实际map划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的，它是ConcurrentHashMap类构造函数的一个可选参数，默认值为16，这样在多线程情况下就能避免争用。
275. Java中Semaphore是什么？
Java中的Semaphore是一种新的同步类，它是一个计数信号。从概念上讲，从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release()添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore只对可用许可的号码进行计数，并采取相应的行动。信号量常常用于多线程的代码中，比如数据库连接池。
276. 如果你提交任务时，线程池队列已满。会时发会生什么？
这个问题问得很狡猾，许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度执行那么ThreadPoolExecutor’s submit()方法将会抛出一个RejectedExecutionException异常。
277. Java线程池中submit()和 execute()方法有什么区别？
两个方法都可以向线程池提交任务，execute()方法的返回类型是void，它定义在Executor接口中, 而submit()方法可以返回持有计算结果的Future对象，它定义在ExecutorService接口中，它扩展了Executor接口，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。
278. 什么是阻塞式方法？
阻塞式方法是指程序会一直等待该方法完成期间不做其他事情，ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。
279. Swing是线程安全的吗？ 为什么？
你可以很肯定的给出回答，Swing不是线程安全的，但是你应该解释这么回答的原因即便面试官没有问你为什么。当我们说swing不是线程安全的常常提到它的组件，这些组件不能在多线程中进行修改，所有对GUI组件的更新都要在AWT线程中完成，而Swing提供了同步和异步两种回调方法来进行更新。
280. Java中invokeAndWait和 invokeLater有什么区别？
这两个方法是Swing API 提供给Java开发者用来从当前线程而不是事件派发线程更新GUI组件用的。InvokeAndWait()同步更新GUI组件，比如一个进度条，一旦进度更新了，进度条也要做出相应改变。如果进度被多个线程跟踪，那么就调用invokeAndWait()方法请求事件派发线程对组件进行相应更新。而invokeLater()方法是异步调用更新组件的。
281. Swing API中那些方法是线程安全的？
这个问题又提到了swing和线程安全，虽然组件不是线程安全的但是有一些方法是可以被多线程安全调用的，比如repaint(), revalidate()。 JTextComponent的setText()方法和JTextArea的insert() 和 append() 方法也是线程安全的。
282. 如何在Java中创建Immutable对象？
这个问题看起来和多线程没什么关系， 但不变性有助于简化已经很复杂的并发程序。Immutable对象可以在没有同步的情况下共享，降低了对该对象进行并发访问时的同步化开销。可是Java没有@Immutable这个注解符，要创建不可变类，要实现下面几个步骤：通过构造方法初始化所有成员、对变量不要提供setter方法、将所有的成员声明为私有的，这样就不允许直接访问这些成员、在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝。
283. Java中的ReadWriteLock是什么？
一般而言，读写锁是用来提升并发程序性能的锁分离技术的成果。Java中的ReadWriteLock是Java 5 中新增的一个接口，一个ReadWriteLock维护一对关联的锁，一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的，你可以使用JDK中的ReentrantReadWriteLock来实现这个规则，它最多支持65535个写锁和65535个读锁。
284. 多线程中的忙循环是什么?
忙循环就是程序员用循环让一个线程等待，不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制，而忙循环不会放弃CPU，它就是在运行一个空循环。这么做的目的是为了保留CPU缓存，在多核系统中，一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。
285. volatile 变量和atomic 变量有什么不同？
这是个有趣的问题。首先，volatile 变量和 atomic 变量看起来很像，但功能却不一样。Volatile变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。
286. 如果同步块内的线程抛出异常会发生什么？
这个问题坑了很多Java程序员，若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的，里面的线程都会释放锁，所以对比锁接口我更喜欢同步块，因为它不用我花费精力去释放锁，该功能可以在finally block里释放锁实现。
287. 单例模式的双检锁是什么？
这个问题在Java面试中经常被问到，但是面试官对回答此问题的满意度仅为50%。一半的人写不出双检锁还有一半的人说不出它的隐患和Java1.5是如何对它修正的。它其实是一个用来创建线程安全的单例的老方法，当单例实例第一次被创建时它试图用单个锁进行性能优化，但是由于太过于复杂在JDK1.4中它是失败的，我个人也不喜欢它。无论如何，即便你也不喜欢它但是还是要了解一下，因为它经常被问到。
288. 如何在Java中创建线程安全的Singleton？
这是上面那个问题的后续，如果你不喜欢双检锁而面试官问了创建Singleton类的替代方法，你可以利用JVM的类加载和静态变量初始化特征来创建Singleton实例，或者是利用枚举类型来创建Singleton
289. 写出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。
290. 如何强制启动一个线程？
这个问题就像是如何强制进行Java垃圾回收，目前还没有觉得方法，虽然你可以使用System.gc()来进行垃圾回收，但是不保证能成功。在Java里面没有办法强制启动一个线程，它是被线程调度器控制着且Java没有公布相关的API。
291. Java中的forkjoin框架是什么？
fork join框架是JDK7中出现的一款高效的工具，Java开发人员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的，目的是将所有可用的处理能力用来提升程序的性能。fork join框架一个巨大的优势是它使用了工作窃取算法，可以完成更多任务的工作线程可以从其它线程中窃取任务来执行
292. Java多线程中调用wait()和 sleep()方法有什么不同？
Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。
293. JAVA接口和抽象类的区别是什么？
Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：
§ 接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
§ 类可以实现很多个接口，但是只能继承一个抽象类
§ 类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
§ 抽象类可以在不提供接口方法实现的情况下实现接口。
§ Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
§ Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
§ 接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
294.”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？
“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。
Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
295.是否可以在static环境中访问非static变量？
static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。
296.JDK和JRE的区别是什么？
Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件。Java开发工具包(JDK)是完整的Java软件开发包，包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)，可以让开发者开发、编译、执行Java应用程序。
297.什么是Java虚拟机？
Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。
Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。
298.Hibernate工作原理及为什么要用？
原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory
为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系
299．Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
2. Hibernate3 提供了属性的延迟加载功能 当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
300．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many
301.Struts1流程：
1、客户端浏览器发出HTTP请求。2、根据web.xml配置，该请求被ActionServlet接收。3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。4、是否验证，需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。6、Action返回ActionForward对象，跳转到相应JSP页面或Action。7、返回HTTP响应到客户端浏览器。
MVC设计模式：modal：“模型” 也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射
302.struts是什么？
struts1是基于JSP和servlet的一个开源的Web应用框架，使用的是MVC的设计模式struts2是基于webwork技术的框架，是sun和webwork公司联手开发的一个功能非常齐全的框架，struts2和struts1没有任何关系，是一个全新的框架
303.spring是什么？
spring是一个集成了许多第三方框架的大杂烩，其核心技术是IOC（控制反转，也称依赖注入）和AOP（面向切面编程）
304.hibernate是什么？
hibernate是基于ORM对象关系映射（完成对象数据到关系数据映射的机制）实现的,做数据持久化的工具
305.JSF是什么？
JavaServer Face是基于组件的web开发框架，跟sturts差不多的框架
306.数据库里面的索引和约束是什么?
索引是为了提高数据的检索速度，索引是建立在数据表上，根据一个或多个字段建立的约束是为了保持数据的完整性，约束有非空约束，主键约束，外键约束等等。
307.spring是什么
这个问题，往往可以通过我们为什么要使用spring这个问题来切入：AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight
construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。
308.用自己的话简要阐述struts2的执行流程。
Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。
Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。基本简要流程如下：1、客户端浏览器发出HTTP请求。2、根据web.xml配置，该请求被FilterDispatcher接收。3、根据struts.xml配置，找到需要调用的Action类和方法， 并通过IoC方式，将值注入给Aciton。4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。6、返回HTTP响应到客户端浏览器。
309. Java中的泛型是什么 ? 使用泛型的好处是什么?
这是在各种Java泛型面试中，一开场你就会被问到的问题中的一个，主要集中在初级和中级面试中。那些拥有Java1.4或更早版本的开发背景的人都知道，在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。它提供了编译期的类型安全，确保你只能把正确类型的对象放入集合中，避免了在运行时出现ClassCastException。
310. Java的泛型是如何工作的 ? 什么是类型擦除 ?
这是一道更好的泛型面试题。泛型是通过类型擦除来实现的，编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List
311. 什么是泛型中的限定通配符和非限定通配符 ?
这是另一个非常流行的Java泛型面试题。限定通配符对类型进行了限制。有两种限定通配符，一种是它通过确保类型必须是T的子类来设定类型的上界，另一种是它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。另一方面表示了非限定通配符，因为可以用任意类型来替代。更多信息请参阅我的文章泛型中限定通配符和非限定通配符之间的区别。
312. List和List 之间有什么区别 ?
这和上一个面试题有联系，有时面试官会用这个问题来评估你对泛型的理解，而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子，List可以接受任何继承自T的类型的List，而List可以接受任何T的父类构成的List。例如List可以接受List
313. 如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?
编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。泛型方法的例子请参阅Java集合类框架。最简单的情况下，一个泛型方法可能会像这样:
public V put(K key, V value) {
return cache.put(key, value);
314. Java中如何使用泛型编写带有参数的类?
这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。
315. 编写一段泛型程序来实现LRU缓存?
对于喜欢Java编程的人来说这相当于是一次练习。给你个提示，LinkedHashMap可以用来实现固定大小的LRU缓存，当LRU缓存已经满了的时候，它会把最老的键值对移出缓存。LinkedHashMap提供了一个称为removeEldestEntry()的方法，该方法会被put()和putAll()调用来删除最老的键值对。当然，如果你已经编写了一个可运行的JUnit测试，你也可以随意编写你自己的实现代码。
316. 你可以把List传递给一个接受List
对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以List
List
List
objectList = stringList; //compilation error incompatibletypes
317. Array中可以用泛型吗?
这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。
318. 如何阻止Java中的类型未检查的警告?
如果你把泛型和原始类型混合起来使用，例如下列代码，Java 5的javac编译器会产生类型未检查的警告，例如
List
注意: Hello.java使用了未检查或称为不安全的操作;
这种警告可以使用@SuppressWarnings(“unchecked”)注解来屏蔽。
319. Java中List
原始类型和带参数类型
320. Java中List和List
这道题跟上一道题看起来很像，实质上却完全不同。List 是一个未知类型的List，而List
List listOfAnyType;
List
List
List
listOfAnyType = listOfString; //legal
listOfAnyType = listOfInteger; //legal
listOfObjectType = (List
321. List和原始类型List之间的区别.
该题类似于“原始类型和带参数类型之间有什么区别”。带参数类型是类型安全的，而且其类型安全是由编译器保证的，但原始类型List却不是类型安全的。你不能把String之外的任何其它类型的Object存入String类型的List中，而你可以把任何类型的对象存入原始List中。使用泛型的带参数类型你不需要进行类型转换，但是对于原始类型，你则需要进行显式的类型转换。
List listOfRawTypes = new ArrayList();
listOfRawTypes.add(“abc”);
listOfRawTypes.add(123); //编译器允许这样 – 运行时却会出现异常
String item = (String) listOfRawTypes.get(0); //需要显式的类型转换
item = (String) listOfRawTypes.get(1); //抛ClassCastException，因为Integer不能被转换为String
List
listOfString.add(“abcd”);
listOfString.add(1234); //编译错误，比在运行时抛异常要好
item = listOfString.get(0); //不需要显式的类型转换 – 编译器自动转换
322. 什么是JDBC，在什么时候会用到它？
JDBC的全称是Java DataBase Connection，也就是Java数据库连接，我们可以用它来操作关系型数据库。JDBC接口及相关类在java.sql包和javax.sql包里。我们可以用它来连接数据库，执行SQL查询，存储过程，并处理返回的结果。
JDBC接口让Java程序和JDBC驱动实现了松耦合，使得切换不同的数据库变得更加简单。
323. 有哪些不同类型的JDBC驱动？
有四类JDBC驱动。和数据库进行交互的Java程序分成两个部分，一部分是JDBC的API，实际工作的驱动则是另一部分。
A JDBC-ODBC Bridge plus ODBC Driver（类型1）：它使用ODBC驱动连接数据库。需要安装ODBC以便连接数据库，正因为这样，这种方式现在已经基本淘汰了。
B Native API partly Java technology-enableddriver（类型2）：这种驱动把JDBC调用适配成数据库的本地接口的调用。
C Pure Java Driver for Database Middleware（类型3）：这个驱动把JDBC调用转发给中间件服务器，由它去和不同的数据库进行连接。用这种类型的驱动需要部署中间件服务器。这种方式增加了额外的网络调用，导致性能变差，因此很少使用。
D Direct-to-Database Pure Java Driver（类型4）：这个驱动把JDBC转化成数据库使用的网络协议。这种方案最简单，也适合通过网络连接数据库。不过使用这种方式的话，需要根据不同数据库选用特定的驱动程序，比如OJDBC是Oracle开发的Oracle数据库的驱动，而MySQLConnector/J是MySQL数据库的驱动。
324. JDBC是如何实现Java程序和JDBC驱动的松耦合的？
JDBCAPI使用Java的反射机制来实现Java程序和JDBC驱动的松耦合。随便看一个简单的JDBC示例，你会发现所有操作都是通过JDBC接口完成的，而驱动只有在通过Class.forName反射机制来加载的时候才会出现。
我觉得这是Java核心库里反射机制的最佳实践之一，它使得应用程序和驱动程序之间进行了隔离，让迁移数据库的工作变得更简