转载：[Java面经]干货整理, Java面试题(覆盖Java基础,Java高级,JavaEE,数据库,设计模式等)

原文：

一：继承、抽象类与接口区别、访问控制(private, public, protected，默认)、多态相关
！1、interface和 abstract class的区别
interface是接口，abstract class是抽象类。
1，语法层次
抽象类中可以拥有任意范围的成员数据，可以定义非抽象方法。而接口中只能拥有静态的不能修改的成员数据，同时所有的方法必须是抽象的。
所以说接口是抽象类的一种特例。
2，跨域不同
a,抽象类是对类的整体进行抽象，包括类的属性和行为。接口是对类的局部(行为)进行抽象。
b,抽象类是is-a，跨域的是具有相似特点的类。接口是like-a,可以跨域不同的类。
例如猫、狗可以抽象一个动物类的抽象类，具备叫的方法。鸟、飞机可以实现Fly接口，具备飞的行为。
3，设计层次
抽象类是自下而上的一种设计思想，而接口是自顶而下的一种设计思想。
抽象类中我们要知道子类才能抽象出父类。而接口不同，它只需要定义一个规则即可。

！2、是否可以继承多个接口，是否可以继承多个抽象类
java可以实现多个接口，对于类是单继承体系结构。

%3、Static Nested Class 和 Inner Class的不同
静态内部类没有了指向外部的引用，可以直接被实例化而不需要依附与外部类的实例化。
非静态内部类保留了指向外部的引用，必须依附于外部类的实例化才能够实例化内部类。
静态嵌套类内部中：内部类不能访问外部类的非静态成员。外部类不能直接访问静态类中的属性，需要通过内部类去访问。
非静态内部类中：内部类可以直接访问外部类的属性成员。外部类不能直接访问静态类中的属性，需要通过内部类去访问。
延伸：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个类，所以无论外围类是否已经继承某个类，对内部类都没有影响。
内部类：成员内部类(直接在外部类中)、局部内部类(内部类在方法或者作用域中)、嵌套内部类(static 修饰的内部类)、匿名内部类
这里需要说明一点：局部内部类和匿名内部类访问局部变量时为和需要加final关键字？
局部变量的生命周期与局部内部类的对象的生命周期的不一致性。例如内部类innerClass在方法f()中，而方法f()中定义局部变量i且被内部类使用。
当方法f()运行结束后，局部变量i就已经死亡不存在了，但局部内部类对象可能还存在(直道没有人再引用该对象才会消亡)，这时出现一种情况就是
局部内部类要访问一个已经不存在的局部变量。而当变量被final修饰时，通过final将局部变量"复制"一份，复制品直接作为局部变量中的数据成员。

！4、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
overload重载和override重写是Java多态性的不同表现。
overload是一个类多态性的表现，override是父类与之类多态性的不同表现。
override:子类中定义与父类相同的名称及签名. overload:方法相同方法签名不同。
注意：不能通过访问权限、返回类型、抛出的异常进行重载

！5、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized
static 修饰的方法不能够被重写。

！6、是否可以继承String类
不可以，String是被final修饰的类。

！7、构造器Constructor是否可被override?
构造器不能被继承，所以也不能够被重写。

！8、作用域public,protected,private,以及不写时的区别?
不写时默认是default，这里主要说明这几个作用域的使用范围。
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
这里需要说明的是在同一个package， public、protected、friendly使用范围一致。
而在其他package中，只有子孙类中protected才能被访问。

二：collections相关的数据结构及API
http://cmsblogs.com/?p=106
！1、列举几个Java Collection类库中的常用类
此处应该有Collection类图。
Collection是java.util 中的一个接口。继承自Iterable。
子接口：List、Set、Queue...
实现类：ArrayList、LinkedList、HashSet、TreeSet、Vector、Stack
其他相关类：Iterator、TreeMap、HashTable、HashMap
Collection接口是最基本的集合接口，它不提供直接的实现，Java SDK提供的类都是继承自Collection的"子接口"
如List和Set。Collection所代表的是一种规则，它所包含的元素都必须遵循一条或者多条规则。
如有些允许重复而有些则不能重复、有些必须要按照顺序插入而有些则是散列，有些支持排序但是有些则不支持。

！2、List、Set、Map是否都继承自Collection接口？
List、Set继承自Collection接口，而Map不是。
(1)List 所代表的是有序的Collection。实现List接口的集合主要有：ArratList、LinkedList、Vector、Stack。
(2) Set是一种不包括重复元素的Collection。实现了Set接口的集合有：EnumSet、HashSet、TreeSet。
(3)Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到Value的映射。同时它也没有继承Collection。
实现map的有：HashMap、TreeMap、HashTable、Properties、EnumMap。

！3、HashMap和Hashtable的区别
需查看源码。
1、历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 。
2、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 。
3、值：只有HashMap可以让你将空值作为一个表的条目的key或value 。

1.HashTable的方法是同步的，在方法的前面都有synchronized来同步，HashMap未经同步，所以在多线程场合要手动同步
2.HashTable不允许null值(key和value都不可以) ,HashMap允许null值(key和value都可以)。
3.HashTable有一个contains(Object value)功能和containsValue(Object value)功能一样。
4.HashTable使用Enumeration进行遍历，HashMap使用Iterator进行遍历。
5.HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。
6.哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
而HashMap重新计算hash值，而且用与代替求模：

1 int hash = hash(k);
2 int i = indexFor(hash, table.length);
3 static int hash(Object x) {
4     h ^= (h >>> 20) ^ (h >>> 12);
5     return h ^ (h >>> 7) ^ (h >>> 4);
6 }

&&延展：
A、HashMap与HashSet的关系
1、HashSet底层是采用HashMap实现的：

public HashSet() {
    map = new HashMap<E,Object>();
}

2、调用HashSet的add方法时，实际上是向HashMap中增加了一行(key-value对)，该行的key就是向HashSet增加的那个对象，该行的value就是一个Object类型的常量。

private static final Object preSENT = new Object(); 
public boolean add(E e) { 
    return map.put(e, preSENT)==null; 
} 
public boolean remove(Object o) { 
     return map.remove(o)==preSENT; 
}

B、HashMap 和 ConcurrentHashMap 的关系
关于这部分内容建议自己去翻翻源码，ConcurrentHashMap 也是一种线程安全的集合类，他和HashTable也是有区别的，主要区别就是加锁的粒度以及如何加锁，ConcurrentHashMap 的加锁粒度要比HashTable更细一点。将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

%4、HashMap中是否任何对象都可以做为key,用户自定义对象做为key有没有什么要求？
用户自定义的对象当作key需要实现Map中的hashCode和Equals方法。
HashMap用可以的哈希值来存储和查找键值对。
当插入一个Entry时，HashMap会计算Entry Key 的哈希值。Map会根据这个哈希值把Entry插入到相应的位置。
查找时，HashMap通过计算Key的哈希值到特定的位置查找这个Entry。
如果我们在使用自定义对象做为Key时，我们需要保证当改变对象的状态的时候，不改变它的哈希值。

！5、Collection 和 Collections的区别
Collection 是一个接口，它是各种集合结构的父接口。
Collections是一个包装类，它包含有各种有关集合操作的静态方法。Collcetions不能被实例化，它的构造函数是私有的。
例如：
sort():专门针对LIST进行排序，在实际开发中，我们确实经常需要对一个装有一些对象的LIST进行排序！
min/max():如果，我们想取一个集合中的最小、最大值，如何快速的取到呢？上面的方法将帮我们实现。
reverse():如果，我们仅仅需要得到一个LIST的相反顺序！
Shuffle():通过这个方法，将使得LIST中元素的顺序不可预测，即顺序是随机的，混排的。
synchronizedList():返回指定列表支持的同步（线程安全的）列表。
...

%6、其他的集合类：concurrenthashmap,treemap,treeset,linkedhashmap等。
(1)ConcurrentHashMap:http://www.cnblogs.com/ITtangtang/p/3948786.html
(2)TreeMap:
(3)TreeSet:
(4)LinkedHashMap:

三：异常体系
！1、Error、Exception和RuntimeException的区别，作用又是什么？列举3个以上的RuntimeException
Throwable是java语言中所有错误和异常的超类。它有两个子类：Error、Exception。
Error为错误的意思，是程序无法处理的，如OutOfMemoryErro、ThreadDeath等，出现这种情况你唯一能做的就是听之任之，交由JVM来处理，不过JVM在大多数情况下会选择中止线程。
Exception是程序可以处理的异常，分为CheckedException(受检异常)，另一种是UncheckedException(不受检异常)。其中CheckExpection是发生在编译阶段，必须要使用try...catch(或者throws)，否则编译不通过。
而UnceckedException发生在运行期，具有不确定性，主要是由程序的逻辑问题引起的，难以排查，我们一般需要纵观全局才能够发现这类的异常错误。所以在程序设计中我们需要认真考虑，尽量处理异常，即使产生了异常，也能尽量保证程序朝着有利方向发展。

！2、Java中的异常处理机制的简单原理和应用
(1)当Java程序违反了Java的语义规则时，Java虚拟机就会将发生的错误表示为一个异常。
违反语义规则包括2种情况：
(a)一种是Java类库内置的语义检查。
(b)另一种情况就是Java允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。
(2)所有的异常都是java.lang.Throwable的子类。

！3、内存溢出和内存泄露
http://wade6.iteye.com/blog/1842907
内存溢出：指在指定大小的内存空间，写入了超出大小的数据，从而导致了内存益处。通俗地说，就是内存不够，没办法支持当前程序。
当发生内存益出时，程序将无法进行，强制终止。
内存泄露：指某个程序已不再执行，却始终占用着内存，不释放，从而消耗着资源，称其为内存泄露。
当发生内存泄露，那么可用内存会逐渐减少，从而降低性能。

(a)对于内存的溢出可能发生的情况，大概有几种：
1、在程序中存在死循环，或者循环过多，而产生了过多重复的对象的实例。
2、存在对象的引用，使用完后没有清除，导致Java虚拟机不能回收。
3、一次操作时，在内存中加载了大量的数据，原则上说，在java中，由于它的自动垃圾回收机制，出现内存溢出的可能性并不是很大。

(b)对于内存泄露可能发生的情况，大概有几种：
1、长生命周期的对象持有短生命周期的引用。
这是内存泄露最常见的场景，也是代码设计中经常出现的问题。
例如：在全局静态map中缓存局部变量，且没有清空操作，随着时间的推移，这个map会越来越大，造成内存泄露。
2、修改hashset中对象的参数值，且参数是计算哈希值的字段。
当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段，否则对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中删除当前对象，造成内存泄露。
3、机器的连接数和关闭时间设置。
长时间开启非常耗费资源的连接，也会造成内存泄露。
解决方案：
1、尽早释放无用对象的引用
2、使用字符串处理，避免使用String，应大量使用StringBuffer，每一个String对象都得独立占用内存一块区域
3、尽量少用静态变量，因为静态变量存放在永久代（方法区），永久代基本不参与垃圾回收
4、避免在循环中创建对象
5、开启大型文件或从数据库一次拿了太多的数据很容易造成内存溢出，所以在这些地方要大概计算一下数据量的最大值是多少，并且设定所需最小及最大的内存空间值。

四：其他
！1、String和StringBuffer、StringBuilder的区别
http://www.cnblogs.com/xudong-bupt/p/3961159.html
1，可变与不可变化性
String类中使用字符数组保存字符串，因为有final修饰，所以string是不可变的。
private final char value[];
关于不可变性：http://www.hollischuang.com/archives/1230
StringBUilder和StringBuffer的公共父类是：AbstracStringBuilder类，在AbstracStringBu中也是使用字符数组保存字符串，可知这两种对象都是可变的。
char[] value;

2，是否多线程安全
String中对象是不可变得，也可以理解为常量，显然是线程安全的。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。
StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

！2、String s = “123”;这个语句有几个对象产生
创建了一个对象，将“123”存储到常量池中。
延展：String s = new String("abc")这个语句创建了几个对象？
这种题目主要就是为了考察程序员对字符串对象的常量池掌握与否。上述的语句中是创建了2个对象，第一个对象是”abc”字符串存储在常量池中，第二个对象在JAVA Heap中的 String 对象。

！3、reader和inputstream区别
首先要分清reader和inputstream，一个是读取字符流，一个是读取字节流。
InputStream是表示字节输入流的所有类的超类，Reader是用于读取字符流的抽象类
InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。
即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。
http://blog.sina.com.cn/s/blog_6d3183b50101cri5.html

！4、==和equals的区别
1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较，应用双等号（==）,比较的是他们的值。
2.复合数据类型(类)
当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。
JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。
对于String复写Object的equals方法，只是比较字符串值是否相等：
String类中的equals()方法：

 1 public boolean equals(Object anObject)
 2 {
 3     //如果是同一个对象
 4     if (this == anObject)
 5     {
 6         return true;
 7     }
 8     //如果传递进来的参数是String类的实例
 9     if (anObject instanceof String)
10     {
11         String anotherString = (String)anObject;
12         int n = count;//字符串长度
13         if (n == anotherString.count) //如果长度相等就进行比较
14         {
15             char v1[] = value;//取每一个位置的字符
16             char v2[] = anotherString.value;
17             int i = offset;
18             int j = anotherString.offset;
19             while (n-- != 0) //对于每一位置逐一比较
20             {
21                 if (v1[i++] != v2[j++])
22                 return false;
23             }
24             return true;
25         }
26     }
27     return false;
28 }

%5、hashCode的作用
http://www.cnblogs.com/dolphin0520/p/3681042.html
很多地方都会利用到hash表来提高查找效率。在Java的Object类中有一个方法:
public native int hashCode();
hashCode方法的主要作用是为了配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable。
考虑一种情况，当向集合中插入对象时，如何判别在集合中是否已经存在该对象了？（注意：集合中不允许重复的元素存在）
也许大多数人都会想到调用equals方法来逐个进行比较，这个方法确实可行。但是如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。此时hashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的hashCode方法，得到对应的hashcode值，实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值，如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；如果存在该hashcode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址，所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了，说通俗一点：Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。

%6、hashCode和equals方法的关系
在有些情况下，程序设计者在设计一个类的时候为需要重写equals方法，比如String类，但是千万要注意，在重写equals方法的同时，必须重写hashCode方法。
也就是说对于两个对象，如果调用equals方法得到的结果为true，则两个对象的hashcode值必定相等；
如果equals方法得到的结果为false，则两个对象的hashcode值不一定不同；
如果两个对象的hashcode值不等，则equals方法得到的结果必定为false；
如果两个对象的hashcode值相等，则equals方法得到的结果未知。

？7、Object类中有哪些方法，列举3个以上（可以引导）
妈蛋，这个在我校招也是我参加的第一次面试时问到了，当时觉得怎么会问这么简单的问题，但是最后自己还是回答不全。
Object方法：equals()、toString()、finalize()、hashCode()、getClass()、clone()、wait()、notify()、notifyAll()

！8、char型变量中能不能存贮一个中文汉字?为什么?
CHAR类型变量时能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的。
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

%9、了解过哪些JDK8的新特性，举例描述下相应的特性？
！10、Input/OutputStream和Reader/Writer有何区别？何为字符，何为字节？
！11、如何在字符流和字节流之间转换？
InputStreamReader是字节流向字符流的桥梁，它使用指定的charset读取字节并将其解码为字符。
OutputStreamWriter是字符流通向字节流的桥梁，它使用指定的charset将要写入流中的字符编码成字节，它使用的字符集可以由名称指定或显示给定，否则将接受默认的字符集：

！12、启动一个线程是用run()还是start()?
start()方法是启动（即开辟)一个线程的方法，因此线程的启动必须通过此方法，
而run()方法，只是Thread类的一个方法，它本身并不能开辟线程。

%13、海量数据查询、存储
！14、switch可以使用那些数据类型
A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types (discussed in Enum Types), the String class, and a few special classes that wrap certain primitive types: Character, Byte, Short, and Integer (discussed in Numbers and Strings).

！15、多线程与死锁
实现多线程的几种方式：
继承Thread/实现Runnable接口。
所谓死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

%16、Java的四种引用
！17、序列化与反序列化
！18、自动装箱与拆箱
！19、正则表达式

五：JAVA开发工具、环境的使用
IDE、maven、svn/git、Linux、Firebug

第二部分: Java高级

一：多线程
！1、多线程的实现方式，有什么区别
java中可以通过继承Thread和实现Runnable接口来实现多线程。
两者的区别：
a,一个类只能继承一个父类，存在局限；一个类中可以实现多个接口。
b,在实现Runable接口的时候调用Thread的Thread(Runnable run)或者Thread(Runnable run, String name)构造方法创建进程时，使用同一个Runnable实例，所以建立的多线程的实例变量是可以共享的。

public class RunThread implements Runnable{}
    public static void main(String[] args){
        RunThread thread = new RunThread();
        new Thread(thread).start();
        new Thread(thread).start();
}

c,Runnable接口和Thread之间的联系：
public class Thread extends Object implements Runnable

%2、同步和并发是如何解决的

3、什么叫守护线程，用什么方法实现守护线程（Thread.setDeamon()的含义）
在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)
用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
JVM内部的实现是如果运行的程序只剩下守护线程的话，程序将终止运行，直接结束。所以守护线程是作为辅助线程存在的，主要的作用是提供计数等等辅助的功能。

%4、如何停止一个线程？
终止线程的三种方法：
1. 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
在定义退出标志exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值，
2. 使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。
使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程：
thread.stop();
虽然使用上面的代码可以终止线程，但使用stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，因此，并不推荐使用stop方法来终止线程。
3. 使用interrupt方法中断线程。
使用interrupt方法来终端线程可分为两种情况：
（1）线程处于阻塞状态，如使用了sleep方法。
（2）使用while（！isInterrupted（））{……}来判断线程是否被中断。
在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。下面的代码演示了在第一种情况下使用interrupt方法。
注意：在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个是静态的方法interrupted（），一个是非静态的方法isInterrupted（），这两个方法的区别是interrupted用来判断当前线是否被中断，而isInterrupted可以用来判断其他线程是否被中断。因此，while （！isInterrupted（））也可以换成while （！Thread.interrupted（））。

！5、解释是一下什么是线程安全？举例说明一个线程不安全的例子。解释Synchronized关键字的作用。
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据
在多线程的情况下，由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

！6、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
可进入其他对象的非synchronized方法，但是如果其他有加synchronized的方法将处于阻塞状态。

二：内存结构，GC
！1、gc的概念，如果A和B对象循环引用，是否可以被GC？
两个对象相互引用，是会不会被GC没有直接关系。采用的GC Roots可达性来决定是否会被GC回收。
现在的GC都采用分代收集的方式，不同的区采用不同的算法，大致有：复制，标记-清扫，标记-压缩，标记-清扫-压缩等。

%2、Java中的内存溢出是如何造成的
http://outofmemory.cn/java/OutOfMemoryError/PermGen-space-Java-heap-space-unable-create-new-native-thread
jvm管理的内存大致包括三种不同类型的内存区域：Permanent Generation space（永久保存区域）、Heap space(堆区域)、Java Stacks(Java栈）。
其中永久保存区域主要存放Class（类）和Meta的信息，Class第一次被Load的时候被放入PermGen space区域，Class需要存储的内容主要包括方法和静态属性。
堆区域用来存放Class的实例（即对象），对象需要存储的内容主要是非静态属性。每次用new创建一个对象实例后，对象实例存储在堆区域中，这部分空间也被jvm的垃圾回收机制管理。
而Java栈跟大多数编程语言包括汇编语言的栈功能相似，主要基本类型变量以及方法的输入输出参数。Java程序的每个线程中都有一个独立的堆栈。容易发生内存溢出问题的内存空间包括：Permanent Generation space和Heap space。

第一种OutOfMemoryError： PermGen space
发生这种问题的原意是程序中使用了大量的jar或class，使java虚拟机装载类的空间不够，与Permanent Generation space有关。解决这类问题有以下两种办法：
1,增加java虚拟机中的XX:PermSize和XX:MaxPermSize参数的大小，其中XX:PermSize是初始永久保存区域大小，XX:MaxPermSize是最大永久保存区域大小。如针对tomcat6.0，在catalina.sh 或catalina.bat文件中一系列环境变量名说明结束处（大约在70行左右） 增加一行： JAVA_OPTS=" -XX:PermSize=64M -XX:MaxPermSize=128M" 如果是windows服务器还可以在系统环境变量中设置。感觉用tomcat发布sprint+struts+hibernate架构的程序时很容易发生这种内存溢出错误。使用上述方法，我成功解决了部署ssh项目的tomcat服务器经常宕机的问题。
2,清理应用程序中web-inf/lib下的jar，如果tomcat部署了多个应用，很多应用都使用了相同的jar，可以将共同的jar移到tomcat共同的lib下，减少类的重复加载。这种方法是网上部分人推荐的，我没试过，但感觉减少不了太大的空间，最靠谱的还是第一种方法。
第二种OutOfMemoryError： Java heap space
发生这种问题的原因是java虚拟机创建的对象太多，在进行垃圾回收之间，虚拟机分配的到堆内存空间已经用满了，与Heap space有关。解决这类问题有两种思路：
1,检查程序，看是否有死循环或不必要地重复创建大量对象。找到原因后，修改程序和算法。 我以前写一个使用K-Means文本聚类算法对几万条文本记录（每条记录的特征向量大约10来个）进行文本聚类时，由于程序细节上有问题，就导致了Java heap space的内存溢出问题，后来通过修改程序得到了解决。
2,增加Java虚拟机中Xms（初始堆大小）和Xmx（最大堆大小）参数的大小。如：set JAVA_OPTS= -Xms256m -Xmx1024m

%3、jvm gc如何判断对象是否需要回收，有哪几种方式？
(1)、引数记数 (Reference Counting)
给对象添加一个引用计数其，每有一个地方引用这个对象，计数器值加1，每有一个引用失效则减1。
优点：实现简单、判断效率高。 缺点：难以解决对象之间的循环引用问题。
(2)、可达性分析(Reachability Analysis)
从GC Roots(每种具体实现对GC Roots有不同的定义)作为起点，向下搜索它们引用的对象，可以生成一棵引用树，树的节点视为可达对象，反之视为不可达。
JVM使用“可达性分析算法”来判定一个对象是否会可以被回收，有两个细节需要注意：
1.Java的GC Roots如何定义
Java中GC Roots包括以下几种对象：
a.虚拟机栈（帧栈中的本地变量表）中引用的对象
b.方法区中静态属性引用的对象
c.方法区中常量引用的对象
d.本地方法栈中JNI引用的对象

2.不可达对象一定会被回收吗
不是。
执行垃圾回收前JVM会执行不可达对象的finalize方法，如果执行完毕之后该对象变为可达，则不会被回收它。
但一个对象的finalize方法只会被执行一次。

？4、Java中的内存溢出和C＋＋中的内存溢出，是一个概念吗？
！5、引用计数，对象引用遍历；jvm有哪几种垃圾回收机制？讲讲分代回收机制
引用技术法 Reference Counting：
引用计数器的实现很简单，对于一个对象 A，只要有任何一个对象引用了 A，则 A 的引用计数器就加 1，当引用失效时，引用计数器就减 1。只要对象 A 的引用计数器的值为 0，则对象 A 就不可能再被使用。
引用计数器的实现也非常简单，只需要为每个对象配置一个整形的计数器即可。但是引用计数器有一个严重的问题，即无法处理循环引用的情况。因此，在 Java 的垃圾回收器中没有使用这种算法。
分带回收：Generational Collection

三：CLASSLOADER
！1、ClassLoader的功能和工作模式
Java中的所有类，必须被装载到jvm中才能运行，这个装载工作是由jvm中的类装载器完成的，类装载器所做的工作实质是把类文件从硬盘读取到内存中，JVM在加载类的时候，都是通过ClassLoader的loadClass（）方法来加载class的，loadClass使用双亲委派模式。

四：NIO
？1、IO和NIO本质不同在实际项目使用场景及如何使用

五：其他
？1、hashcode 有哪些算法
%2、反射,是否可以调用私有方法,在框架中的运用
？3、知道范型的实现机制吗？
？4、Socket编程通常出现的异常有哪些，什么情况下会出现
？5、了解JVM启动参数吗？-verbose -Xms -Xmx的意思是什么？
%6、StringBuffer的实现方式，容量如何扩充
%7、代理机制的实现

第三部分: JavaEE

一：Servlet的掌握，包括新的异步Servlet
！1、Servelt的概念。常问http request能获得的参数
Servlet 是一种基于java技术的web组件，是一种基于java的且与第三方平台无关的类。通常，它可以被Web 服务器编译、加载和运行，最后生成动态的资源内容。

%2、servlet中，如何定制session的过期时间？
在web.xml中配置：
<session-config>
<session-timeout>20</session-timeout>
</session-config>
上面这种设置，对整个web应用生效。当客户端20分钟内都没有发起请求时，容器会将session干掉。单位为分钟。

session.setMaxInactiveInterval(30*60);
单位是秒。Session设置产生效果的优先循序是，先程序后配置，先局部后整体。

！3、Servlet中的session工作原理 （禁用cookie如何使用session）
http://dxz.iteye.com/blog/2193399?utm_source=tuicool&utm_medium=referral
session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息。
Cookies是一种能够让网站服务器把少量数据储存到客户端的硬盘或内存，或是从客户端的硬盘读取数据的一种技术。Cookies是当你浏览某网站时，由Web服务器置于你硬盘上的一个非常小的文本文件，它可以记录你的用户ID、密码、浏览过的网页、停留的时间等信息。
session: 当用户请求来自应用程序的 Web 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，服务器将终止该会话。
cookie机制：采用的是在客户端保持状态的方案，而session机制采用的是在服务端保持状态的方案。同时我们看到由于服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助cookie机制来达到保存标识的目的。
session机制：服务器首先检查这个客户端的请求里是否已经包含了一个session标识（session id）如果含有sessionid则说明以前为此客户端创建过session服务器就会把这个按照session Id把session给检索出来（如果检索不到就会重新建立一个session），如果客户端请求不包含session id，
则为此客户端创建一个session并且生成一个与此对应的session id，session id是一个不会重复的字符串，该id会在本次响应客户端的时候传送给客户端。
保存这个session id的方式：
a、可以采用cookie，这样就可以在交互的过程中自动的按照规则把这个表示发送给服务器。一般这个cookie的名字类似于SEEESIONID的，但是cookie可以被人为禁止。
b、所以也经常使用一种使用一种叫做URL重写的技术，就是把sessionid直接附加在URL路径的后面。
c、还有一种技术叫做表单隐藏字段。就是服务器会自动修改表单添加一个隐藏的字段，在表单提交的时候就会把这个session id传递会服务器。
session和cookie的区别：
cookie数据放在客户端，session数据放在服务器端。
cookie不是很安全，别人可以分析存放在本地的cookie并进行cookie欺骗考虑安全性的话应该使用session。
session因为在服务器上保存了很多信息，当在访问量比较大的时候会增加服务器的负担，从这方面考虑应该使用cookie
单个cookie的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie
有人建议将登录信息等重要信息放在session中，非重要的信息可以放在cookie中。

！4、servlet中，filter的应用场景有哪些？
1，通过filter进行全站字符编码过滤
get/post 提交不同。
post 是表单提交
get方法提交的话是将数据带在你的url上面传过去的。
request.setCharacterEncoding("UTF-8");这个是只对post方法有用，如果想对get方法有用就在tomcat配置文件server.xml中Connector元素下设置
URIEncoding="UTF-8"

！5、描述JSP和Servlet的区别、共同点（JSP的工作原理）。
尽管JSP在本质上就是SERVLET,但是两者的创建方式不一样.Servlet完全是JAVA程序代码构成擅长于流程控制和事务处理而通过Servlet
来生成动态网页很不直观;JSP由HTML代码和JSP标签构成可以方便地编写动态网页因此在实际应用中采用Servlet来控制业务流程,而采
用JSP来生成动态网页.在struts框架中,JSP位于MVC设计模式的视图层,而Servlet位于控制层。

服务器在执行jsp的时候，首先把jsp翻译成一个Servlet，所以我们访问jsp时，其实不是在访问jsp，而是在访问jsp翻译过后的那个Servlet

？6、JSP的动态include和静态include
！7、Servlet的生命周期
init service destory

二：WEB框架的掌握(挑其掌握的一种)
！1、Struts中请求的实现过程
！2、MVC概念
%3、谈一下自己最熟悉的web框架？然后就了解的web框架再深入下去
%4、Spring mvc与Struts mvc的区别 （什么是Mvc框架）
？5、Service嵌套事务处理，如何回滚

三：http相关(内部重定向，外部重定向)，http返回码
！1、session和cookie的区别
！2、HTTP请求中Session实现原理？
%3、如果客户端禁止Cookie能实现Session吗？
！4、http get和post区别
GET在浏览器回退时是无害的，而POST会再次提交请求。
GET产生的URL地址可以被Bookmark，而POST不可以。
GET请求会被浏览器主动cache，而POST不会，除非手动设置。
GET请求只能进行url编码，而POST支持多种编码方式。
GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
GET请求在URL中传送的参数是有长度限制的，而POST么有。
对参数的数据类型，GET只接受ASCII字符，而POST没有限制。
GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
GET参数通过URL传递，POST放在Request body中。

！5、在web开发中，用redirect与forward做跳转有什么区别？web应用服务器对用户请求通常返回一些状态码，请描述下分别以4和5开头的状态码
100-199:表示成功接收请求，要求客户端继续提交下一次请求才能完成整个处理过程。
200-299：表示成功接收请求并已完成整个处理过程，常用200.
300-399：为完成请求，客户需进一步细化请求。例如，请求的资源已经移动一个新地址，常用302、307和304
400-499：客户端的请求有错误，常用404.
500-599：服务器出现错误，常用500。

四：spring，ibatis，hibernate相关
？1、Hibernate/Ibatis两者的区别
？2、OR Mapping的概念
%3、hibernate一级和二级缓存是否知道
？4、使用hibernate实现集群部署，需要注意些什么
！5、Spring如何实现AOP和IOC的？
！6、Spring的核心理念是什么？是否了解IOC和AOP
！7、Spring的事务管理 ，Spring bean注入的几种方式
！8、Spring AOP解决了什么问题

五：jboss，tomcat等容器相关
？1、Tomcat和weblogic的最根本的区别
？2、Jboss端口在哪个配置文件中修改

六：web安全，SQL注入，XSS, CSRF等
%1、SQL注入 SQL安全

七：AJAX相关
？1、AJAX感受，有什么缺点？
%2、你使用的是Ajax的那种框架？
？3、Ajax如何解决跨域问题

八：Web Service
？1、简述WebService是怎么实现的

九：JMS
？1、JMS的模式两种模式
队列模式: 一对一
主题(订阅)模式: 一对多

十：其他
？1、Js:confirm()方法
？2、Iframe的优缺点
%3、我们在web应用开发过程中经常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串?（主要是考量有没有碰到过编码问题，问题是如何解决的）
？4、怎么获取到客户端的真实IP?
？5、名词解释：jndi，rmi，jms，事务，如果有了解的话可以深入
？6、WEB层如何实现Cluster

第四部分: 数据库相关

一：关系模型理论：
！1、范式
？2、rownum和rowid的区别与使用

二：事务相关
%1、Transaction有哪几种隔离级别？（Isolation Level）
？2、Global transaction的原理是什么?
！3、事务是什么？

三：并发控制
%1、乐观锁，悲观锁

四：ORACLE或MYSQL题目
！1、分页如何实现（Oracle，MySql）
！2、Mysql引擎

五：其他
%1、数据库操作的性能瓶颈通常在哪里, 1000万级别访问，在数据库和java程序上考虑哪些来进行性能优化
%2、性能方面。多数结合多线程、同步来问，以提取一张大表数据来作为例子 解决性能的方法
！3、表关联时，内连接，左连接，右连接怎么理解？
！4、Statement和PreparedStatement之间的区别
！5、用JDBC怎样从数据库中查询一条记录
%6、索引以及索引的实现(B+树介绍、和B树、R树区别

第五部分: 设计模式

一：高内聚，低耦合方面的理解
？1、在项目中是否采用分层的结构，是怎样划分的，各层之间采用了哪些相关技术？ 对哪些设计模式比较熟悉？
%2、什么是低耦合和高聚合？封装原则又是什么意思？
%3、类A依赖类B，会产生什么问题？怎样解除这种耦合？

二：设计模式方面
%1、谈一下自己了解或者熟悉的设计模式
！2、Singleton的几种实现方式
？3、工厂模式和抽象工厂模式之间的区别
！4、简述M-V-C模式解决了什么问题？

三：其他
%1、说说你所知道的UML图，在项目中是如何运用

第六部分: 其他清单 只有题目

J2SE基础
1. 九种基本数据类型的大小，以及他们的封装类。
（2）byte——1 byte——Byte
（3）short——2 bytes——Short
（4）int——4 bytes——Integer
（5）long——8 bytes——Long
（6）float——4 bytes——Float
（7）double——8 bytes——Double
（8）char——2 bytes——Character
static Integer valueOf(int i) : 切记-127--+127范围， 使用cache


2. Switch能否用string做参数？
可以。在 Java 7之前，switch 只能支持 byte、short、char、int或者其对应的封装类以及 Enum 类型。
在 Java 7中，String支持被加上了。

3. equals与==的区别。
在java中的数据类型可以分为两类。
1，基本数据类型，他们之间的比较用==表示比较它们的值。
2，引用数据类型，当使用==进行比较时，比较的是它们内存中的存放地址是否相同。而equals内部也是直接引用的==。
但是equals是Object中的方法， 我们可以通过复写来改变equals的用法， 比如String中的equals只是比较两个变量的值是否相等：
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = offset;
            int j = anotherString.offset;
            while (n-- != 0) {
                if (v1[i++] != v2[j++])
                    return false;
            }
            return true;
        }
    }
    return false;
}


4. Object有哪些公用方法？
equals(), toString(), hashCode(), getClass(), notify(), notifyAll(), wait(), finalize(), clone()

5. Java的四种引用，强弱软虚，用到的场景。


6. Hashcode的作用。(这里来说明equals和hashCode的关联)
如果两个对象相等，那么他们一定有相同的哈希值（hash code）。
如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）
1、equals方法用于比较对象的内容是否相等（覆盖以后）
2、hashcode方法只有在集合中用到
3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。
4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，
   如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，
   如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

7. ArrayList、LinkedList、Vector的区别。
ArrayList: 内部采用数组存储元素，支持高效随机访问，支持动态调整大小
    增删慢，查询快。
LinkedList: 内部采用链表来存储元素，支持快速插入/删除元素，但不支持高效地随机访问.
    增删快，查询慢。
Vector: 可以看作线程安全版的ArrayList

8. String、StringBuffer与StringBuilder的区别。
这里插入知识点：String的intern
直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中
1. String类型是Java内的对象，是个不可变的对象，当每次对String进行改变时都需要生成一个新的String对象，然后将指针指向一个新的对象，如果在一个循环里面，不断的改变一个对象，就要不断的生成新的对象，而且对象多了，Java的垃圾自动回收机制会开始工作，所以效率很低，建议在不断更改String对象的地方不要使用String类型
2. StringBuffer 是个可变的对象，就是每次操作都是对对象本身进行操作，而不用生成新的对象，这样效率肯定就会有有很大的提高，在大部分情况下StringBuffer的效率要比String类型要高
3. StringBuilder 与StringBuffer一样是个可变的字符序列，提供与StringBuffer兼容的API，但是不能保证同步，用在字符串缓冲区被当个线程使用的情况，在单机非多线程的情况下使用StringBuilder会有比较好的效率，因为StringBuilder没有处理同步(Synchronized)问题。StringBuffer则会处理同步问题，如果StringBuilder会在多线程下被操作，则要改用StringBuffer，让对象自行管理同步问题。

9. Map、Set、List、Queue、Stack的特点与用法。
10. HashMap和HashTable的区别。
11. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。
12. TreeMap、HashMap、LindedHashMap的区别。
13. Collection包结构，与Collections的区别。
14. try catch finally，try里有return，finally还执行么？
15. Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。
16. Java面向对象的三个特征与含义。
17. Override和Overload的含义去区别。
18. Interface与abstract类的区别。
19. Static class 与non static class的区别。
20. java多态的实现原理。
21. 实现多线程的两种方法：Thread与Runable。
22. 线程同步的方法：sychronized、lock、reentrantLock等。
23. 锁的等级：方法锁、对象锁、类锁。
24. 写出生产者消费者模式。
25. ThreadLocal的设计理念与作用。
26. ThreadPool用法与优势。
27. Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。
28. wait()和sleep()的区别。
29. foreach与正常for循环效率对比。
30. Java IO与NIO。
31. 反射的作用于原理。
32. 泛型常用特点，List<String>能否转为List<Object>。
33. 解析XML的几种方式的原理与特点：DOM、SAX、PULL。
34. Java与C++对比。
35. Java1.7与1.8新特性。
36. 设计模式：单例、工厂、适配器、责任链、观察者等等。
37. JNI的使用。

JVM
1. 内存模型以及分区，需要详细到每个区放什么。
2. 堆里面的分区：Eden，survival from to，老年代，各自的特点。
3. 对象创建方法，对象的内存分配，对象的访问定位。
4. GC的两种判定方法：引用计数与引用链。
5. GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方，如果让你优化收集方法，有什么思路？
6. GC收集器有哪些？CMS收集器与G1收集器的特点。
7. Minor GC与Full GC分别在什么时候发生？
8. 几种常用的内存调试工具：jmap、jstack、jconsole。
9. 类加载的五个过程：加载、验证、准备、解析、初始化。
10. 双亲委派模型：Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。
11. 分派：静态分派与动态分派。

操作系统
1. 进程和线程的区别。
2. 死锁的必要条件，怎么处理死锁。
3. Window内存管理方式：段存储，页存储，段页存储。
4. 进程的几种状态。
5. IPC几种通信方式。
6. 什么是虚拟内存。
7. 虚拟地址、逻辑地址、线性地址、物理地址的区别

TCP/IP
1. OSI与TCP/IP各层的结构与功能，都有哪些协议。
2. TCP与UDP的区别。
3. TCP报文结构。
4. TCP的三次握手与四次挥手过程，各个状态名称与含义，TIMEWAIT的作用。
5. TCP拥塞控制。
6. TCP滑动窗口与回退N针协议。
7. Http的报文结构。
8. Http的状态码含义。
9. Http request的几种类型。
10. Http1.1和Http1.0的区别
11. Http怎么处理长连接。
12. Cookie与Session的作用于原理。
13. 电脑上访问一个网页，整个过程是怎么样的：DNS、HTTP、TCP、OSPF、IP、ARP。
14. Ping的整个过程。ICMP报文是什么。
15. C/S模式下使用socket通信，几个关键函数。
16. IP地址分类。
17. 路由器与交换机区别。

数据结构与算法
1. 链表与数组。
2. 队列和栈，出栈与入栈。
3. 链表的删除、插入、反向。
4. 字符串操作。
5. Hash表的hash函数，冲突解决方法有哪些。
6. 各种排序：冒泡、选择、插入、希尔、归并、快排、堆排、桶排、基数的原理、平均时间复杂度、最坏时间复杂度、空间复杂度、是否稳定。
7. 快排的partition函数与归并的Merge函数。
8. 对冒泡与快排的改进。
9. 二分查找，与变种二分查找。
10. 二叉树、B+树、AVL树、红黑树、哈夫曼树。
11. 二叉树的前中后续遍历：递归与非递归写法，层序遍历算法。
12. 图的BFS与DFS算法，最小生成树prim算法与最短路径Dijkstra算法。
13. KMP算法。
14. 排列组合问题。
15. 动态规划、贪心算法、分治算法。（一般不会问到）
16. 大数据处理：类似10亿条数据找出最大的1000个数.........等等

基础篇

JAVA基础

1、  JAVA基础

1)      抽象类和接口的区别？

补充问题：JAVA8中为什么要加入默认方法？

2)      静态内部类(static class)的作用？

3)      序列化和反序列化

4)      动态代理和静态代理的区别？

赠送问题：代理模式，什么是代理模式？如何实现？代理模式结构图是怎样的？代理模式应用在什么场景？

5)      nio熟悉吗，nio和io的区别？

6)      java8有哪些新特性？

2、  JAVA API

1)      transient关键字的作用？

2)      volatile关键字的作用？

3)      abstract和final是否可同时使用？

4)      ArrayList、LinkedList、vector的区别？

5)      HashMap、LinkedHashMap，concurrentHashMap的区别，concurrentHashMap为什么特别好用，你看过源码吗？

6)      collection的继承结构，你是否看过源码？

3、  JVM调优(性能)

1)      有哪些调优工具

2)      如何快速定位有问题代码

3)      内存溢出如何处理，如何调优

4)      垃圾回收机制，有哪些垃圾回收算法，如何配置垃圾回收策略

5)      新生代和老年代

4、  Tomcat

tomcat可以稳定支持的最大并发用户数

Tomcat集群如何架设：Tomcat+Apache

集群时特别关注两个问题：

 1：如何实现多应用服务器间的session共享：（一台服务器崩溃，另外一台服务器可以继续支持）

 2：如何分发请求到各个应用服务器实现压力分解：（这里的解决方案是用apache做 web服务器）

 

算法问题

1、  生产者和消费者问题？

2、  查找算法有几种，写出实现代码？

3、  排序算法有几种，写出实现代码？

4、  遍历二叉树，分别按照前序、中序、后续？

5、  红黑树

程序题

1、  写出一个字符串，打印出字符串中字符的所有排序

2、  无序的有重复数据的list变成有序的无重复数据的list

 

框架篇

1、  Spring核心：

 分别说说aop和IOC

事务配置的几种方式？

spring有几种注入方式？

spring依赖注入的四种装配方式？

spring的几个重要注解@Component（不推荐使用）、@Repository、@Service、@Controller

2、  SpringMVC和Struts2：两者的区别

3、  Mybatis和Hibernate：两者的区别

           mybatis如何实现多表关联查询

           mybatis的resultMap

           mybatis的#和$

4、  是否可以用maven搭建项目，maven如何构建web项目？

5、  git的使用

6、  当日志非常大时，如何查找需要的日志？

7、  SSH的局限有哪些

 数据库篇

数据库基础

1、  MySQL和oracle的区别

2、  Oracle移植到mysql需要处理哪些

3、  存储过程

4、  mysql存储引擎innodb和myisam的区别

 

数据库优化

1、  sql优化

2、  索引

关于索引：联合索引A和B，当按照A、A和B、B查询时索引使用情况？

3、  数据库优化，使用过哪些优化工具：常用的SQLYOG、基准测试，expain、status等

具体问题：

           如何找到并定位慢SQL？

           如何确定表和查询是否是最优的？

           枚举类型如何使用，枚举类型的误用带来的损失？

有没有什么工具可以监控数据库，快速查看有问题的sql?如果存在大批量有问题的sql，如何排查？

如何诊断响应差的(太多线程)，僵尸进程(无响应或长时间运行)，或者诊断连接问题？

如果在某段时间内用户反映服务器变慢，如何知道服务器性能差？

           假设已经检查了所有常规信息——内存、磁盘等，而所有这些信息都在正常范围内，没有出现错误和异常，这时，你怎么知道系统是否运行变慢？

 

数据库进阶

1、  当数据库存储数据出现瓶颈，如何处理？——数据库水平拆分、垂直拆分

2、  说说水平拆分和垂直拆分，什么时候水平拆分，什么时候垂直拆分，分别解决了哪些问题，分别存在哪些不能解决的问题，如何结合使用？

3、  当水平拆分时，到不同的表和库中或不同的分布式服务器上时：不同的表可以联合查询(union)、不同的库可以加上库名进行联合查询；如果需要查询的数据分布在不同的服务器之间，如何查询？如何在存储数据时就将需要同时查询的数据放在同一服务器上(存储时取模或者按照时间分布数据，查询的时候取模或者按照时间查询)

4、  mysql读写分离

5、  数据库集群

 

升级篇

分布式

1、  有哪些分布式框架，对比其性能优劣？

同步调用：RSET(JAX-RS、Spring Boot)、RPC(Thrift、Dubbo、HSF)

异步调用：Kafka、Notify、MetaQ

同步和异步的区别，分别用于什么场景？

2、  dubbo + zookeeper

3、  nosql(redis、memcache、mongodb)

 

大并发的处理

1、  负载均衡

2、  分布式

3、  缓存

4、  数据库分库分表

5、  数据库集群

6、  图片服务器分离

7、  首页静态化

 

大数据问题：

假如每天产生5亿行日志文件，如何搜索到指定内容？

有一个100T大小的文件存放在磁盘中，不借助任何外部存储设备，如何统计指定字符串的个数？

同上，有一个文件，存放每天访问的URL，每天有100万条，如何统计URL的个数？

测试1000万条数据的查询

 

多线程

1、  有哪些多线程的应用场景

2、  你自己有写过多线程吗，在哪些场景

3、  线程池,java提供的线程池有哪几种？

4、  队列

5、  servlet是线程安全的吗，如何改进？

6、  实现同步的几种方式?

 

安全

关于安全方面做了哪些工作？

手机、支付如何保证信息安全？

sql注入问题

如何保证访问URL安全：如何不暴露真实的URL地址；如何防止篡改URL地址；如何防止在URL中SQL注入？

 

设计模式

1、  你熟悉哪些设计模式

2、  框架中用到哪些设计模式

           JAVA IO：装饰器模式(Decorator)、适配器模式(Adapt)

           Spring ：访问者模式(Visitor)、代理模式(Proxy)、策略模式(Strategy)

           SpringMVC：模版模式(TempleteMethod)

           Mybatis： 简单工厂模式、工厂方法模式(FactoryMethod)、抽象工厂模式(Abstract Factory)

           Tomcat：门面模式、观察者模式(Observer)、命令模式(Command)、责任链模式(chainof responsible)

           Velocity ：合成模式
3、  装饰模式和适配器模式的区别
4、  写一个单例模式
 

linux
1、会使用哪些命令
查看端口是否被占用
如何查看指定的日志


网络
1、  通信协议是否有了解，TCP/UDP等、HTTP
2、  http反向代理


业务篇
1、  订单：大并发问题

2、  订单或产品数据量变大之后如何优化

3、  交易付款如何操作

4、  与物流接口

5、  画出你负责的项目的架构图