Java中如何实现代理机制(JDK、CGLIB)
JDK动态代理：代理类和目标类实现了共同的接口，用到InvocationHandler接口。
CGLIB动态代理：代理类是目标类的子类，用到MethodInterceptor接口。
多线程的实现方式
继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。
ServletContext,Listener,Filter和自启动Servlet的执行顺序
应用上下文：即程序上下文，也就是整个程序，可以把它想做一个容器，里面可以放各种各样的变量，这个容器能被整个程序共享，一个用户能拥有多个request，一个用户只能拥有一个session，那么这个上下文就是所有用户有且只能拥有一个，类似于spring的容器的概念。
上下文对象即ServletContext，此对象就是应用上下文了，好比spring中的ApplicationContext
我们在应用spring框架进行依赖注入的时候，依赖注入的方式一般分为两种，xml文件配置和注解形式，除了这两种方式外，还可以通过先从ServletContext上下文中将ApplicationContext取到，然后直接通过ApplicationContext.getBean(name)获取你想要的对象。形象的比喻：容器是一口大锅，对象是锅里的饺子，你想吃哪个饺子了直接用勺子去舀就行了，ServletContext就是这么个道理。
自启动servlet：自启动servlet和普通servlet在创建和原理上基本一样，只是在web.xml里面配置稍有不同，写过servlet的童孩应该都知道一个servlet要被触发，只有通过请求映射相应url去访问，也就是说servlet的调用时被动的，需要请求触发。
自启动servlet的触发则是在项目启动的时候，初始化方法就执行了，看一下web.xml
<servlet>
<servlet-name>testServlet1</servlet-name>
<servlet-class>com.servlet.ServletTest1</servlet-class>
<init-param>
<param-name>testServlet1</param-name>
<param-value>i am testServlet1's param</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
没错，就是多了<load-on-startup>标签，这个servlet就成了自启动servlet，我们可以应用自启动servlet完成一些项目初始化工作，比如在项目启动的时候就将数据库里面一些重要的信息先=加载进内存以作备用，不至于要用的时候才去查数据库降低效率。若一个servlet被配置成了自启动servlet，那么在servlet类里就要重写父类的方法init()，顾名思义就是初始化。
顺序是 listener - filter - servlet
Java中MVC详解以及优缺点总结
MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务数据、逻辑、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。
最典型的MVC就是Jsp + Servlet + JavaBean的模式
优点：分层，结构清晰，耦合性低，大型项目代码的复用性得到极大的提高，开发人员分工明确，提高了开发的效率，维护方便，降低了维护成本。
缺点：简单的小型项目，使用MVC设计反而会降低开发效率，层和层虽然相互分离，但是之间关联性太强，没有做到独立的重用。
面向对象
面向对象是一种思想，世间万物都可以看做一个对象，这里只讨论面向对象编程（OOP），Java是一个支持并发、基于类和面向对象的计算机编程语言，面向对象软件开发的优点：
代码开发模块化，更易维护和修改；
代码复用性强；
增强代码的可靠性和灵活性；
增加代码的可读性。
面向对象的四大基本特性：
抽象：提取现实世界中某事物的关键特性，为该事物构建模型的过程。对同一事物在不同的需求下，需要提取的特性可能不一样。得到的抽象模型中一般包含：属性（数据）和操作（行为）。这个抽象模型我们称之为类。对类进行实例化得到对象。
封装：封装可以使类具有独立性和隔离性；保证类的高内聚。只暴露给类外部或者子类必须的属性和操作。类封装的实现依赖类的修饰符（public、protected和private等）
继承：对现有类的一种复用机制。一个类如果继承现有的类，则这个类将拥有被继承类的所有非私有特性（属性和操作）。这里指的继承包含：类的继承和接口的实现。
多态：多态是在继承的基础上实现的。多态的三个要素：继承、重写和父类引用指向子类对象。父类引用指向不同的子类对象时，调用相同的方法，呈现出不同的行为；就是类多态特性。多态可以分成编译时多态和运行时多态。
抽象、封装、继承和多态是面向对象的基础。在面向对象四大基础特性之上，我们在做面向对象编程设计时还需要遵循有一些基本的设计原则。
线程五状态：新建、就绪、执行、阻塞、死亡
其中，阻塞状态(Blocked)
线程运行过程中，可能由于各种原因进入阻塞状态:
1>线程通过调用sleep方法进入睡眠状态；
2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3>线程试图得到一个锁，而该锁正被其他线程持有；
4>线程在等待某个触发条件；
所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
死亡状态(Dead)
有两个原因会导致线程死亡：
1) run方法正常退出而自然死亡，
2) 一个未捕获的异常终止了run方法而使线程猝死。
线程安全性的五种类别
答：①. 不可变 -- 不可变的对象一定是线程安全的，并且永远也不需要额外的同步。Java 类库中大多数基本数值类如 Integer 、 String 和 BigInteger 都是不可变的。
②. 线程安全 -- 线程安全的对象，由类的规格说明所规定的约束在对象被多个线程访问时仍然有效，不管运行时环境如何排列，线程都不需要任何额外的同步。这种线程安全性保证是很严格的 -- 许多类，如 Hashtable 或者 Vector都不能满足这种严格的定义。
③. 有条件的线程安全 -- 有条件的线程安全类对于单独的操作可以是线程安全的，但是某些操作序列可能需要外部同步。条件线程安全的最常见的例子是遍历由 Hashtable 或者 Vector 或者返回的迭代器。
④. 线程兼容 -- 线程兼容类不是线程安全的，但是可以通过正确使用同步而在并发环境中安全地使用。这可能意味着用一个 synchronized 块包围每一个方法调用，或者创建一个包装器对象，其中每一个方法都是同步的(就像 Collections.synchronizedList() 一样)。许多常见的类是线程兼容的，如集合类 ArrayList 和 HashMap 、 java.text.SimpleDateFormat 、或者 JDBC 类 Connection 和 ResultSet。
⑤. 线程对立 -- 线程对立类是那些不管是否调用了外部同步都不能在并发使用时安全地呈现的类。线程对立很少见，当类修改静态数据，而静态数据会影响在其他线程中执行的其他类的行为，这时通常会出现线程对立。线程对立类的一个例子是调用 System.setOut() 的类。
Java 集合部分都有哪些接口，主要体现了哪些设计模式？
答：Java 集合部分主要有Collection、List、Set、Map、Comparator、Iterator 等，主要体现的设计模式是策略模式和迭代模式
策略模式主要体现在每个接口有不同的实现，可以完成互换，如List 接口下有ArrayList 和LinkedList,在不同的场景下可以互换。
迭代模式主要体现在Iterator 的实现，为不同的数据存储方式(数组、链表、散列表等)提供了统一的访问方式。
Comparator 体现的设计模式是什么？ -- 策略模式，即不改变对象自身，而使用一个策略对象去改变它的行为。
注：策略模式的优缺点是什么：
优点：（1）将具体算法逻辑与客户类分离，（2）避免了大量的if else 判断
缺点：（1）每个算法一个类，产生了太多的类，（2）客户端要知道所有的策略类，以便决定使用哪一个。
JDK、JRE、JVM关系是什么？
JDK（Java Development Kit）即为Java开发工具包，包含编写Java程序所必须的编译、运行等开发工具以及JRE。开发工具如：用于编译java程序的javac命令、用于启动JVM运行java程序的java命令、用于生成文档的javadoc命令以及用于打包的jar命令等等。
JRE（Java Runtime Environment）即为Java运行环境，提供了运行Java应用程序所必须的软件环境，包含有Java虚拟机（JVM）和丰富的系统类库。系统类库即为java提前封装好的功能类，只需拿来直接使用即可，可以大大的提高开发效率。
JVM（Java Virtual Machines）即为Java虚拟机，提供了字节码文件（.class）的运行环境支持。 简单说，就是JDK包含JRE包含JVM。
请写出下面几个表达式的结果，答案可以用10进制或16进制书写
1). 0xaa | 0x55
2). 15 & 240
3). 10 ^ 12
4). -2 >> 1
5). -2 >>> 1
1). 分析：十六进制数用0x⋯⋯来表示，后面一个十六进制位是四位，两个十六进制位为一个字节，最多后面可以有8个十六进制位，32个字节,如：0xFFFFFFFF。 或（“ | ”）运算，全0为0，其他为1。
所以：0xaa 用二进制表示为 10101010 ,0x55 用二进制表示为 01010101 ,按位或之后为 11111111 ，十进制数为255，十六进制数为 0xFF 。
2). 分析：10进制转换成2进制，用该数字除以2，记录商和余数，利用商再次除以2，记录商和余数⋯⋯直到上为0或余数为0停止，余数逆序组成二进制的从低到高位（最后的余数为二进制最低位）。与（“ & ”）运算，全1为1，其他为0 。
所以： 15 等于1111 ，240等于 11110000，15前面用0补齐为00001111 ，按位与之后为 00000000 ，即结果为0
3). 分析： 亦或（“ ^ ”）运算，相同取0，不同取1 。
所以：1010 ^ 1100 =0110 , 十进制表示为6，十六进制表示为 0x06 。
4). 分析： 带符号右移（“ >> ”），即有符号位时，负数符号位补1，正数符号位补0， -2 的二进制求法是正数取反加1，因此 2 的二进制表示为0000 0010 ，取反加一为1111 1110 ，即 -2 的二进制表示。
注： >> , << , >>> , 运算符只针对int型和long型，byte ,short ,char型需要转换成Int型在进行操作。
所以： 带符号右移之后为 1111 1111 ，除符号位之外，减一取反，得到带符号十进 制数为 -1 。
5). 分析：无符号右移 (“ >>> ”) ，即无论正负数，右移之后符号位均补 0 。
所以： -2 的二进制无符号右移一位之后为 0111 1111 1111 1111 1111 1111 1111 1111，即 2^31 - 1,二的三十一次方减一。
注：右移和无符号右移主要区别就在于左面最高位补 0 还是补 1 的问题，无符号右移任何时候最高位都补 0 ， 有符号右移则是正数补 0 ，负数补 1 。（没有无符号左移！）。
解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。
通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM中的栈空间；而通过new关键字和构造器创建的对象则放在堆空间，堆是垃圾收集器管理的主要区域，由于现在的垃圾收集器都采用分代收集算法，所以堆空间还可以细分为新生代和老生代，再具体一点可以分为Eden、Survivor（又可分为From Survivor和To Survivor）、Tenured；方法区和堆都是各个线程共享的内存区域，用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据；程序中的字面量（literal）如直接书写的100、”hello”和常量都是放在常量池中，常量池是方法区的一部分，。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过JVM的启动参数来进行调整，栈空间用光了会引发StackOverflowError，而堆和常量池空间不足则会引发OutOfMemoryError。
接口和抽象类的区别是什么？
从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类可以不实现抽象类的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
状态码
301 - 资源（网页等）被永久转移到其它URL
304（Not Modified）
400 (Bad Request/错误请求)
401 (Unauthorized/未授权)
403 (Forbidden/禁止)
404 (Not Found/未找到)
405 (Method Not Allowed/方法未允许)
406 (Not Acceptable/无法访问)
408 (Request Timeout/请求超时)
500 (Internal Server Error/内部服务器错误)
503 (Service Unavailable/服务无法获得)
504 (Gateway Timeout/网关超时)
八种基本数据类型的大小，以及他们的封装类
八种基本数据类型：int、short、float、double、long、boolean、byte、char。
封装类分别是：Integer、Short、Float、Double、Long、Boolean、Byte、Character。
public static void main(String[] args) {
Integer a = new Integer(3);
Integer b = 3; // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false，比较的是引用两个引用没有引用同一对象
System.out.println(Objects.equals(a, b)); // true，比较的是值
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
}
float f=3.4;是否正确？
答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型，会造成精度损失，
因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;
使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。
静态变量和实例变量的区别？
在语法定义上的区别：
静态变量前要加 static 关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
静态变量不属于某个实例对象，而是属于类， 所以也称为类变量，只要程序加载了类的字节码，
不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
总之，实例变量必须创建对象后才可以通过这个对象 来使用，静态变量则可以直接使用类名来引用。
静态变量使用时,通过类名.名称, 实例变量必须要初始化后才能使用。实例变量是实例化后才会分配空间,而静态变量当类加载时会分配空间。
是否可以从一个 static 方法内部发出对非 static 方法的调用？
不可以。因为非 static 方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对 象上进行方法调用，
而 static 方法调用时不需要创建对象，可以直接调用。
也就是说，当一 个 static 方法被调用时，可能还没有创建任何实例对象，如果从一个 static 方法中发出对非 static 方法的调用，
那个非 static 方法是关联到哪个对象上的呢？这个逻辑无法成立，所以， 一个 static 方法内部不可以发出对非 static 方法的调用。
非static方法可以访问static方法.static方法不能访问非static方法
"=="和 equals 方法究竟有什么区别？
==如果判断值类型的话，判断内容是否相同。如果判断引用类型则是判断内存地址是否相同
Equals判断值内容是否相等
接口与抽象类的区别？
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的
抽象类可以在不提供接口方法实现的情况下实现接口。
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
final, finally, finalize 的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成 final 类型
finally 是异常处理语句结构的一部分，表示总是执行。
finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可
以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 JVM 不保证此方法总被调用
所有的类都继承于object类，你用过的object类的直接子类有哪些，object类常用的方法有哪些?
①．clone方法
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
②．getClass方法
final方法，获得运行时类型。
③．toString方法
该方法用得比较多，一般子类都有覆盖。
④．finalize方法
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
⑤．equals方法
该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
⑥．hashCode方法
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hashCode()==obj2.hashCode()，但是hashCode相等不一定就满足equals。
不过为了提高效率，应该尽量使上面两个条件接近等价。
⑦．wait方法
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。
wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
⑧．notify方法
该方法唤醒在该对象上等待的某个线程。
⑨．notifyAll方法
该方法唤醒在该对象上等待的所有线程
java 中有几种类型的流？
字节流，字符流。字节流继承于 InputStream OutputStream，
字符流继承于InputStreamReader OutputStreamWriter。在 java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。
什么是线程不安全？如何解决？线程之间如何同步
就是在多个线程共享同一个数据会受到其他线程的干扰。
如何解决:使用线程同步技术， 用上锁(synchronized)。 让一个线程执行完了，在让另一个线程执行。
线程之间同步使用 synchronized、wait 与 notify
集合相关面试题
1.说一下数据结构中的什么是数组？什么是链表？
所谓数组，是相同数据类型的元素按一定顺序排列的集合
数组：存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难，因为数组中间插入，后面的元素需要进行位移。
链表:链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易，按序号进行寻址需要向前或者前后遍历节点。
2.说一下ArrayList底层实现方式？
①ArrayList通过数组实现，一旦我们实例化ArrayList无参数构造函数默认为数组初始化长度为10
②add方法底层实现如果增加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组当中。当新数组无法容纳增加的元素时，重复该过程。是一旦数组超出长度，就开始扩容数组。扩容数组调用的方法 Arrays.copyOf(objArr, objArr.length + 1);
5.ArrayList LinkedList vector 区别
答：1. 对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。
2. 在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
3. LinkedList不支持高效的随机元素访问。
4. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
这两个类都实现了 List 接口(List 接口继承了Collection 接口),他们都是有序集合,即存储在这两个集合中的元素的位置都是有顺序的,相当于一种动态的数组,我们以后可以按位置索引号取出某个元素,并且其中的数据是允许重复的。
ArrayList 与 Vector 的区别,这主要包括两个方面:
(1)同步性:
Vector 是线程安全的,也就是说是它的方法之间是线程同步的,而 ArrayList 是线程序不安全的,它的方法之间是线程不同步的。如果只有一个线程会访问到集合,那最好是使用 ArrayList,因为它不考虑线程安全,效率会高些;如果有多个线程会访问到集合,那最好是使用 Vector,因为不需要我们自己再去考虑和编写线程安全的代码。
(2)数据增长:
ArrayList 与 Vector 都有一个初始的容量大小,当存储进它们里面的元素的个数超过了容量时,就需要加 ArrayList 与 Vector 的存储空间,每次要增加存储空间时,不是只增加一个存储单元,而是增加多个存储单元,每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector 默认增长为原来两倍,而 ArrayList 的增长策略在文档中没有明确规定(从源代码看到的是增长为原来的1.5倍)。
ArrayList 与 Vector 都可以设置初始的空间大小,Vector 还可以设置增长的空间大小,而 ArrayList 没有提供设置增长空间的方法。
Java中的集合包括三大类，它们是Set、List和Map，他们都是接口，它们有各自的实现类。Set的实现类主要有HashSet和TreeSet，List的实现类主要有ArrayList，Map的实现类主要有HashMap和TreeMap。
Set中的对象不按特定方式排序，并且没有重复对象。但它的有些实现类能对集合中的对象按特定方式排序，例如TreeSet类，它可以按照默认排序，也可以通过实现接口来自定义排序方式。
List中的对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象，如通过list.get(i)方式来获得List集合中的元素。
Map中的每一个元素包含一个键对象和值对象，它们成对出现。键对象不能重复，值对象可以重复。
8.List****、****Map****、****Set ****三个接口****,存取元素时****,各有什么特点
list：存储： 有序的 可重复的
访问：可以[for循环]，foreach循环，iterator迭代器 迭代。
set：存储：无序的 不重复的
访问：可以foreach循环，iterator迭代器 迭代
map：存储：存储的是一对一对的映射 ”key=value“，key值 是无序，不重复的。value值可重复
访问：可以map中key值转为为set存储，然后迭代这个set，用map.get(key)获取value
也可以 转换为entry对象 用迭代器迭代
9.****说出****ArrayList,Vector, LinkedList ****的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（[线程安全]），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
10.****去掉一个****Vector ****集合中重复的元素
通过Vector.contains（）方法判断是否包含该元素，如果没有包含就添加到新的集合当中，适用于数据较小的情况下。
11.Collection ****和****Collections ****的区别。
Collection是集合类的上级接口，继承于它的接口主要有Set和List。 Collections是针对集合类的一个帮助类，它提供了一系列静态方法实现了对各种集合的排序，搜索和线程安全等操作。
12.Set 里的元素是不能重复的,那么用什么方法来区分重复与否呢?是用==还是equals()?它们有何区别
set里的元素是不能重复的，用iterator()方法来区分重复与否。
equals 方法（是[String类]从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等。
==用于比较引用和比较基本数据类型时具有不同的功能：
比较基本数据类型，如果两个值相同，则结果为true
而在比较引用时，如果引用指向内存中的同一对象，结果为true
15.请说下Iterator的作用
迭代器可以实现Collection接口的方法，可以一个一个地获取集合中的元素
在遍历集合时 可判断是否有下一个元素
18.HashSet和TreeSet有什么区别，什么时候用它们
区别:HashSet中的元素不能重复,没有顺序
TreeSet中的元素不能重复,但有顺序
当集合中的元素需要排序时,用TreeSet
一般情况下用HashSet,因为不需要排序,速度比TreeSet快
21.比较下集合和数组的优缺点
集合是多个对象的容器,可以将不同数据类型的多个对象组织在一起
数组类型是有相同数据类型的数据集合,数组是很多语言都支持的底层数据结构,性能上是最高的
23.在List里面怎么去掉重复的数？
通过把List里面的数据放入HashSet可以去除重复
25.ArrayList集合加入1万条数据，应该怎么提高效率
因为ArrayList的底层是数组实现,并且数组的默认值是10,如果插入10000条要不断的扩容,耗费时间,所以我们调用ArrayList的指定容量的构造器方法ArrayList(int size) 就可以实现不扩容,就提高了性能
网络通讯部分
7.什么是Http协议无状态协议？怎么解决Http协议无状态协议？
1、无状态协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息
2、无状态协议解决办法： 通过1、Cookie 2、通过Session会话保存。
8.Http协议有什么组成？
请求报文包含三部分：
a、请求行：包含请求方法、URI、HTTP版本信息
b、请求首部字段
c、请求内容实体
响应报文包含三部分：
a、状态行：包含HTTP版本、状态码、状态码的原因短语
b、响应首部字段
c、响应内容实体
10.get与post请求区别？
区别一：get重点在从服务器上获取资源，post重点在向服务器发送数据；
区别二：get传输数据是通过URL请求，以field（字段）= value的形式，置于URL后，并用"?"连接，多个请求数据间用"&"连接，如http://127.0.0.1/Test/login.action?name=admin&password=admin，这个过程用户是可见的；
post传输数据通过Http的post机制，将字段与对应值封存在请求实体中发送给服务器，这个过程对用户是不可见的；
区别三：
Get传输的数据量小，因为受URL长度限制，但效率较高；
Post可以传输大量数据，所以上传文件时只能用Post方式；
区别四：
get是不安全的，因为URL是可见的，可能会泄露私密信息，如密码等；
post较get安全性较高；
区别五：
get方式只能支持ASCII字符，向服务器传的中文字符可能会乱码。
post支持标准字符集，可以正确传递中文字符。
11.Http与Https优缺点？
a、通信使用明文不加密，内容可能被窃听，也就是被抓包分析。
b、不验证通信方身份，可能遭到伪装
c、无法验证报文完整性，可能被篡改
HTTPS就是HTTP加上加密处理（一般是SSL安全通信线路）+认证+完整性保护
12.Http优化
利用负载均衡优化和加速HTTP应用
利用HTTP Cache来优化网站
13.Http协议有那些特征？
1、支持客户/服务器模式；2、简单快速；3、灵活；4、无连接；5、无状态；
JavaWeb基础部分
1.讲下Servlet的执行流程。doGet和doPost的区别
执行流程：
创建servlet对象，通过服务器反射机制创建servlet对象，第一次请求时才会创 建
调用servlet对象的init()方法，初始化servlet的信息，init()方法之后在servlet创建时被调用一次
处理业务（执行doGet、doPost方法）
销毁（调用destory方法销毁）
doGet和doPost都是接受用户请求的方法，doGet处理get请求，doPost处理post请求，doGet用于地址栏提交，doPost用于表单提交，在页面提交数据时，get的数据大小有限制4k，post没有限制，get请求提交的数据会在地址栏显示，post不显示，所以post比get安全.
2.当service有一个实例变量，doGet和doPost去调用这个变量，会出现什么问题，你是如何解决的。
会出现线程不安全问题。无论是doGet还是doPost去调用，服务器端处理的过程都是一样的，那么我们可以把处理过程单独写在另外一个方法handle里，让两个方法都去调用handle，根据不同请求去调用不同的方法。
3.如何处理servlet的线程不安全问题
线程安全就是多线程操作同一个对象不会有问题，线程同步一般来保护线程安全，所以可以在Servlet的线程里面加上同步方法或同步块。（Synchronized）可以保证在同一时间只有一个线程访问，（使用同步块会导致性能变差，最好不去使用实例变量）
4.Jsp的重定向和转发的流程有什么区别
重定向是客户端行为，转发是服务器端行为
重定向时服务器产生两次请求，转发产生一次请求，重定向时可以转发到项目以外的任何网址，转发只能在当前项目里转发
重定向会导致request对象信息丢失。转发则不会
转发的url不会变,request.getRequestDispatch().forward()
重定向的url会改变,response.getRedirect();
5.Jsp和servlet的区别
jsp的可读性强，容易维护，并且jsp在最后会编译成servlet
servlet容易调试
6.Jsp的九大内置对象，三大指令，七大动作的具体功能
JSP九大内置对象:
pageContext ：只对当前jsp页面有效，里面封装了基本的request和session的对象Request ：对当前请求进行封装Session ：浏览器会话对象，浏览器范围内有效Application ：应用程序对象，对整个web工程都有效Out ：页面打印对象，在jsp页面打印字符串Response ：返回服务器端信息给用户Config ：单个servlet的配置对象，相当于servletConfig对象Page ：当前页面对象，也就是thisException ：错误页面的exception对象，如果指定的是错误页面，这个就是异常对象
三大指令：
Page ：指令是针对当前页面的指令Include ：用于指定如何包含另一个页面Taglib ：用于定义和指定自定义标签
七大动作：
Forward，执行页面跳转，将请求的处理转发到另一个页面Param ：用于传递参数Include ：用于动态引入一个jsp页面Plugin ：用于下载javaBean或applet到客户端执行useBean ：使用javaBeansetProperty ：修改javaBean实例的属性值getProperty ：获取javaBean实例的属性值
7.获取页面的元素和值有几种方式，分别说一下
request.getParameter() 返回客户端的请求参数与值request.getParameterNames() 返回所有可用属性名的枚举request.getParameterValues() 返回包含参数的所有值的数组
8.servlet和javaScript的区别，他们分别是什么作用
一个是服务端，一个是客户端
Servlet是独立于平台和协议的服务器端的java应用程序，可以动态生成web页面，并采用响应--请求的模式提供web服务
javaScript是一种解释性语言，用于向html页面提供交互行为，通常被直接嵌入在html页面中
servlet是java语言编写的web应用
js是基于html上的一种解释语言
9.会话跟踪有哪些，他们的区别是什么
Cookie，session和application，Cookie是http对象，客户端与服务端都可以操纵
cookie是在客户端保持状态，session是在服务器端保持状态，由于cookie是保存在客户端本地的，所以数据很容易被窃取，当访问量很多时，使用session则会降低服务器的性能，application的作用域是整个工程里只有一个，可以在不同浏览器之间共享数据，所有人都可以共享，因此application也是不安全的
10.request ，response，session 和 application是怎么用的
Request是客户端向服务端发送请求
Response是服务端对客户端请求做出响应
Session在servlet中不能直接使用，需要通过getSession()创建，如果没有设定它的生命周期，或者通过invildate()方法销毁，关闭浏览器session就会消失
Application不能直接创建，存在于服务器的内存中，由服务器创建和销毁
11.jsp页面跳转
Jsp页面跳转有两种方式，forward和redirect（转发和重定向）；
Forward只能在当前项目里跳转，只产生一次请求，request保存的变量不会丢失，url地址不会改变；
Redirect可跳转到项目以外的任何页面，产生两次请求，request保存的变量会全部丢失，url地址会发生改变，变化为第二个请求的地址会话跟踪
12.如果创建servlet实例不用构造方法，怎么创建一个servlet实例
Web容器会自动为servlet写一个无参的构造器，它使用class.forName("").newInstance()反射来创建servlet实例的
13.Servlet是安全的吗？当service有一个实例变量，doGet和doPost去调用这个变量，会出现什么问题，你是如何解决的
是线程不安全的，因为servlet是单例模式，当多个客户端共同访问的时候线程不安全。
尽量用局部变量，同步块，如果当前字段是不会改变的，用final修饰
数据库部分
慢查询
①.通过命令临时开启慢查询日志
-- 查询是否开启了慢查询
show variables like '%slow%';
-- 开启慢查询日志
set global slow_query_log='ON';
-- 查看慢查询的时间限制(mysql默认的慢查询时间是10秒)
show variables like 'long_query_time';
-- 设置慢查询时间限制(设置慢查询时间限制为1秒)
set long_query_time=1;
-- 慢查询语句(查询超过1秒，日志文件都将记录)
select * from emp where empno=112033
-- 显示慢查询次数
show status like 'slow_queries';
②.通过修改MySql配置文件my.ini
1）.datadir="D:/MySQL5.6/MySQL Server 5.6/data"
log-output=FILE（这个一定要改成FILE，否则慢查询日志不会输出到日志文件）
slow-query-log=on（on表示启用，0表示关闭）
slow_query_log_file="mysql-slow.log"（慢查询日志文件，在上面的datadir目录之下）
long_query_time=1（定义超过1秒的查询就是慢查询，测试时候用，生产环境应该根据实际需要调整在1到10之间的数）
2）.重新启动mysql服务
不过开启慢查询日志记录，将消耗资源，因此，生产环境下，应当按需开启，不应一直开启！！！
2.SQL优化
使用索引
a.使用组合索引时，第一个可以不用和第二个一起作为条件，也会使用组合索引；
b.使用第二个条件不使用第一个条件时，不会使用组合索引；
C.使用第一个和第二个一起查询时会使用组合索引。
②.使用模糊查询like时，在条件前面加%，索引会失效
③.如果条件中有or,即使其中有条件带索引也不会使用。换言之，就是要求使用的所有字段都必须建立索引，建议大家尽量避免使用or关键字
④.如果列类型是字符串，那一定要在条件中将数据用引号包起来，否则不使用索引
⑤．如果mysql估计使用全表扫描要比索引快，则不使用索引
⑥.判断是否为NULL，使用 is NULL,不要使用 =NULL
⑦.group by 分组时不会使用索引，会全表扫描
⑧.group by 分组时，默认会使用升序进行排列，要使分组效率提高，就禁止使用排序（order by NUll）
⑨.in和not in也要慎用，否则会全表扫描，可以使用exits和 not exits代替；对于连续的数值，可以使用between and代替
⑩.应尽量避免在where字句中使用！=或<>,否则会全表扫描
⑪.查询时，避免使用 ，用具体的字段列表代替“”，不要返回用不到的任何字段。
3.添加索引的条件
①．肯定在where条件经常使用
②.该字段的值不是唯一几个值
③．字段内容不是频繁变化
JVM调优
Java内存结构
内存空间分为：方法区、java堆、java栈、本地方法栈
方法区：又称永久区，使用static关键字修饰，存储常量，当class文件加载时创建（初始化），所有线程都会共享，注意线程安全问题。
Java堆：创建对象，new对象、数组存放在堆内存，堆内的所有对象会被共享。根据垃圾回收机制的不同，Java堆有可能拥有不同的结构，最为常见的就是将整个Java堆分为新生代和老年代。其中新生带存放新生的对象或者年龄不大的对象，老年代则存放老年对象。）新生代分为eden区、s0区、s1区，s0和s1也被称为from和to区域，他们是两块大小相等并且可以互相角色的空间。绝大多数情况下，对象首先分配在eden区，在新生代回收后，如果对象还存活，则进入s0或s1区，之后每经过一次新生代回收，如果对象存活则它的年龄就加1，对象达到一定的年龄后，则进入老年代。
③．Java栈：Java栈是一块线程私有的空间，一个栈，一般由三部分组成:局部变量表、操作数据栈和帧数据区
1）局部变量表：用于报错函数的参数及局部变量
2）操作数栈：主要保存计算过程的中间结果，同时作为计算过程中的变量临时的存储空间。
3）帧数据区:除了局部变量表和操作数据栈以外，栈还需要一些数据来支持常量池的解析，这里帧数据区保存着访问常量池的指针，方便计程序访问常量池，另外当函数返回或出现异常时卖虚拟机子必须有一个异常处理表，方便发送异常的时候找到异常的代码，因此异常处理表也是帧数据区的一部分。
JVM参数调优总结
在JVM启动参数中，可以设置跟内存、垃圾回收相关的一些参数设置，默认情况不做任何设置JVM会工作的很好，但对一些配置很好的Server和具体的应用必须仔细调优才能获得最佳性能。通过设置我们希望达到一些目标：
GC的时间足够的小
GC的次数足够的少
发生Full GC的周期足够的长
前两个目前是相悖的，要想GC时间小必须要一个更小的堆，要保证GC次数足够少，必须保证一个更大的堆，我们只能取其平衡。
（1）针对JVM堆的设置，一般可以通过-Xms -Xmx限定其最小、最大值，为了防止垃圾收集器在最小、最大之间收缩堆而产生额外的时间，我们通常把最大、最小设置为相同的值 （2）年轻代和年老代将根据默认的比例（1：2）分配堆内存，可以通过调整二者之间的比率NewRadio来调整二者之间的大小，也可以针对回收代，比如年轻代，通过 -XX:newSize -XX:MaxNewSize来设置其绝对大小。同样，为了防止年轻代的堆收缩，我们通常会把-XX:newSize -XX:MaxNewSize设置为同样大小
（3）年轻代和年老代设置多大才算合理？这个我问题毫无疑问是没有答案的，否则也就不会有调优。我们观察一下二者大小变化有哪些影响
更大的年轻代必然导致更小的年老代，大的年轻代会延长普通GC的周期，但会增加每次GC的时间；小的年老代会导致更频繁的Full GC
更小的年轻代必然导致更大年老代，小的年轻代会导致普通GC很频繁，但每次的GC时间会更短；大的年老代会减少Full GC的频率
如何选择应该依赖应用程序对象生命周期的分布情况：如果应用存在大量的临时对象，应该选择更大的年轻代；如果存在相对较多的持久对象，年老代应该适当增大。但很多应用都没有这样明显的特性，在抉择时应该根据以下两点：（A）本着Full GC尽量少的原则，让年老代尽量缓存常用对象，JVM的默认比例1：2也是这个道理 （B）通过观察应用一段时间，看其他在峰值时年老代会占多少内存，在不影响Full GC的前提下，根据实际情况加大年轻代，比如可以把比例控制在1：1。但应该给年老代至少预留1/3的增长空间
垃圾回收机制
定义
垃圾回收机制就是不定时去java堆内存清理不可达对象（未被引用对象）
2.算法
算法分为：引用计数法、标记清除、标记压缩、复制算法、分代算法。
引用计数法
定义：每个对象在堆内存会有一个标记，默认是15次，gc回收时，对象不可达减1，可达加1，当次数为0时会被回收
优点：引用计数收集器可以很快的执行，交织在程序中运行，对程序需要不被长时间打断的实时环境有利。
缺点：无法检测到循环引用，并且每次加减非常浪费内存。
复制算法
定义：s0和s1将可用内存按容量分为大小相同的两块，每次只使用一块，当这块内存使用完了，就将还存活的复制到另一块内存上去，然后把使用过的内存一次性清理。这样使得每次对一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆指针，按顺序分配内存即可，实现简单，运行高效
缺点：耗费内存，可使用内存降为原来的一半。
标记清除
定义：为每个对象做一个标记（0.可达 1.不可达），对象没有经常使用，将对象标记为1.不可达，直接清除，不具有连续性。
标记压缩：连续性、无碎片，标记清除的升级
❉标记清除和标记压缩用于老年代。
❉应尽量减少垃圾回收机制的执行次数，因为垃圾回收机制执行时会产生卡顿。
Java框架部分
2.说SpringIOC、SpringAOP?
SpringIOC原理
在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成，在没有使用Spring的时候，每个对象在需要使用他的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。
控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。
SpringAOP
面向切面的编程，或AOP，是一种编程技术，允许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。 SpringAop 就是用 Java的动态代理
Aop底层实现原理
默认使用java动态代理来创建aop,这样就可以为任何接口实例创建代理了
当需要代理的类不是代理接口的时候，spring会切换使用CGLib代理，也可以强制使用CGLib代理
3.Spring的底层实现机制是什么？
使用Demo4j（解析XML）+Java反射机制
Demo4j 其实就是解析XML。使用反射机制实例化bean。
5.动态代理与静态代理区别？
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。
Spring注入有那些方式？
Set注入
构造器注入
静态工厂的方法注入
实例工厂的方法注入
7.Spring有那些注解？
@Autowired(按类型注入)
@Resource(按名称注入)
@Service(标示为注入为服务层)
@Controller(标识控制器bean id)
@RequestMapping（表示映射URL路径）
8.一个接口有多个实现类，使用Spring怎么样只注入其中一个实现类？
@Autowired
@Qualifier(“userServiceImpl”)
Private UserService userService
9.简述Spring的优缺点？
Spring 的优点？?
1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦
2.可以使用容易提供的众多服务，如事务管理，消息服务等
3.容器提供单例模式支持
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能
5.容器提供了众多的辅助类，能加快应用的开发
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等
7.spring属于低侵入式设计，代码的污染极低
8.独立于各种应用服务器
9.spring的DI机制降低了业务对象替换的复杂性
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部
缺点:使用到了大量反射机制。反射机制非常占内存
11.Spring为什么要结合使用HandlerMapping以及HandlerAdapter来处理Handler?
符合面向对象中的单一职责原则，代码架构清晰，便于维护，最重要的是代码可复用性高。如HandlerAdapter可能会被用于处理多种Handler。
14.说一下orm与jdbc的区别？
jdbc只是一个java操作数据库的规范接口而已
orm不过是一种思想，对象关系映射。
ORM：是对象关系模型，如hibernate,让你以面向对象的方式去编程。封装了JDBC.
JDBC：是从底层访问数据库服务器。一般银行，金融行业为了安全起见，直接用JDBC访问
24.mybatis的执行流程
①.我们配置mybatis的配置文件，sqlmapConfig.xml这个文件（虽然名称不固定，但是这是约定成俗的写法）。然后通过配置文件，加载mybatis的运行环境，创建SqlSessionFactory的会话工厂（按照单例方式创建，多例也可以，不过浪费资源严重）。
②.通过会话工厂（SqlSessionFactory）去创建会话（SqlSession）。这个接口是线程不安全的，所以建议应用在方法内。
③.调用sqlSession的方法去操作数据库了。操作完成后，进行下事务的commit()的方法。然后释放资源关sqlSession。
25.Mybatis与Hibernate的本质区别和应用场景？
hibernate：是一个标准ORM框架（对象关系映射）。入门门槛较高的，不需要程序写sql，sql语句自动生成了。
对sql语句进行优化、修改比较困难的。
应用场景：适用与需求变化不多的中小型项目，比如：后台管理系统，erp、orm、oa。
mybatis：专注是sql本身，需要程序员自己编写sql语句，sql修改、优化比较方便。mybatis是一个不完全 的ORM框架，虽然程序员自己写sql，mybatis 也可以实现映射（输入映射、输出映射）。
应用场景：适用与需求变化较多的项目，比如：互联网项目。
企业进行技术选型，以低成本 高回报作为技术选型的原则，根据项目组的技术力量进行选择
设计模式部分
1.你熟悉那些设计模式？
总共有23种设计模式
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
企业面试的时候，面试官非常喜欢考单例，而且非常喜欢考手写单例。
List和Set比较，各自的子类比较
对比一：Arraylist与LinkedList的比较
1、ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。
2、因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。
3、LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。
4、因为LinkedList要移动指针,所以查询操作性能比较低。适用场景分析：当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。
对比二：ArrayList与Vector的比较
1、Vector的方法都是同步的，是线程安全的，而ArrayList的方法不是，由于线程的同步必然要影响性能。因此，ArrayList的性能比Vector好。
2、当Vector或ArrayList中的元素超过它的初始大小时，Vector会将它的容量翻倍，而ArrayList只增加50%的大小，这样。ArrayList就有利于节约内存空间。
3、大多数情况不使用Vector，因为性能不好，但是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性。
4、Vector可以设置增长因子，而ArrayList不可以。
适用场景分析：
1、Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。
对比三：HashSet与TreeSet的比较
1.TreeSet 是二叉树实现的，Treeset中的数据是自动排好序的，不允许放入null值 。
2.HashSet 是哈希表实现的，HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束 。
3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例。
适用场景分析：
HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。
JVM的内存结构
根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分。
1、Java虚拟机栈：线程私有；每个方法在执行的时候会创建一个栈帧，存储了局部变量表，操作数栈，动态连接，方法返回地址等；每个方法从调用到执行完毕，对应一个栈帧在虚拟机栈中的入栈和出栈。
2、堆：线程共享；被所有线程共享的一块内存区域，在虚拟机启动时创建，用于存放对象实例。
3、方法区：线程共享；被所有线程共享的一块内存区域；用于存储已被虚拟机加载的类信息，常量，静态变量等。
4、程序计数器：线程私有；是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。
5、本地方法栈：线程私有；主要为虚拟机使用到的Native方法服务。
强引用，软引用和弱引用的区别
1、强引用
最普遍的一种引用方式，如String s = "abc"，变量s就是字符串“abc”的强引用，
只要强引用存在，则垃圾回收器就不会回收这个对象。
2、软引用（SoftReference）
用于描述还有用但非必须的对象，如果内存足够，不回收，如果内存不足，则回收。
一般用于实现内存敏感的高速缓存，软引用可以和引用队列ReferenceQueue联合使用，如果软引用的对象被垃圾回收，
JVM就会把这个软引用加入到与之关联的引用队列中。
3、弱引用（WeakReference）
弱引用和软引用大致相同，弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。
在垃圾回收器线程扫描它所管辖的内存区域的过程中，
一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
短时间内通过弱引用取对应的数据，可以取到，当执行过第二次垃圾回收时，将返回null。弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。
4、虚引用（PhantomReference）
就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。
虚引用与软引用和弱引用的一个区别在于：
虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引，
就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。
springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的
核心：控制反转和面向切面
请求处理流程：
1、首先用户发送请求到前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；
2、页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；
3、前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；
4、前端控制器再次收回控制权，将响应返回给用户。
控制反转如何实现：
我们每次使用spring框架都要配置xml文件，这个xml配置了bean的id和class。spring中默认的bean为单实例模式，通过bean的class引用反射机制可以创建这个实例。因此，spring框架通过反射替我们创建好了实例并且替我们维护他们。A需要引用B类，spring框架就会通过xml把B实例的引用传给了A的成员变量。
BIO、NIO和AIO的区别
Java BIO ： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
Java AIO： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。NIO比BIO的改善之处是把一些无效的连接挡在了启动线程之前，减少了这部分资源的浪费（因为我们都知道每创建一个线程，就要为这个线程分配一定的内存空间）AIO比NIO的进一步改善之处是将一些暂时可能无效的请求挡在了启动线程之前，比如在NIO的处理方式中，当一个请求来的话，开启线程进行处理，但这个请求所需要的资源还没有就绪，此时必须等待后端的应用资源，这时线程就被阻塞了。
适用场景分析：
BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解，如之前在Apache中使用。
NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持，如在 Nginx，Netty中使用。
AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持，在成长中，Netty曾经使用过，后来放弃。
什么是线程死锁？死锁如何产生？如何避免线程死锁？
死锁的介绍：
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。当线程进入对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调用wait方法，才释放资源，在此期间，其他线程将不能进入该代码块。当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁。
死锁的产生的一些特定条件：
1、互斥条件：进程对于所分配到的资源具有排它性，即一个资源只能被一个进程占用，直到被该进程释放 。
2、请求和保持条件：一个进程因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
3、不剥夺条件：任何一个资源在没被该进程释放之前，任何其他进程都无法对他剥夺占用。
4、循环等待条件：当发生死锁时，所等待的进程必定会形成一个环路（类似于死循环），造成永久阻塞。
如何避免：
1、加锁顺序：当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。当然这种方式需要你事先知道所有可能会用到的锁，然而总有些时候是无法预知的。
2、加锁时限：加上一个超时时间，若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试。但是如果有非常多的线程同一时间去竞争同一批资源，就算有超时和回退机制，还是可能会导致这些线程重复地尝试但却始终得不到锁。
3、死锁检测：死锁检测即每当一个线程获得了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此之外，每当有线程请求锁，也需要记录在这个数据结构中。死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁并且锁超时也不可行的场景。
面向对象的特征有哪些方面？
抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。
封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。
多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。
方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2). 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。
Switch能否用string做参数
jdk1.7并没有新的指令来处理switch string，
而是通过调用switch中string.hashCode,将string转换为int从而进行判断。
public class TestString {
static String string = "123";
public static void main(String[] args) {
switch (string) {
case "123":
System.out.println("123");
break;
case "abc":
System.out.println("abc");
break;
default:
System.out.println("defauls");
break;
}
}
}
3.equals与==的区别
使用==比较原生类型如：boolean、int、char等等，使用equals()比较对象。
1、==是判断两个变量或实例是不是指向同一个内存空间。
equals是判断两个变量或实例所指向的内存空间的值是不是相同。
2、==是指对内存地址进行比较。
equals()是对字符串的内容进行比较。
3、==指引用是否相同。
equals()指的是值是否相同。
public static void main(String[] args) {
String a = new String("ab"); // a 为一个引用
String b = new String("ab"); // b为另一个引用,对象的内容一样
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
System.out.println(aa == bb); // true
System.out.println(a == b); // false，非同一对象
System.out.println(a.equals(b)); // true
System.out.println(42 == 42.0); // true
}
public static void main(String[] args) {
Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1.equals(obj2));//false,值不一样
System.out.println(obj1==obj2);//false，引用地址不一样
obj1=obj2;
System.out.println(obj1==obj2);//true
System.out.println(obj2==obj1);//true
}
8.Map、Set、List、Queue、Stack的特点与用法
Map是键值对，键Key是唯一不能重复的，一个键对应一个值，值可以重复。
TreeMap可以保证顺序。
HashMap不保证顺序，即为无序的。
Map中可以将Key和Value单独抽取出来，其中KeySet()方法可以将所有的keys抽取成一个Set。
而Values()方法可以将map中所有的values抽取成一个集合。
Set不包含重复元素的集合，set中最多包含一个null元素。
只能用Lterator实现单项遍历，Set中没有同步方法。
List
有序的可重复集合。
可以在任意位置增加删除元素。
用Iterator实现单向遍历，也可用ListIterator实现双向遍历。
Queue遵从先进先出原则。
使用时尽量避免add()和remove()方法,而是使用offer()来添加元素，使用poll()来移除元素，
它的优点是可以通过返回值来判断是否成功。
LinkedList实现了Queue接口。Queue通常不允许插入null元素。
Stack遵从后进先出原则。
Stack继承自Vector。
它通过五个操作对类Vector进行扩展，允许将向量视为堆栈，它提供了通常的push和pop操作，
以及取堆栈顶点的peek()方法、测试堆栈是否为空的empty方法等。
用法
如果涉及堆栈，队列等操作，建议使用List。
对于快速插入和删除元素的，建议使用LinkedList。
如果需要快速随机访问元素的，建议使用ArrayList。
HashTable 和 HashMap 是 Map 的实现类。
HashTable 是线程安全的，不能存储 null 值。
HashMap 不是线程安全的，可以存储 null 值。
Stack类：继承自Vector，实现一个后进先出的栈。提供了几个基本方法，push、pop、peak、empty、search等。
Queue接口：提供了几个基本方法，offer、poll、peek等。已知实现类有LinkedList、PriorityQueue等。
11.String、StringBuffer与StringBuilder的区别
可变性
String类中使用字符数组保存字符串，private final char value[]，所以string对象是不可变的。
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，
在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。
线程安全性
String中的对象是不可变的，也就可以理解为常量，线程安全。
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，
如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。
StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
性能
每次对String 类型进行改变的时候，都会生成一个新的String 对象，然后将指针指向新的String 对象，性能最低。
StringBuffer每次都会对StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。
相同情况下使用StirngBuilder 相比使用StringBuffer 仅能获得10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
String：适用于少量的字符串操作的情况。
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况。
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况。
StringBuilder：是线程不安全的，而StringBuffer是线程安全的。
这三个类之间的区别主要是在两个方面，即运行速度和线程安全这两方面。
首先说运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String。
再来说线程安全
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的。
如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，
StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，
但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。
所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，
还是建议使用速度比较快的StringBuilder。
12.Spring AOP
通知(Adivce)
通知有5种类型
Before 在方法被调用之前调用
After 在方法完成后调用通知，无论方法是否执行成功
After-returning 在方法成功执行之后调用通知
After-throwing 在方法抛出异常后调用通知
Around 通知了、包含了被通知的方法，在被通知的方法调用之前后调用之后执行自定义的行为
切点（Pointcut）
切点在Spring AOP中确实是对应系统中的方法。
但是这个方法是定义在切面中的方法，一般和通知一起使用，一起组成了切面。
连接点（Join point）
连接点就是你准备在系统中执行切点和切入通知的地方（一般是一个方法，一个字段）
切面（Aspect）
切面是切点和通知的集合，一般单独作为一个类。
通知和切点共同定义了关于切面的全部内容，它是什么时候，在何时和何处完成功能。
引入（Introduction）
引用允许我们向现有的类添加新的方法或者属性
织入（Weaving）
组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。
Spring和其他纯Java AOP框架一样，在运行时完成织入。
上代码
定义主题接口，这些接口的方法可以成为我们的连接点
public interface Subject {
//登陆
public void login();
//下载
public void download();
}
定义实现类,这是代理模式中真正的被代理人（如果你有参与代购，这个就像你在代购中的角色）
public class SubjectImpl implements Subject {
public void login() {
System.err.println("借书中...");
}
public void download() {
System.err.println("下载中...");
}
}
定义切面（切面中有切点和通知）
public class PermissionVerification {
public void canLogin() {
//做一些登陆校验
System.err.println("我正在校验啦！！！！");
}
/**
* 校验之后做一些处理（无论是否成功都做处理）
* @param args 权限校验参数
*/
public void saveMessage() {
//做一些后置处理
System.err.println("我正在处理啦！！！！");
}
}
再来看看我们的SpringAOP.xml文件
<aop:config>
<!-- 这是定义一个切面，切面是切点和通知的集合-->
<aop:aspect id="do" ref="PermissionVerification">
<!-- 定义切点 ，后面是expression语言，表示包括该接口中定义的所有方法都会被执行-->
<aop:pointcut id="point" expression="execution(* wokao666.club.aop.spring01.Subject.*(..))" />
<!-- 定义通知 -->
<aop:before method="canLogin" pointcut-ref="point" />
<aop:after method="saveMessage" pointcut-ref="point" />
</aop:aspect>
</aop:config>
13.数据库索引
索引就像书的目录， 通过书的目录就准确的定位到了书籍具体的内容
在了解数据库索引之前，首先了解一下数据库索引的数据结构基础，B+tree
B＋tree 是一个n叉树，每个节点有多个叶子节点，一颗B+树包含根节点，内部节点，叶子节点。根节点可能是一个叶子节点，也可能是一个包含两个或两个以上叶子节点的节点。
数据库索引是用于提高数据库表的数据访问速度的。
数据库索引的特点：
a）避免进行数据库全表的扫描，大多数情况，只需要扫描较少的索引页和数据页，而不是查询所有数据页。而且对于非聚集索引，有时不需要访问数据页即可得到数据。
b）聚集索引可以避免数据插入操作，集中于表的最后一个数据页面。
c）在某些情况下，索引可以避免排序操作。
想要理解索引原理必须清楚一种数据结构「平衡树」(非二叉)，也就是b tree或者 b+ tree，重要的事情说三遍：“平衡树，平衡树，平衡树”。当然， 有的数据库也使用哈希桶作用索引的数据结构 ， 然而， 主流的RDBMS都是把平衡树当做数据表默认的索引数据结构的。
索引能让数据库查询数据的速度上升， 而使写入数据的速度下降，原因很简单的， 因为平衡树这个结构必须一直维持在一个正确的状态， 增删改数据都会改变平衡树各节点中的索引数据内容，破坏树结构， 因此，在每次数据改变时， DBMS必须去重新梳理树（索引）的结构以确保它的正确，这会带来不小的性能开销，也就是为什么索引会给查询以外的操作带来副作用的原因。
每次给字段建一个新索引， 字段中的数据就会被复制一份出来， 用于生成索引。 因此， 给表添加索引，会增加表的体积， 占用磁盘存储空间。
Java的四个基本特性（抽象、封装、继承，多态）
抽象：就是把现实生活中的某一类东西提取出来，用程序代码表示，我们通常叫做类或者接口。抽象包括两个方面：一个是数据抽象，一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的行为特征。
封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行封装隐藏。封装分为属性的封装和方法的封装。
继承：是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于抽取多类事物的共性。
多态：允许不同类的对象对同一消息做出响应。方法的重载、类的覆盖正体现了多态，简而言之就是一个类创建出的对象有各种形态。
重载和重写的区别
重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；如果父类方法访问修饰符为private则子类中就不是重写。
构造器Constructor是否可被override
构造器不能被重写，不能用static修饰构造器，只能用public private protected这三个权限修饰符，且不能有返回语句。
访问控制符public,protected,private,以及默认的区别
private只有在本类中才能访问；
public在任何地方都能访问；
protected在同包内的类及包外的子类能访问；
默认不写在同包内能访问。
抽象类和接口的区别
语法层次
抽象类和接口分别给出了不同的语法定义。
设计层次
抽象层次不同，抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。
跨域不同
抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a"
关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的，仅仅是实现了接口定义的契约而已，"like-a"的关系。
什么是泛型、为什么要使用以及泛型擦除
泛型，即“参数化类型”。
创建集合时就指定集合元素的类型，该集合只能保存其指定类型的元素，避免使用强制类型转换。
Java编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程即类型擦除。泛型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。
类型擦除的主要过程如下：
1）.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。
2）.移除所有的类型参数。
HashMap实现原理
//HashMap继承AbstractMap抽象类并实现Map接口方法
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
}
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable {
}
public abstract class Dictionary<K,V> {
}
//AbstractMap抽象类实现Map接口
public abstract class yu<K,V> implements Map<K,V> {
}
//Map是一个接口
public interface Map<K,V> {
}
HashMap可以接受null键值和值，而HashTable则不能；HashMap是非synchronized;HashMap很快
HashMap 包含如下几个构造器：
HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。
HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。
initialCapacity：HashMap的最大容量，即为底层数组的长度。
loadFactor：负载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。
默认情况下，数组大小为16，那么当HashMap中元素个数超过16x0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作
我们知道java.util.HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。
具体原理参考文章：
http://zhangshixi.iteye.com/blog/672697
http://www.admin10000.com/document/3322.html
HashTable实现原理
具体原理参考文章：
http://www.cnblogs.com/skywang12345/p/3310887.html
http://blog.csdn.net/chdjj/article/details/38581035
HashMap和HashTable区别
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； HashMap重新计算hash值，而且用与代替求模。
ArrayList和LinkedList区别及使用场景
public class ArrayList<E> extends AbstractList<E> implements List<E>
}
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
}
public abstract class AbstractCollection<E> implements Collection<E> {
}
public interface Collection<E> extends Iterable<E> {
}
public interface Iterable<T> {
}
public class LinkedList<E> extends AbstractSequentialList<E> implements List{
}
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
}
public class Vector<E> extends AbstractList<E> implements List<E>
}
Concurrenthashmap实现原理
具体原理参考文章：
http://www.cnblogs.com/ITtangtang/p/3948786.html
http://ifeve.com/concurrenthashmap/
Error、Exception区别
Error类和Exception类的父类都是throwable类，他们的区别是：
Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
Unchecked Exception和Checked Exception，各列举几个
Unchecked Exception:
a. 指的是程序的瑕疵或逻辑错误，并且在运行时无法恢复。
b. 包括Error与RuntimeException及其子类，如：OutOfMemoryError,
UndeclaredThrowableException, IllegalArgumentException,
IllegalMonitorStateException, NullPointerException, IllegalStateException,
IndexOutOfBoundsException等。
c. 语法上不需要声明抛出异常。
Checked Exception:
a. 代表程序不能直接控制的无效外界情况（如用户输入，数据库问题，网络异常，文件丢失等）
b. 除了Error和RuntimeException及其子类之外，如：ClassNotFoundException,
NamingException, ServletException, SQLException, IOException等。
c. 需要try catch处理或throws声明抛出异常。
如何停止一个线程
参考文章：
http://www.cnblogs.com/greta/p/5624839.html
什么是线程安全
线程安全就是多线程访问同一代码，不会产生不确定的结果。
如何保证线程安全
对非安全的代码进行加锁控制；
使用线程安全的类；
多线程并发情况下，线程共享的变量改为方法级的局部变量。
synchronized如何使用
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
1). 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2). 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3). 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4). 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
synchronized和Lock的区别
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。Lock的锁定是通过代码实现的，而synchronized是在JVM层面上实现的，synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。Lock锁的范围有局限性，块范围，而synchronized可以锁住块、对象、类。
多线程如何进行信息交互
void notify() 唤醒在此对象监视器上等待的单个线程。
void notifyAll() 唤醒在此对象监视器上等待的所有线程。
void wait() 导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。
void wait(long timeout) 导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者超过指定的时间量。
void wait(long timeout, int nanos) 导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
sleep和wait的区别(考察的方向是是否会释放锁)
sleep()方法是Thread类中方法，而wait()方法是Object类中的方法。
sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态，在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备。
a、sleep是让当前线程指定休眠时间，然后继续工作不释放锁
b、让当前线程wait则是等待，直到有线程通知notify（）唤醒他才会重新工作。释放锁
多线程与死锁
死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。
产生死锁的原因：
一.因为系统资源不足。
二.进程运行推进的顺序不合适。
三.资源分配不当。
如何才能产生死锁
产生死锁的四个必要条件：
一.互斥条件：所谓互斥就是进程在某一时间内独占资源。
二.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
三.不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。
四.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
死锁的预防
打破产生死锁的四个必要条件中的一个或几个，保证系统不会进入死锁状态。
一.打破互斥条件。即允许进程同时访问某些资源。但是，有的资源是不允许被同时访问的，像打印机等等，这是由资源本身的属性所决定的。所以，这种办法并无实用价值。
二.打破不可抢占条件。即允许进程强行从占有者那里夺取某些资源。就是说，当一个进程已占有了某些资源，它又申请新的资源，但不能立即被满足时，它必须释放所占有的全部资源，以后再重新申请。它所释放的资源可以分配给其它进程。这就相当于该进程占有的资源被隐蔽地强占了。这种预防死锁的方法实现起来困难，会降低系统性能。
三.打破占有且申请条件。可以实行资源预先分配策略。即进程在运行前一次性地向系统申请它所需要的全部资源。如果某个进程所需的全部资源得不到满足，则不分配任何资源，此进程暂不运行。只有当系统能够满足当前进程的全部资源需求时，才一次性地将所申请的资源全部分配给该进程。由于运行的进程已占有了它所需的全部资源，所以不会发生占有资源又申请资源的现象，因此不会发生死锁。
四.打破循环等待条件，实行资源有序分配策略。采用这种策略，即把资源事先分类编号，按号分配，使进程在申请，占用资源时不会形成环路。所有进程对资源的请求必须严格按资源序号递增的顺序提出。进程占用了小号资源，才能申请大号资源，就不会产生环路，从而预防了死锁。
什么叫守护线程，用什么方法实现守护线程
守护线程是为其他线程的运行提供服务的线程。
setDaemon(boolean on)方法可以方便的设置线程的Daemon模式，true为守护模式，false为用户模式。
Java线程池技术及原理
参考文章：
http://www.importnew.com/19011.html
http://www.cnblogs.com/dolphin0520/p/3932921.html
java并发包concurrent及常用的类
这个内容有点多，参考文章：
并发包诸类概览：http://www.raychase.net/1912
线程池：http://www.cnblogs.com/dolphin0520/p/3932921.html
锁：http://www.cnblogs.com/dolphin0520/p/3923167.html
集合：http://www.cnblogs.com/huangfox/archive/2012/08/16/2642666.html
volatile关键字
用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。
Java语言中的volatile变量可以被看作是一种“程度较轻的
synchronized”；与
synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是synchronized的一部分。锁提供了两种主要特性：互斥（mutual
exclusion）和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的，如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。Volatile变量具有synchronized的可见性特性，但是不具备原子特性。这就是说线程能够自动发现volatile
变量的最新值。
要使volatile变量提供理想的线程安全，必须同时满足下面两个条件：对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。
第一个条件的限制使volatile变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而volatile不能提供必须的原子特性。实现正确的操作需要使x 的值在操作期间保持不变，而volatile
变量无法实现这点。
每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。
read and load 从主存复制变量到当前工作内存
use and assign 执行代码，改变共享变量值
store and write 用工作内存数据刷新主存相关内容
其中use and
assign 可以多次出现，但是这一些操作并不是原子性，也就是在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样。
Java中的NIO，BIO，AIO分别是什么
BIO:同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
NIO:同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
AIO:异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理.AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。
IO和NIO区别
一.IO是面向流的，NIO是面向缓冲区的。
二.IO的各种流是阻塞的，NIO是非阻塞模式。
三.Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。
序列化与反序列化
把对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。
对象的序列化主要有两种用途：
一.把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
二.在网络上传送对象的字节序列。
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。
内存溢出和内存泄漏的区别
内存溢出是指程序在申请内存时，没有足够的内存空间供其使用，出现out of
memory。
内存泄漏是指分配出去的内存不再使用，但是无法回收。
Java内存模型及各个区域的OOM，如何重现OOM
这部分内容很重要，详细阅读《深入理解Java虚拟机》，也可以详细阅读这篇文章http://hllvm.group.iteye.com/group/wiki/2857-JVM
用什么工具可以查出内存泄漏
一. Memory
Analyzer－是一款开源的JAVA内存分析软件，查找内存泄漏，能容易找到大块内存并验证谁在一直占用它，它是基于Eclipse
RCP(Rich Client Platform)，可以下载RCP的独立版本或者Eclipse的插件。
二. JProbe－分析Java的内存泄漏。
三.JProfiler－一个全功能的Java剖析工具，专用于分析J2SE和J2EE应用程序。它把CPU、执行绪和内存的剖析组合在一个强大的应用中，GUI可以找到效能瓶颈、抓出内存泄漏、并解决执行绪的问题。
四. JRockit－用来诊断Java内存泄漏并指出根本原因，专门针对Intel平台并得到优化，能在Intel硬件上获得最高的性能。
五. YourKit-.NET & Java Profiling业界领先的Java和.NET程序性能分析工具。
六.AutomatedQA －AutomatedQA的获奖产品performance profiling和memory debugging工具集的下一代替换产品，支持Microsoft,Borland, Intel, Compaq 和 GNU编译器。可以为.NET和Windows程序生成全面细致的报告，从而帮助您轻松隔离并排除代码中含有的性能问题和内存/资源泄露问题。支持.Net 1.0,1.1,2.0,3.0和Windows 32/64位应用程序。
七.Compuware DevPartner Java Edition－包含Java内存检测,代码覆盖率测试,代码性能测试,线程死锁,分布式应用等几大功能模块
Java内存管理及回收算法
阅读这篇文章：http://www.cnblogs.com/hnrainll/archive/2013/11/06/3410042.html
Java类加载器及如何加载类(双亲委派)
阅读文章：
https://www.ibm.com/developerworks/cn/java/j-lo-classloader/（推荐）
http://blog.csdn.net/zhoudaxia/article/details/35824249
下面继续
https://blog.csdn.net/qq_41701956/article/details/80045532