一、Java基础
1、String类为什么是final的，
运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String
String是单线程的，少量的字符串操作的情况，线程安全的，因为它是不可变的，字符串常量。
StringBuffer：适用于多线程下在字符缓冲区进行大量操作的情况，线程安全，所有方法都有synchronized修饰，可变的。
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况，非线程安全，可变的。
2.反射中，Class.forName和classloader的区别
【java中class.forName()和classLoader都可用来对类进行加载。
class.forName()：将类的.class文件加载到jvm中之外，还会对类进行解释，执行类中的static块。
而classLoader只干一件事情，就是将.class文件加载到jvm中，不会执行static中的内容,只有在newInstance才会去执行static块。
Class.forName(name, initialize, loader)带参函数也可控制是否加载static块。并且只有调用了newInstance()方法采用调用构造函数，创建类的对象
】
【反射：动态获取信息及动态调用对象成员的功能。如在运行状态中，对任意一个类，都能直到它的所有属性和方法；对任意一个对象能调用它的任意方法或修改任意属性。
1、显式加载类：Class.forName(string name)
2、实例化类：Class类newInstance()方法、Constructor类的newInstance()方法
3、执行方法：先获取Method对象：Class类的getMethod(xxx)
再Method类的invoke(Object obj，Object...args)
4、修改属性：Field类的set(Object obj，Object value)
5、修改权限：Field、Method、Constructor的setAccessible(boolean flag)设为true】
[图片上传中...(image.png-b1d0c0-1544507416431-0)]
3.JSP九大内置对象
（1）request对象：封装了客户端的请求信息。是HttpServletRequest类的实例。
（2）response对象：包含了响应客户请求的有关信息。是HttpServletResponse类的实例。
（3）session对象 ：客户端与服务器的一次会话，不是多次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.
（4）out对象：向客户端输出内容常用的对象
（5）page对象：指向当前JSP页面本身，是java.lang.Object类的实例
（6）application对象 ：实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭。它是ServletContext类的实例。
（7）exception对象：当一个页面在运行过程中发生了例外，就产生这个对象。是java.lang.Throwable的对象
（8）pageContext对象：提供了对JSP页面内所有的对象及名字空间的访问，如访问本页的session，或取本页application的某一属性值。
（9)config对象:web.xml中与该页有关的配置信息
4、Servlet：
【【【a. 原理：是JavaWeb应用开发的核心组件，与平台、协议无关，运行在servlet容器中(如Tomcat)，为各种客户请求提供服务。
b. servlet的生命周期：(存在于容器中，容器重启/停止==>servlet重新开始/结束，周期：加载、实例化、初始化 init()、处理请求 service()、卸载destroy() )
(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
Service()方法来响应客户端请求（Service方法会根据请求的method属性来调用doGet（）和doPost（））
(5)卸载：调用destroy方法让servlet自己释放其占用的资源
c. servlet的4个包；
servlet的4个对象：
(1)请求对象(ServletRequest、HttpServletRequest)
(2)响应对象(ServletResponse、HttpServletResponse）
(3)Servlet配置对象（ServletConfig）
(4)Servlet上下文对象（ServletContext）】】】
5、关于.class文件和.java文件：
java编译器在编译java类文件是，会将原有的文本文件 翻译 成 二进制字节码，存在.class文件。
（1）只含一个类/接口的java类文件，编译后只产生一个.class文件。
（2）java类文件存在内部类，编译后产生多个.class文件，命名：外部类名+$+内部类名
（3）java类文件存在多个并行类/接口，编译后产生多个.class文件，且都以类名命名。
6、Java类可以预先加载/按需加载 ——动态加载机制
11、非线性结构：一个结点元素可能有多个直接前驱和多个直接后继（如二维数组、多维数组、广义表、树，二叉树）
线性结构：有序数据元素的集合（如线性表、栈、队列、双队列、数组、串）
13、静态方法只能用静态常量；普通方法可以用静态/普通常量。
14、各种排序算法：
插入（直接、二分、希尔）、选择（简单、堆）、交换（冒泡、快排）、归并、基数。
不稳定：快希选堆
（1）插入排序：直接插入排序（从后往前找，有合适的就插入）O(n^2)
（2）插入排序：二分插入排序（先排好序，由二分查找，合适位置，插入）O(n^2)
（3）插入排序：希尔排序（分组，取增量，O(nlogn)）
（4）选择排序：简单选择排序（每次选最小/大的排最前，O(nlogn)）
（5）选择排序：堆排序（排最大堆，每次堆顶与未排好的最后一个元素交换),O(nlogn)
（6）交换排序：冒泡排序（每次与隔壁的比，否则交换，每轮把最大/小的排最后）O(n^2)
（7）交换排序：快速排序（选基准，分为2部分，前面的都<，后面都>，start，end)（注意：快排每次至少排完n个）O(nlogn)
（8）归并排序：O(nlogn)
(9)基数排序：O(nlog(r)m)
以上排序中，初始数据集的排列顺序对算法的性能无影响的是 堆排序（无影响，我们只要找最好情况和最差情况时间复杂度一样的算法）
数据结构：线性表、栈、队列、串、数组、树、图
17、关于比较：引用类型和基本类型比较，返回false；基本类型之间会相互转化。(byte/short/char ==>int ==> long ==> float ==>double)
关于equals()和==的比较：
【“==”：对引用类型：比较地址；对基本类型：比较值。
“equals”：对引用类型：比较值。】
==：判断两个对象的地址是不是相等，即判断两个对象是不是同一个对象；
equals()：判断两个对象是否相等：
如果类没有覆盖equals()，默认调用Object类的equals()，则等价于通过"==”比较两个对象；
如果类覆盖了equals()：（比如String）则是比较两个对象的内容是否相等；相等返回true；
hashCode和equals的关系：hashCode相等两个类一定相等码？equals呢？相反呢？
equals相等，则hashcode一定相等，反之则不然。
1、对于“不会创建类对应的散列表的数据结构”：hashCode和equals没有关系，这里的equals是比较类的两个对象是否相等；
2、对于“会创建类对应的散列表的数据结构”(HashSet、HashMap、HashTable)：
(a)两个对象相等，即equals()返回true，则其hashCode()也相等
(b)两个对象hashCode()相等，说明哈希散列值相等，但不一定键值对相等(key和value都不一定，可能是哈希冲突)，则equals不一定返回true。
byte、short和char进行运算时会自动提升为int
对 byte b没有final修饰的变量相加会自动提升为int。
对 final byte b，有final修饰的变量相加不会提升类型，还是（byte）
18、方法的重载：
同一个类，方法名相同，方法形参列表不同（参数类型、个数、顺序不同），与方法的返回值类型与访问权限无关。
19、调用构造方法不能Base(xx)，应该是new Base(xx)
同个类中调用该类的构造方法：new Base(xx)，this(xx)
20、基类是抽象类，子类继承基类，但子类没有实现基类的抽象方法，则子类也是抽象类。
抽象类可以有构造方法，但不能直接创建抽象类的实例对象而已， 在继承了抽象类的子类中通过super(参数列表)调用抽象类中的构造方法。
举例子：抽象类父类Animal，子类Cat继承了父类但没有实现基类构造方法，则Cat也是抽象类，且Cat可以有构造函数。但在主函数中：Animal a=new Animal();Cat c=new Cat(); //都是编译错误！！抽象类不能创建实例对象！！
接口没有抽象方法！！接口也不能被实例化
final类不可继承，final属性不可修改，final方法不可重写（可继承）
21、取近似值：ceil:向上取整；floor:向下取整；
round：原数加0.5再向下取整（eg. Math.round(11.5)=12, Math.round(-11.5)=-11）
22、静态类和单例模式？
【都是线程安全的，两者都可直接使用而无须创建对象，都可提交唯一实例。
单例模式是为了创建实例对象，是一种设计思想，通过类的实例的方法运行。
静态类是静态方法集合，可以通过类的方法或类的实例运行，不可以调用其他的实例方法和访问实例成员，不使用关键字this。
当不需要依赖其他类或资源时，使用静态方法；需要依赖其他类的实例或使用某些资源时用单例】
23、XML：通用数据交换格式（平台无关、语言无关、系统无关,重量级，复杂）
XML解析方式：DOM(Document Object Model，将文档转化为对象模型，通过DOM接口随机访问，树模式)、DOM4J(在DOM的基础上)、SAX(顺序模式访问，适合大型文档)、JSON
(轻量级数据交换格式，js object notation。JSON解析方式：fastjson（阿里的）优点：数据格式简单、易读写（字符串、对象）、易解析、支持多种语言）
26、类变量不设置初始值，会设置默认初始值；而局部方法中声明的变量则必须进行初始化，他不会进行默认值赋值。
整数型的默认是 int，带小数的默认是 double 类型
27、HashMap和Hashtable对比：
（1）继承类不同：HashMap继承AbstractMap，Hashtable继承Dictionary
（2）执行效率：HashMap非线程安全，是HashTable的轻量级实现，效率较高；Hashtable线程安全，效率较低
（3）空值：HashMap允许Entry的key和value为null，HashTable不允许，否则报NullPointedException
（4）Hashmap无contains方法，HashTable有contains方法
线程安全/同步：vector stack hashtable enumeration(枚举，相当于迭代器）
28、关于ASCII码：0 ==> 48、A==>65、a==>97
二、多线程
1、假如有Thread1、Thread2、Thread3、Thread4四条线程分别统计C、D、E、F四个盘的大小，所有线程都统计完毕交给Thread5线程去做汇总，应当如何实现？
2、常用的线程池有几种？有什么区别和联系？线程池的实现原理是怎么样的？
【线程池中有若干个准备运行的空闲线程，线程在程序运行的开始创建，可把创建的Runnable对象交给线程池中的线程运行。运行完成，线程转入休眠，有任务则唤醒，所有任务执行结束再关闭线程池。
好处是：减少了重复创建和销毁线程的开销。
实现原理：1、线程池核心线程是否都在执行任务？不是，创建新的工作线程执行任务；是，进入下个流程。
2、线程池判断工作队列是否已满？未满，将任务存储在工作队列中；已满，进入下个流程。
3、线程池里的线程是否都处在工作状态？没有，创建新的工作线程执行任务；已满，则交给饱和策略来处理这个任务。
】
4、线程之间通讯方式：
共享变量方式：wait、notify()、notifyall
队列：生产者、消费者（多个缓冲区）
5、线程池的种类：四种
FixThreadPool：线程数量固定的线程池
CachedThreadPool：线程数量不定的线程池
ScheduledThreadPool：执行定时任务和具有固定周期的重复任务
SingleThreadPool: 只有一个核心线程，它确保所有的任务都在同一个线程中按顺序执行
6、线程进程区别
【进程：资源进行调度和分派的基本单位；
线程：CPU进行调度和分派的单位
一个进程包含多个线程，同一进程的各个线程之间可以共享相同的内存空间，由共享空间实现数据交换、实施其他同步工作。线程是进程的一部分，线程通常与其他线程共享内存空间。进程有独立的内存空间。
进程：程序执行过程；线程：系统中最小的执行单元】
7、进程间怎么通信（管道、信号量、信号、消息队列、套接字、共享内存）
线程间怎么通信（信号量、信号、锁机制）
线程状态，以及转变，
消息队列（RabbitMQ)
8、wait，sleep区别
【1、sleep()可以在任何地方使用，wait()只能在同步块或者同步方法中使用
2、sleep()方法是Thread类的，调用会暂停器线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；
wait()是Object类的方法，调用会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或所有线程，才会进入锁池，不再次获得对象锁才会进入运行状态；
3、sleep()会捕获异常；wait()不会】
9、Object有什么方法？
【clone()、equals()、finalize()（允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作）、getClass()、notify()、notifyAll()、hashCode()、toString()、wait（）】
10、实现线程的四种方式？ （继承Thread，实现Runnable接口，线程池（线程池参数必须知道corePoolSize，maximumPoolSize，任务队列，等待时间这），Callable接口（Future设计模式理解））
11、造成死锁的四个必要条件（互斥、占有且等待、循环等待、不可抢占）
【互斥：任意时刻一个资源只能给一个进程使用；
占有且等待：一个进程在申请它所需要的资源，等待其他资源的时候，继续占有已分配的资源；
不可抢占：对于已经分配给一个进程的资源，其他进程不可以抢占
循环等待：进程之间形成一种头尾相接相互等待资源的循环】
12、如何实现同步，回答Lock，Synchronized，原子类，CAS机制，volatile,
分析区别优势，最好可以自己实现一个锁，通过分析AQS（Lock顶层抽象对列同步器）
13、基本的生产者，消费者问题解决【wait()、notify()】
14、锁有多少种？（对共享数据加锁）
【1、同步锁：synchronized，修饰方法或块，保证同一时刻只有一个线程进行访问；
2、可重入锁：无阻塞同步机制，非线程安全，try-catch语句，ReentrantLock和sychronized是可重入锁。是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class）
3、读写锁/互斥锁：读多写少】
15、乐观锁和悲观锁？
【悲观锁：假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作。(总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。再比如Java里面的同步原语synchronized关键字的实现也是悲观锁。)
乐观锁：假设不会发生并发冲突，只在提交操作时检查是否违反数据完整性。乐观锁不能解决脏读的问题。每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。】
【悲观锁机制存在以下问题：
- 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。
- 一个线程持有锁会导致其它所有需要此锁的线程挂起。
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险。
乐观锁的具体实现细节：冲突检测和数据更新。其实现方式有一种比较典型的就是 Compare and Swap ( CAS )。
eg.CAS 操作中包含三个操作数 —— 需要读写的内存位置（V）、进行比较的预期原值（A）和拟写入的新值(B)。CAS 有效地说明了“ 我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。 】
16、多线程的优缺点？
优点：使程序响应速度更快；当前没有进行处理的任务时/占用大量处理时间的任务可定期将处理器时间让给其他任务；可以随时停止任务；可分别设置各个任务的优先级以优化性能。
缺点：等候使用共享资源时造成程序的运行速度变慢，如打印机；对线程进行管理要求额外的CPU开销；线程死锁。
17、synchronized和lock区别？
（1）synchronized加在方法或代码块上，括号中表示需要锁的对象。Lock需要显示地指定起始位置和终止位置。synchronzied是托管给jvm执行的，Lock锁定是通过代码实现的。
（2）锁的机制不一样。synchronized获得锁和释放的方式都是在块结构中，而且是自动释放锁，发生异常时会自动释放锁而不会导致死锁。而Lock则需要开发人员手动去释放，且必须在finally块中释放（因为如果发生异常时没有主动Unlock释放锁，可能引起死锁）
（3）Lock是一个接口。而synchronized是Java中的关键字，是内置的语言实现；
三、IO（File IO和Socket IO，File IO都是阻塞IO。io是输入输出。
IO流分为字节流（InputSream读、OutputSream写）、字符流(Reader、Writer)。
3、按行读取文件：(File、BufferedReader、FileReader)
String path="F://a.txt";
File file=new FIle(path);
BufferedReader br=new BufferedReader(new FileReader(file));
String s;
while((s=br.readLine())!=null){
System.out.println(s);
}
按字节读取文件，一次读一个字节：(File，InputSream，FileInputSream， int t=in.read();）
File file=new File(filename)；
InputSream in=null;
try{
in=new FIleInputSream(file);
int tempbyte;
while((tempbyte=in.read())!=-1){
输出tempbyte;
}
in.close();
}catch(IOException e){
e.printStackTrace();
}
按字节读文件，一次读多个字节：（File，FileInputSream）
try{
byte[] tempbytes=new byte[100];
int byteread=0;
in=new FileInputStream(fileName);
while((byteread=in.read(tempbytes))!=-1){
System.out.println(tempbytes,0,byteread)
4、记住，只要一读取键盘录入，就用这句话。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
5、io io 和 nio区别
【nio:即new io(JDK1.4引入，相同作用和目的，但效率更高；】
【区别：1、io是面向流的，nio面向缓冲区。
Java io面向流，则每次从流中读一个或多个字节，直到读取所有字节，期间没有被缓存在任何地方，若需要前后移动流中的数据，需先缓存到缓冲区中。nio面向缓冲区，数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。
2、阻塞与非阻塞IO
io流是阻塞的，一个线程读或写时，线程被阻塞直到数据被读取或完全写入。nio时非阻塞模式，但是它是多路复用IO不是非阻塞IO，一个线程可以同时去做其他事情。
3、io无选择器，nio有选择器。nio的选择器允许一个单独的线程来监视多个输入通道，可注册多个通道使用一个选择器，后使用一个单独的线程来"选择"通道，通道里已经有可处理的输入，或选择已准备写入的通道。即用一个线程管理多个通道。】
6、同步／异步主要针对客户端：
同步：就是当客户端发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是说必须一件一件的事情去做，等一件做完了才能去做下一件。
异步：就是当客户端发出一个功能调用时，调用者不用等接收方发出响应。实际处理这个调用的部件在完成后，会通过状态，通知和回调来通知调用者。客户端可以接着去做 后面的事情。
虽然主要是针对客户端，但是服务器端不是完全没有关系的，同步／异步必须配合服务器端才能实现。同步／异步是由客户端自己控制，但是服务器端是否阻塞/非阻塞，客户端完全不需要关心。
阻塞／非阻塞主要是针对服务器端：
阻塞：阻塞调用是指服务器端被调用者调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞：指在不能立即得到结果之前，该调用不会阻塞当前线程。
五、框架
（一）、Spring：
1、原理：【Spring是一个轻量级的IoC和AOP容器框架，Java企业级应用的开源开发框架，主要用于开发Java应用。目的是解决企业应用开发的复杂性，2004年发布】
【优点：轻量级容器框架；（Spring的IOC容器）降低组件间的耦合性。Spring提供了众多辅助类。Spring对主流框架提供了支持（如SpringMVC、Mybatis、Hibernate）；独立于各种应用服务器；Spring的高度开放性，并不强制应用完全依赖于Spring，可自由选用Spring框架的部分或全部。】
2、Spring注入方式：IOC和DI
【DI和IOC是不同时期对spring核心思想的概述。
DI：依赖注入，从容器角度，spring容器依赖外部应用程序注入它所需要的资源；
IOC：控制反转，从应用程序角度，应用程序控制注入spring容器所需要的外部资源。
DI注入方式：setter注入、构造器注入
IOC注入方式：setter注入、构造器注入、注解方式注入
Spring的配置方式：基于xml的配置、基于注解的配置、基于java的配置
为一个Bean注入属性的方式：接口注入、构造器注入、set方法注入
】
3、AOP：面向切面编程，对业务逻辑各个部分进行隔离，降低业务逻辑各部分之间的耦合度，提高程序可重用性，提高开发效率。
在Java中的应用常是动态代理
【涉及到代理模式，代理类和委托类为保持行为的一致性，实现同一接口。比如Person类继承了接口Speakable，想知道Person类实现的speak()方法何时执行，可以再增加一个PersonProxy类，也实现接口Speakable，在其speak()中统计时间。】
主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。
aop在spring中有两中实现的方式一种是xml，一种是基于注解的。】
4、spring中beanFactory和ApplicationContext的联系和区别
【两者都是Spring框架的常用接口
前者是Spring核心工厂，可用于配置、创建、管理bean实例；
后者也称Spring上下文，提供框架的实现，一般用在Spring实现类中，用于访问容器中bean的常用接口；
后者继承前者，是对前者的扩展，一般来说，会比较经常使用到后者】
5、Spring注解：
@Autowired：可修饰setter方法、属性和构造函数，自动连接属性bean
@Transactional 注解：用于事务管理，设置自动提交（注解在类上，则该类中所有方法都纳入事务管理；注解在方法上，该方法纳入事务管理）
@Required：setter方法时，该bean配置时必须放在xml配置中
@Qualifier：修饰属性，指定真正的被装配的bean(在xml中已经配置了该bean 如，@Qualifier("studnet1"))
在基于java配置中会用到两个注解：
@Configuration：注解在类上，说明该类可作为bean定义的来源
@Bean：注解在有返回对象的方法上，说明此对象被注册成为bean
6、将Spring配置到应用开发中有以下三种方式：
基于XML的配置、基于注解的配置、基于Java的配置
7、设计模式：单例模式（Bean默认单例）、工厂模式（BeanFactory创建对象实例）、代理模式（AOP）
8、事务几种实现方式
（1）编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。（不用）
（2）基于 TransactionProxyFactoryBean的声明式事务管理
（3）基于 @Transactional 的声明式事务管理
（4）基于Aspectj AOP配置事务
（二）SpringMVC
1、概念：SpringMVC是一个表现层的框架，是Spring的一个模块，基于MVC架构来简化web应用程序开发的应用开发框架，将model、view和controller三者分离，简化开发。
2、流程：
3、注解：
@RequestMapping
@RequestBody（与json有关，直接返回对象）
@Controller：声明类，控制器
（三）Mybatis：
1、概念
【Mybatis是一个持久层框架，它支持定制化 SQL、存储过程以及高级映射。】
2、XML文件/直接在接口上注解
（四）Struts2：基于POJO的Action的MVC Web框架。它基于当年的Webwork和XWork框架，继承其优点，同时做了相当的改进。
需要action类（model），包含execute()方法
（五）Hibernate：
1、原理：一个开源的、轻量级的ORM工具，对JDBC进行非常轻量级的对象封装，将POJO与数据库表建立映射关系。可自动生成SQL语句，自动执行。
2、优点：开源和轻量级；快速性能。Hibernate框架的性能很快，因为缓存在Hibernate框架内部使用。（两种等级缓存，一级缓存默认启用）。数据库独立查询。自动创建表。简化复杂连接，轻松获取多个表中的数据。提供查询统计和数据库状态（支持查询缓存）
3、工作原理：
【1、读取并解析配置文件
2、读取并解析映射信息，创建sessionFactory
3、打开session
4、创建事务Transaction
5、持久化操作
6、提交事务
7、关闭session和sessionFactory】
（六）JDBC、hibernate和Mybatis区别
【JDBC：较底层，对性能要求较高，流程是注册数据库驱动-->建立数据库连接-->建立statement，sql语句传给statement执行-->返回结果，则放到ResultSet对象中，遍历获取；
Hibernate：在JDBC基础上进行封装，对数据库进行完整性控制，是全自动ORM映射工具，数据库移植性好；将数据库中的数据表映射为持久层的Java对象，对sql语句进行修改和优化较困难；
Mybatis：在JDBC基础上进行封装，灵活使用sql语句，半自动ORM映射工具，需要收到编写sql完成查询关联对象或关联集合。将sql语句中的输入参数和输出参数映射为java对象，sql修改优化较方便。但MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。】
（七） struts2和springMVC的区别
【1、struts2入口是一filter过滤器(StrutsPrepareAndExecuteFilter)；springMVC的核心入口是一个servlet前端控制器(DispatcherServlet)，
2、struts2通过在action类中定义成员变量接收参数,(属性驱动和模型驱动),它只能使用多例模式管理action；
springmvc通过在controller方法中定义形参接收参数,springmvc可以使用单例模式管理controller.
3、struts2是基于类开发的,每个请求过来创建一个action实例,实例对象中有若干个方法。
springmvc是基于方法开发的,注解开发中使用requestMapping将url和方法进行 映射,如果根据url找到controller类的方法生成一个handler处理器对象(只包括一个method)；
开发中建议使用springmvc,springmvc方法更类似service业务方法.
】
六、数据库
（一）基本
1、一些基本的像union和union all的区别、
【union：对两个结果集进行并集操作，去重，同时进行默认规则的排序；
union all：对两个结果集进行并集操作，包括重复行，不进行排序】
left join，right join，full /outer join，inner join区别？ 假设有集合A和B
【left join：A全集+AB的交集
right join：B全集+AB交集
full/outer join：AB并集，对没有匹配的记录，以null作为值
inner join：AB交集】
varchar和char区别：
char长度固定，varchar长度可变，按实际长度存储，而char若实际字符小于设定好的，会自动添加空格来填满。char效率较高；所以尽量使用varchar
（二）数据库性能的优化【创建索引、只返回需要的字段、数据分页、创建存储过程】
这个优化法则归纳为5个层次：
1、 减少数据访问（减少磁盘访问）：如创建索引，并由索引来访问数据
2、 返回更少数据（减少网络传输或磁盘访问）：如只返回需要的字段、进行数据分页处理
3、 减少交互次数（减少网络传输）：使用存储过程优化业务逻辑
4、 减少服务器CPU开销（减少CPU及内存开销）
5、 利用更多资源（增加资源）
三、SQL注入
mybatis#{}和${}区别：
#{}：将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
如：order by #user_id#，
如果传入的值是111,那么解析成sql时的值为order by "111"
如果传入的值是id，则解析成的sql为order by "id".
${}：将传入的数据直接显示生成在sql中。
如：order by $user_id$
如果传入的值是111,那么解析成sql时的值为order by user_id;
如果传入的值是id，则解析成的sql为order by id.
#方式能够很大程度防止sql注入。$方式无法防止Sql注入。
$方式一般用于传入数据库对象，例如传入表名。一般能用#的就别用$.
5、SQL注入：就是通过把SQL命令插入到Web[表单]提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。
举个栗子：
select * from users where username='xxx' and password=md5('admin');
但sql注入时，用户名输入'or 1=1 --' ,密码随意
则 变成了 select * from users where username="or 1=1--" and password=md5(" ")
这里的--相当于将后面的password给注释掉了
即等价于 select* from users where username=“ ” or 1=1
而1=1成立，所以SQL命令变成了select * from users
造成了SQL注入的情况
防止SQL注入的其他方法：
1.（简单又有效的方法）PreparedStatement
采用预编译语句集，其内置了处理sql注入的能力，只要使用其setXXX方法传值即可。（提高了代码的可读性、可维护性，提高了性能 和 安全性
原理：sql注入是对sql语句的准备（编译）过程破坏，而PreparedStatement不再对sql语句解析、准备，只是把输入串作为数据处理，避免了sql注入问题）
2.可用正则表达式
3.字符串过滤
4.jsp中调用该函数检查是否包含非法字符
5.jsp页面判断代码
四、数据库设计有关
如何实现一对多设计，多对多设计
【一对多：在多的里面建立一的字段，比如母亲（一）和孩子（多），在孩子表添加母亲id
多对多：比如老师和学生，建立一个关系表，表id，老师id，学生id即可】
五、数据库存储引擎
myisam非聚集索引，innodb聚集索引（两者都是使用B+树作为索引结构）
【非聚集索引MYISAM：叶节点的数据域存放的是数据记录的地址。索引文件和数据文件分开，主索引和辅助索引都不会影响数据文件。辅助索引和主索引结构上基本相同，但主索引要求key是唯一的，辅助索引key可重复。
检索过程：先按B+树搜索算法找到索引，Key存在，则取其data域的值，以其作为地址读取相应数据记录。
聚集索引INNODB：主索引的数据文件本身就是索引文件，主索引的叶结点包含了完整的数据记录。辅助索引的数据域存放相应记录主键的值而不是地址。(InnoDB的所有辅助索引都引用主键作为data域)
检索过程：辅助索引搜索需要检索两遍索引：首先检索辅助索引获得主键，然后用主键到主索引中检索获得记录。
】
六、嵌套子查询：
1、集合成员资格：in测试元组是否是集合中的成员；not in：测试是否不是集合中的成员。
2、集合的比较：<some,<=some,=some,>some ,all
<>all 等价于not in
3、空关系测试：not exists(B except A)
4、重复元组存在性测试：unique
七、事务：指作为单个逻辑工作单元执行的一系列操作
1 数据库事务的特性【原子性、一致性、隔离性、持久性】
2 数据库事务的隔离级别
【未提交读、不可重复读、可重复读、串行化
事务隔离级别 脏读 不可重复读 幻读
未提交读 是 是 是
不可重复读 否 是 是
可重复读 否 否 是
串行化 否 否 否
1、脏读：事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据
2、不可重复读：事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据时，结果 不一致。（侧重于修改，只需锁住满足条件的行）
3、幻读：系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级，但是系统管理员B就在这个时候插入了一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。（侧重于新增/删除，解决幻读需要锁表）
】
八、索引
1、什么是索引？【索引是对数据库表中一列或多列的值进行排序的一种存储结构。相当于目录】
2、为什么要建立索引？【提高查询效率】
3、为什么索引能提升效率？【索引通过事先排好序，在查找时可以应用二分查找等高效率的算法】
4、索引什么情况会失效？
【1、在where中使用or且其中一个列非索引；
2、对于多列索引，不是使用的第一部分，则不会使用索引
3、like查询是以%开头（以%结尾可以使用索引）
4、列类型是字符串，则一定要在条件中将数据使用’ ‘，否则索引失效
5、当全表扫描比使用索引快时
6、在where中使用!=,<>；
7、where中'='左边运算
此时引擎会放弃使用索引，而改用全表扫描】
like%..%为什么会扫描全表？遵循什么原则？
【因为这样是全模糊查找, 无法使用索引, 所以会扫描全表。
使用了索引的最左原则, 因为索引没生效】
5、索引类型？
【1、普通索引：基本索引，无限制
2、唯一索引：列值唯一，允许空值
3、主键索引：列值唯一，不允许空值，表中只有一个
4、组合索引：多列值组成一个索引，专用于组合搜索
5、全文索引：对文本内容进行分词、搜索】
6、创建索引：
【(1)ALTER TABLE：用于普通索引、唯一索引、主键索引
普通索引：ALTER TABLE student ADD INDEX s_id(id)
唯一索引：ALTER TABLE student ADD UNIQUE(id)
主键索引：ALTER TABLE student ADD PRIMARY KEY（id）
（2）CREATE INDEX：用于普通索引、唯一索引
普通索引：CREATE INDEX id ON student(id)
唯一索引：CREATE UNIQUE INDEX id ON studnet(id) 】
7、删除索引：ALTER TABLE、DROP INDEX
8、作为索引的数据结构：B+树、B树、Hash
为甚么用B+树索引？【数据有序、范围查询。】
索引使用B+和B区别？
【1、单一节点可以存储更多元素，B+树空间利用率更高，查询的I/O数更少；
2、所有查询都要查找到叶子节点，查询性能稳定。（而B树只需要找到匹配的元素即可，可能是中间节点或者叶子节点。因此B-树的查找性能不稳定（最好情况是只查根节点，最坏查到叶子节点），而B+树每次查找都是稳定）
3、所有叶子节点形成有序链表，便于范围查询。（B-树只能依靠繁琐的中序遍历，而B+树只需要在链表上遍历即可。）】
对比B树和B+树?
【B树：叶子节点不含关键字信息，每个非终端节点包含n个关键字信息
B+树：叶子节点按从小到大顺序存放全部关键字，各叶节点顺序连接；所有非叶节点都可看成是叶节点的索引。】
Hash索引：【哈希索引是将索引键通过 Hash 运算之后，将** Hash运算结果的 Hash 值和所对应的行指针信息**存放于一个 Hash 表中。检索时只需一次哈希算法即可立刻定位到相应的位置，速度非常快。
缺点： ②.哈希索引无法用于排序和范围查询（因为数据并不是按照索引值顺序存储的）
③.哈希索引也不支持部分索引列查询，因为哈希索引始终是使用索引列的全部数据进行哈希计算的。 ④.哈希索引只支持等值比较查询，如=，IN()，<=>操作 ，不能范围查询（因为经过相应的 Hash 算法处理之后的 Hash 值的大小关系，并不能保证和Hash运算前完全一样。） ⑤.如果有大量重复键值，则哈希冲突较多，一些索引的维护操作的代价也会更高】
9、建索引的几大原则？
【1、最左前缀匹配原则：
mysql会一直向右匹配直到遇到范围查询（>、<、between、like）就停止匹配。比如a = 1 and b = 2 and c > 3 and d = 4，如果建立（a,b,c,d）顺序的索引，d是用不到索引的，如果建立(a,b,d,c)的索引则都可以用到，a,b,d的顺序可以任意调整。
2、=和in可以乱序
比如a = 1 and b = 2 and c = 3 建立（a,b,c）索引可以任意顺序，mysql的查询优化器会帮你优化成索引可以识别的形式。
3、尽量扩展索引而不要新建索引（如已有a的索引，要加(a,b)的索引，只需修改原索引）
4、尽量选择区分度高的列作为索引
区分度的公式是count(distinct col)/count(*)，表示字段不重复的比例，比例越大我们扫描的记录数越少。】
八、Java虚拟机
（1）Java虚拟机的内存布局（线程共享|线程隔离）
方法区 虚拟机栈 本地方法栈
堆 程序计数器
堆区：只存放类对象，线程共享，new出来的对象。
方法区：线程共享，类信息、常量、静态变量、即时编译器编译后的代码等数据。
运行时常量池：是方法区的一部分，存类的版本、字段、方法、接口等描述信息，存放编译器生成的各种字面量和符号引用，具备动态性。
直接内存：不是虚拟机运行时数据区的一部分，不是java虚拟机规范中定义的内存区域，抛出异常。
程序计数器：线程隔离，当前线程所执行的字节码的行号指示器，唯一一个不抛异常。
栈区：存放方法局部变量，线程隔离，对象引用。
虚拟机栈：线程隔离，局部变量。
String s="abc"; //产生两个对象：1、引用s：栈中的对象；2、“abc：常量池中的对象
String s=new String("abc"); //产生三个对象：1、引用s：栈中的对象；2、“abc”：常量池中的对象；3、new String()：堆中的对象
（2）GC算法及几种垃圾收集器
【GC算法：新生代：复制算法；老年代：标记-清除算法；标记-整理算法
垃圾收集器：Serial、ParNew、Parallel、Scavenge、G1、CMS、Serial old、Parallel old】
（3）类加载机制，也就是双亲委派模型（JVM加载.class文件的原理机制）
即除顶层的启动类加载器外，其他类加载器都有自己的父类加载器，而类加载器父子关系是组合关系。
工作过程：一个类加载器接收加载请求，先委派给父类加载器，最终所有请求会传到启动类加载器。如果父类加载器反馈自己无法完成加载请求，子加载器才尝试自己加载。
启动类加载器
扩展类加载器
应用程序类加载器
自定义类加载器
（4）Java内存模型(JAVA memory model JMM)
Java线程<==>工作内存<==>Save和load操作<==主内存
Java线程<==>工作内存<==>Save和load操作<==主内存
Java线程<==>工作内存<==>Save和load操作<==主内存
（5）Java内存模型三大特性：
1、原子性：基本数据类型的访问读写是具备原子性的；
synchronized块之间的操作也具备原子性（在lock和unlock之间保存了一个范围的原子性保证）
2、可见性：即一个线程修改了共享变量的值，其他线程能立即得知这个修改。
volatile、synchronized、final
【volatile修饰的变量修改完共享变量的值，必须在下一次写之前写回内存；
synchronized：对一个变量执行unlock之前，必须先把此变量同步回主内存中；
final：被final修饰的字段在构造器一旦初始化完成，且构造器没有把“this”的引用传出去，则其他线程也能看见final字段的值。】
3、有序性：volatile、synchronized
【volatile：包含了禁止指令重排序的语义；
synchronized：一个变量在同一时刻只允许一个线程对其进行lock操作。】
volatile：保证了变量对所有线程的可见性，但不一定是线程安全的，eg非原子操作a++等，多线程操作一个变量，它可能同时发生操作，而不是同一时刻只有一个线程在操作。
synchronized：原子性、可见性、有序性
(6)Java的先行发生规则：
1、程序次序规则：按控制流顺序
2、管程锁定规则：一个unlock操作先行于后面对同一个锁的lock操作
3、volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作
4、线程启动规则：Thread对象的start()方法先行于此线程每一个动作
5、线程终止规则：线程所有操作先行发生于对此线程的终止检测。（终止：检测，如Thread.join()、Thread.isAlive()的返回值）
6、线程终端规则：对Interrupt（）方法的调用先行发生于被中断线程的代码检测到中断事件的发生。（检测中断是否发生：Thread.interrupted()）
7、对象终结规则：一个对象的初始化完成先行于它的finalize()方法的开始
8、传递性：A先行于B，B先行于C，则A先行于C
（8）引用 强软弱虚引用分析
强引用：比如Object o=new Object(); 只要存在则对象不会被回收。
软引用：有用但是并非必要的对象，足够则不回收，内存不足则回收。
弱引用：描述并非必须的对象，只被弱引用关联的对象，GC必回收（无论内存是否充足）
虚引用：很弱，被回收时会收到系统通知。
(9) 垃圾回收方法：标记清除 标记整理 复制算法
(10)线程安全：多线程访问某个类时，不管线程之间如何交替执行，总能得到正确执行结果。
线程安全的实现方法：互斥（临界区【线程中访问共享数据的那段代码】、互斥量、信号量）
（11）ThreadLocal：是线程的一个局部变量。
ThreadLocal用于创建线程的本地变量，该变量是线程之间不共享的
(一个Map用于存储每一个线程的变量副本，Map中元素的Key为线程对象，而Value对应线程的变量副本)，ThreadLocal会为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
（12）你知道哪几种垃圾收集器，各自的优缺点，重点讲下cms，g1
【CMS收集器：一款以获取最短回收停顿时间为目标的收集器，是基于“标记-清除”算法实现的，分为4个步骤：初始标记、并发标记、重新标记、并发清除。
G1收集器：面向服务端应用的垃圾收集器，过程：初始标记；并发标记；最终标记；筛选回收。整体上看是“标记-整理”，局部看是“复制”，不会产生内存碎片。 】
(13) 垃圾收集算法：
（老年代）标记-清除算法：先标记出所有需回收的对象，标记完成后统一回收所有被标记的对象。（效率不高，会产生大量不连续的内部碎片）
(新生代)复制算法：将可用内存划分为相等的两块，每次只用一块，用完时将还存活的对象复制到另一块上，一次清理掉所有已用过的内存（简单高效，但内存少了一半）
（老年代）标记-整理算法：先标记出所有需回收的对象，让所有存活的对象都向一端移动，后直接清理掉端边界以外的内存。
（14）类的加载过程：加载-->验证-->准备-->解析-->初始化-->使用-->卸载
（连接：验证--准备--解析）家宴准姐出
【加载：生成java.lang.Class对象；
验证：确保class文件的字节流信息符合JVM需求，如文件格式、元数据、字节码；
准备：为类变量分配内存，设置类变量初始值；
解析：将常量池内符号引用替换为直接引用；
初始化：开始执行类中定义的JAVA程序代码。】
（15）内存区域调节参数：
-Xms：初始堆大小
-Xmx：最大堆大小
-Xmn：年轻代大小
-xx SurvivorRatio：年轻代中Eden区与survivor区的大小比值
九、集合类：
1、List，set，map存取元素的特点？
【1、存放：
List：有序，可重复；
Set：无序，不可重复；
Map：键值对形式存放，键无序不可重复，值可重复
2、取出：
List：for循环，foreach循环，Iterator迭代器迭代；
Set：foreach循环，Iterator迭代器迭代；
Map：需转为Set，再由Iterator迭代器迭代；或转换为Entry对象进行Iterator迭代器迭代】
2、Collection和Collections的差别
【java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。它提供了一系列的静态方法实现对各种集合的搜索、排序、线程安全化等操作。】
3、Java中的队列都有哪些，有什么区别。
【Queue有3种：LinkedBlockingQueue、PriorityQueue、ConcurrentLinkedQueue
LinkedBlockingQueue：基于节点连接，可选是否有界，不允许null，线程安全的阻塞队列，FIFO
PriorityQueue：无界队列，非线程安全，不允许null，非FIFO，每次从队列中取出的是具有最高优先权的元素。入队和出队的时间复杂度是O（log(n)）
ConcurrentLinkedQueue：基于链接节点的无界线程安全队列、FIFO】
4.Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高
LinkedList是一个双向链表结构.线程不安全.适合于中间部位添加和删除.
ArrayList 是一个数组结构.线程不安全.适合于查询和修改，以及尾部的添加和删除.
Vector 是一个数组结构。但是关键的添加，删除等方法都已经用synchronized修饰，是线程安全的.适合于查询，以及尾部的添加和删除.
Vector & ArrayList
1） Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能。因此，ArrayList的性能比Vector好。
2） 当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小。ArrayList就有利于节约内存空间
5 .栈的实际应用：如进制转换(十进制转八进制)
public void Convert(int num){
Stack<Integer> stack=new Stack<>();
while(num>0){
stack.push(num%8);
num/=8;
}
while(!stack.isEmpty()){
System.out.println(stack.pop());
}
}
6、解决Hash（散列）冲突的四种方法：
【（1）开放定址法（线性探测、二次探测、随机探测）：
线性探测法（如ThreadLocalMap）：插入元素时，如果发生冲突，算法会简单的从该槽位置向后循环遍历hash表，直到找到表中的下一个空槽，并将该元素放入该槽中
随机探测：将线性探测的步长从常数改为随机数，即令： hash ＝ (hash ＋ RN) % m ，其中 RN 是一个随机数。
（2）链地址法/拉链法（如Hashmap）：将所有关键字为同义词的结点链接在同一个单链表中。
（3）再哈希：当发生冲突时，使用第二个、第三个、哈希函数计算地址，直到无冲突时。缺点：计算时间增加。
（4）建立公共溢出区：假设哈希函数的值域为[0,m-1],则设向量HashTable[0..m-1]为基本表，另外设立存储空间向量OverTable[0..v]用以存储发生冲突的记录。】
十、计算机网络：
（一）网络结构及对应协议，协议端口
1、多层网络结构
四层：应用层、运输层、数据链路层、网络接口层
五层：应用层、运输层、数据链路层、网络层、物理层
七层：应用层、表现层、会话层、运输层、数据链路层、网络层、物理层
2、各层网络协议
应用层：HTTP(80)、HTTPS(443)、POP3(110)、FTP(21)、DNS、Telnet
运输层：UDP、TCP
网络层：ARP、ICMP
3、运输层协议
（1）运输层协议所对应的应用层协议，及对应的端口
TCP： POP3(110) HTTP(80) HTTPS(443) FTP(21) Telnet SMTP
UDP：SNMP DNS
（2）运输层协议对比？
tcp和udp区别？
【1、tcp面向连接；udp无连接
2、tcp面向字节流；udp面向数据报
3、tcp可靠运输；udp非可靠运输
4、TCP：传信息；UDP：视频】
（3）运输层协议TCP协议详解：
a、 tcp，udp 三次握手，四次挥手。
【三次握手：1 客户端给服务器发请求建立连接的syn；2、服务器接收syn,发送ack确认报文和syn; 3、客户端接收并返回ack】
【四次挥手：1、客户端===>服务器 释放连接报文FIN; 2、服务器接收fin,发送ack; 3、服务器发送fin 4、客户端发送ack】
为什么三次握手？为了防止已失效的连接请求报文段突然又传送到了服务端，服务器端因此返回ack和syn，而传到客户端，客知道是已经过期的不会理睬，而服务器会一直等待资源】
b.TCP为什么是可靠的？
【1、 确认和重传机制：建立连接时三次握手同步双方的“序列号 + 确认号 + 窗口大小信息”，是确认重传、流控的基础。传输过程中，如果Checksum校验失败、丢包或延时，发送端重传。
2、 数据排序：TCP有专门的序列号SYN字段，可提供数据re-order
3、 流量控制：窗口和计时器的使用。TCP窗口中会指明双方能够发送接收的最大数据量
4、 拥塞控制
TCP的拥塞控制由4个核心算法组成。
慢启动、拥塞避免、快重传、快恢复 】
（4）应用层协议详解
a. http，https区别 ？
【http：超文本传输协议。无状态。从www服务器传输超文本到本地浏览器的传送协议。位于应用层，端口80。使浏览器更高效，减少网络传输。http报文包括起始行(方法、版本)、首部和数据主体。
https：http+ssl，HTTPS存在不同于HTTP的默认端口及一个加密/身份验证层（在HTTP与TCP之间）端口443。无状态，明文传输，用于身份验证、加密通讯，SSL层是证书，非对称加密，ca申请证书）
总结：1、连接方式的端口不同：http80，https443
2、http传输数据未加密，明文的；https：具有安全性的ssl加密传输协议。
3、https需要ca申请证书，一般免费证书较少，所以需要一定费用
4、http连接简单，无状态的，https：ssl+http，加密传输，身份认证】
b. http状态码：
【1xx：表示通知信息，如请求收到了或正在处理
2xx：表示成功，如接受或知道了。如200：请求成功
3xx：表示请求，如要完成请求还必须采取进一步行动。301 - 资源（网页等）被永久转移到其它URL。
4xx：表示客户的差错，如有错误语法。404：请求失败；
5xx：表示服务器差错；如500 - 内部服务器错误】
c. https的传输过程：
【客户端向服务器发送加密请求；服务器用公钥加密，再加上数字证书ca+MD5的数字签名(ca是一种第三方证书)传到客户端；客户端用内置的数字证书列表查询解密，比较该数字证书对应网址与所传的网址是否一致；客户端生成秘钥(随机数)用服务器的公钥加密传回给服务器；服务器用私钥解密。
d.HTTP协议的方法：
（1）GET方法：请求访问（已被URI识别的）资源，指定的资源经服务器解析后返回响应内容。
（2）POST方法：传输实体的主体
（3）PUT方法：传输文件（要求在请求报文的主体中包含文件内容，后保存到请求URI指定的位置）
（4）HEAD：用于确认URI的有效性及资源更新的日期时间
（5）DELETE：删除文件，请求URI删除指定的资源
（6）OPTIONS：查询针对请求URI指定的资源支持的方法
（7）TRACE：让web服务器将之前的请求通信换回给客户端的方法
（8）CONNECT：在与代理服务器通信时建立隧道，实现用隧道协议进行TCP通信。
e、SOAP(simple object access protocols)：简单对象访问协议，基于XML的协议，可和许多互联网协议结合使用(http SMTP)，较复杂可靠，通用性。
REST：是一种架构风格/设计风格，主要用于客户端、服务器交互的软件，描述一种网络系统，更简单轻量。
==>满足这些的：Restful 】
（5）www.baidu.com访问这个网站的具体流程。
【1、得到ip地址（直接找，否则用DNS协议获取ip）；
2、TCP协议，3次握手建立连接
3、HTTP协议请求网页内容】
（6）socket：用于建立网络连接。连接成功时，应用两端产生一个socket实例，操作这个实例，完成所需会话。TCP通过socket对象对数据进行传输。
(7)cookiet和session？
session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。
【1、Cookie和Session都是会话技术，Cookie是运行在客户端，Session是运行在服务器端。
2、Cookie有大小限制以及浏览器在存cookie的个数也有限制（单个cookie保存的数据不能超过4K，很多浏览器限制一个站点最多保存20个cookie），Session是没有大小限制和服务器的内存大小有关。
3、Cookie是以明文的方式存放在客户端的，安全性低，有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击。
4、Session是保存在服务器端上会存在一段时间才会消失（一般是30min），如果session过多会增加服务器的压力。
使session失效的方法：
1.关闭tomcat；2.reload web应用；3.session时间到 4.invalidate session】
（8）关于密钥
a.密钥模式：
（1）对称密钥：加密和解密是相同体制，加密解密算法公开（DES 3DES IDEA RC5）
（2）非对称密钥（公钥）：加密和解密密码不同，加密密钥公钥公开，解密密钥私钥。(RSA ECC)
（3）Hash：MD5 SHA
b.数字签名：
发送者：用私钥SKA对摘要加密+ 原文 ，传送到接受方，接收方用发送者公钥对加密摘要解密得到信息，再和 用hash()对收到的原文信息进行对比，是完整信息，则正确，否则可能被人修改过了。
数字签名是一种加密。
数字签名验证是一种解密。
数字签名=摘要(=信息+Hash)+私钥。
数字证书=公钥+相关信息。
（9）转发和重定向
【转发：服务器行为。地址不变（请求不变）。登录。request.getRequestDispatcher("success.jsp").forward(request,response);
在服务器组件收到用户请求后。经过它的处理后有传递给了另一个组件，不修改用户的请求码。各组件处理完之后在返回给用户，例如主页面的框架。（请求不变）
重定向： response.sendRedirect("success.jsp"); 地址变（修改用户请求）。退出。
在服务器组件收到用户请求后。经过处理修改用户请求。在返回给用户。这样用户再次使用这个请求就会被动的使用新的请求了。（重定向一般是为了防止用户提交完数据后点浏览器刷新或点后退之后产生重复提交）
】
十一、设计模式 ：
设计模式六大原则：
（1)单一职责原则：每个类应该实现单一的职责，不然应该把类拆分
（2）里氏替换原则：任何基类可以出现的地方，子类也可以出现
（3）依赖倒转原则：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。
（4）接口隔离原则：每个接口中不存在子类用不到却必须实现的办法，否则，将接口拆分。
（5）迪米特原则（最少知道原则）：一个类对自己依赖的类知道越少越好。
（6）合成复用原则（Composite Reuse Principle）
原则是尽量首先使用合成/聚合的方式，而不是使用继承。
十二：Linux：
没有在Linux上实施过应用，会常用的linux指令
ls：显示文件目录
mkdir：创建目录
cd：切换目录
touch：建空文件
echo：建有内容的文件
cat：查看文件内容
cp：拷贝
mv：移动或重命名
rm：删除文件
rmidr：删除空目录
find：查找文件
pwd：显示当前目录
wc：统计文本中行数(wc -l 如查找当前目录下的py文件： find . -name "*.py" |wc -l)、字数、字符数
grep：文本文件中查找某字符串
stat：显示文件的详细信息
who ：显示在线登录用户
tar/gzip：打包
：wq 保存并退出
：q 退出
su：切换用户
ps：查看进程
kill：杀死进程
chmod：切换运行模式(可读、可写、可运行 rwx)
十三、操作系统：
1、进程管理：进程、线程、并发（互斥和同步）、死锁
2、内存管理：
~分区：
（1）内存分区（固定分区（大小相等的分区/大小不等的分区），会产生内部碎片）
（2）动态分区（产生外部碎片，解决的 放置算法：BF最佳适配、FF首次适配、NF下次适配
~重定位
~分页：进程划为同样大小固定的块（页框），产生内部碎片
~分段：产生外部碎片
虚拟内存（分页，
页面置换策略：
OPT：最佳置换
LRU：最近最少置换
FIFO：先进先出置换
CLOCK：时钟 ）
3、I/O管理：
单处理器的选择调度策略：
FCFS（先来先服务，非抢占）
轮转（抢占）
SPN（最短进程优先，非抢占）
SRT（最短剩余时间，抢占）
HRRN（最高响应比优先，非抢占）
反馈（抢占）
磁盘调度策略：
FIFO（先进先出策略）、
优先级（比较短的批作业和交互作业优先级较高）、
SSTF（最短服务时间优先）、
SCAN（到达后反转磁头壁）、
C-SCAN（保持一个方向，到达最后再返回另一方向末端的磁道，同方向再次扫描）、
N-STEP-SCAN（N步扫描，把磁盘请求队列分为长度为N的子队列）、FSCAN（两个子队列）
6、死锁四个条件：
互斥(一个资源同时只能用一个线程）、
占有且等待（线程在等待其他资源的时候继续占有原来的资源）
不可抢占（线程不可抢占其他线程的资源)
循环等待（各线程间形成了循环等待资源的)
死锁预防：破坏条件
死锁避免：进程启动拒绝(达到请求量才会启动进程)、资源分配拒绝（银行家算法,Cij-Aij<=Vj 需要的-已分配的<=未分配的)
十四、关于高并发：
高并发(high currency)：互联网分布式系统结构设计中必须考虑的因素之一，指通过设计保证系统能够同时并发处理很多请求。在某个时间点，有多少个访问同时到来。
（一）常用指标：
响应时间、吞吐量、每秒查询量QPS（query per seconde），并发用户数等
【响应时间：系统对请求做出响应的时间（如系统处理一个http请求需要200ms，就是响应时间）
QPS：每秒响应请求数
并发用户数：同时承载正常使用系统功能的用户数量。（如一个即时通讯系统，同时在线量也代表了系统的并发用户数）】
（二）提高系统并发能力的方式：垂直扩展和水平扩展
垂直扩展：提升单机处理能力。
又分为两种：
（1）增强单机硬件性能（例如：增加CPU核数如32核，升级更好的网卡如万兆，升级更好的硬盘如SSD，扩充硬盘容量如2T，扩充系统内存如128G；）
（2）提升单机架构性能，例如：使用Cache来减少IO次数，使用异步来增加单服务吞吐量，使用无锁数据结构来减少响应时间；
水平扩展：增加服务器数量，可线性扩充系统性能。
NOSQL：
Redis：键值对，5种数据类型：String、Hash、List、Set、SortedSet
Java和C++区别：都是面向对象
java由JVM自动分配内存，C++是要自己malloc()、free申请内存
java没有指针，C++有
java支持跨平台
java单继承，C++多继承
