java基础复习
面向对象的特征
封装：将对象属性和方法的代码封装到一个模块中，也就是一个类中，保证软件内部具有优良的模块性的基础，实现“高内聚，低耦合”。
抽象：找出一些事物的相似和共性之处，然后归为一个类，该类只考虑事物的相似和共性之处。抽象包括行为抽象和状态抽象。
继承：在已经存在的类的基础上进行，将其定义的内容作为自己的内容，并可以加入新的内容或者修改原来的方法适合特殊的需要。
多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，就是多态，简单点说：就是用父类的引用指向子类的对象。目的：提高代码复用性，解决项目中紧耦合问题，提高可扩展性。
编译多态：方法的重载，对于多个同名方法,在编译时能够确定执行同名方法中的哪一个。
运行多态：继承，重写父类方法，父类的引用指向子类的对象等。
多态的机制：靠的是父类的或者接口的引用变量可以指向子类或者具体实现类的实例对象。
Java类加载过程
一个java文件从编码完成到最终执行，主要包括两个过程。
编译：即把我们写好的java文件，通过javac命令编译成字节码文件，也就是我们常说的.class文件
运行：就是把编译形成的.class文件交给java虚拟机（JVM）执行
Java运算符优先级别
单目>算数运算符>移位>比较>按位>逻辑>三目>赋值
口诀：淡云一笔安洛三幅
举例：if(a+b!=c && a<b)
String和StringBuffuer、StringBuilder的区别？
String:字符串数值不可变；
StringBuffer：字符串可修改，可以动态构造字符数据。StringBuffer类是可以通过Append()来修改值。线程安全。
StringBuilder：线程不安全。
三者在执行速度方面的比较：StringBuilder > StringBuffer > String
对于三者使用的总结：
- 如果要操作少量的数据用 = String
- 单线程操作字符串缓冲区下操作大量数据 = StringBuilder
- 多线程操作字符串缓冲区下操作大量数据 = StringBuffer
有return的情况下try catch finally的执行顺序
1、不管有没有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
final、finally、finalize的区别
- final是最终的意思，表示不能被改变，可用于成员变量、方法和类
修饰变量：变量一旦被初始化不可改变
修饰方法：方法不能被覆盖
修饰类：类不能够被继承
- finally：异常处理关键字，finally中的主体总会执行，无论异常发生与否
- finalize:类的finalize方法，可以告诉垃圾回收器应该执行的操作，该方法从Object继承而来，在从堆中永久删除对象之前，调用该对象的finalize方法
注意：无法确切的保证垃圾回收器何时调用该方法，也无法保证调用不同对象方法的顺序
JAVA运行时数据区域
Java 一条进程的栈区、堆区、数据区和代码区在内存中的映射
| 内存 | 存储内容 |
|---|---|
| 栈区 | 主要用来存放局部变量, 传递参数, 存放函数的返回地址。.esp 始终指向栈顶, 栈中的数据越多, esp的值越小。 |
| 堆区 | 用于存放动态分配的对象, 当你使用 malloc和new 等进行分配时,所得到的空间就在堆中。动态分配得到的内存区域附带有分配信息, 所以你 能够 free和delete它们。 |
| 数据区 | 全局，静态和常量是分配在数据区中的，数据区包括bss（未初始化数据区）和初始化数据区。 |
| 代码区 | 是个只读区，存放了程序的代码。任何尝试对该区的写操作会导致段违法出错。代码区是被多个运行该可执行文件的进程所共享的。 |
1.程序计数器
程序计数器（Program Counter Register） 是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条执行字节码指令。
每条线程都有一个独立的程序计数器。
如果执行的是java方法，这个计数器记录的是正在执行的虚拟机字节码指令地址。如果是native方法，计数器为空。此内存区域是唯一一个在java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。
2.Java虚拟机栈
同样是线程私有，描述Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。一个方法对应一个栈帧。
局部变量表存放了各种基本类型、对象引用和returnAddress类型（指向了一条字节码指令地址）。其中64位长度long 和 double占两个局部变量空间，其他只占一个。
规定的异常情况有两种：1.线程请求的栈的深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；2.如果虚拟机可以动态扩展，如果扩展时无法申请到足够的内存，就抛出OutOfMemoryError异常。
3.本地方法栈
和Java虚拟机栈很类似，不同的是本地方法栈为Native方法服务。
4.Java堆
是Java虚拟机所管理的内存中最大的一块。由所有线程共享，在虚拟机启动时创建。堆区唯一目的就是存放对象实例。
堆中可细分为新生代和老年代，再细分可分为Eden空间、From Survivor空间、To Survivor空间。
堆无法扩展时，抛出OutOfMemoryError异常
5.方法区
所有线程共享，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
当方法区无法满足内存分配需求时，抛出OutOfMemoryError
JAVA反射机制
是在运行状态中，对于任意一个类都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意方法和属性。
这种动态获取信息以及动态调用对象方法的功能成为JAVA的反射机制。
Java的泛型是如何工作的 ，什么是类型擦除
泛型是通过类型擦除来实现的，编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如
List<String>在运行时仅用一个List来表示。这样做的目的，是确保能和Java 5之前的版本开发二进制类库进行兼容。你无法在运
行时访问到类型参数，因为编译器已经把泛型类型转换成了原始类型。
为什么要用类型擦除实现泛型（伪泛型）
因为设计者在引入泛型概念的时候就是这么做的，成本较低，后来尽管jdk不断升级，但是考虑到要兼容老版本，所以一直也不敢
去改变这种伪泛型的机制
equals和==的区别
在JVM中，内存分为堆内存跟栈内存。他们二者的区别是： 当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，与此同时在栈内存中生成对应的引用，当我们在后续代码中调用的时候用的都是栈内存中的引用。还需注意的一点，基本数据类型是存储在栈内存中。
- ==是判断两个变量或实例是不是指向同一个内存空间，equals是判断两个变量或实例所指向的内存空间的值是不是相同
- ==是指对内存地址进行比较 ， equals()是对字符串的内容进行比较
- ==指引用是否相同， equals()指的是值是否相同。
String s="abcd"是一种非常特殊的形式,和new 有本质的区别。它是java中唯一不需要new 就可以产生对象的途径。
equals()和hashCode()区别
- equals()：反映的是对象或变量具体的值，即两个对象里面包含的值--可能是对象的引用，也可能是值类型的值。
- hashCode()：计算出对象实例的哈希码，并返回哈希码，又称为散列函数。根类Object的hashCode()方法的计算依赖于对象实例的D（内存地址），故每个Object对象的hashCode都是唯一的；当然，当对象所对应的类重写了hashCode()方法时，结果就截然不同了。
1.equal()相等的两个对象他们的hashCode()肯定相等，也就是用equal()对比是绝对可靠的。
2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。
所有对于需要大量并且快速的对比的话如果都用equal()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equal()，如果equal()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！
HashMap、Hashtable、ConcurrentHashMap的原理与区别
HashTable
- 底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化
- 初始size为11，扩容：newsize = olesize*2+1
- 计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length
HashMap
- 底层数组+链表实现，可以存储null键和null值，线程不安全
- 初始size为16，扩容：newsize = oldsize*2，size一定为2的n次幂
- 扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入
- 插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）
- 当Map中元素总数超过Entry数组的75%，触发扩容操作，为了减少链表长度，元素分配更均匀
- 计算index方法：index = hash & (tab.length – 1)
ConcurrentHashMap
- 底层采用分段的数组+链表实现，线程安全
- 通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)
- Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
- 有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁
- 扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容
进程和线程的区别
进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。
线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。
多进程：是指操作系统能同时运行多个任务（程序）。
多线程：是指在同一程序中有多个顺序流在执行。
实现Runnable接口比继承Thread类所具有的优势
- 适合多个相同的程序代码的线程去处理同一个资源
- 可以避免java中的单继承的限制
- 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
Thread的几个重要方法
start()，stop()，join()，sleep()，run()。
wait()和notify()是Object的方法，分别表示线程的挂起和恢复。
锁的类型
可重入锁：在执行对象中所有同步方法内部不用再次获得锁
可中断锁：在等待获取锁的过程中可中断
公平锁：按等待获取锁的线程的等待时间进行获取。等待时间长的优先获取锁
读写锁：对资源读取和写入的时候拆分为两部分处理。读的时候可以多线程一起读，写的时候必须同步写
synchronized与Lock的区别
1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。
synchronized和volatile的区别
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是
立即可见的。
2）禁止进行指令重排序。
volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；
synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
1.volatile仅能使用在变量级别；
synchronized则可以使用在变量、方法、和类级别的
2.volatile仅能实现变量的修改可见性，并不能保证原子性；
synchronized则可以保证变量的修改可见性和原子性
3.volatile不会造成线程的阻塞；
synchronized可能会造成线程的阻塞。
4.volatile标记的变量不会被编译器优化；
synchronized标记的变量可以被编译器优化
并发编程学习
synchronized
-
线程安全:当多个线程访问某一个类(对象或方法)时，这个类始终都能表现出正确的行为，那么这个类(对象或方法)就是线程安全
-
synchronized:可以在任意对象以及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"
-
多个线程多个锁:多个线程，每个线程都可以拿到自己指定的锁，分别获得锁之后，执行synchronized方法体的内容
-
事务的四大特性(ACID):原子性，一致性，隔离性，持久性
-
并发操作引发的问题:丢失修改，不可重复读，幻读，脏读
volatile
-
volatile概念:volatile关键字的主要作用是使变量在多个线程间可见。
-
volatile关键字虽然拥有多个线程之间的可见性，但是不具备同步性(原子性)，要实现原子性建议使用atomic类的系列对象(AtomicInteger)。
wait/notify
-
线程通信概念:线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体。线程间的通信就成为整体的必用方式一致。
-
使用wait/notify方法可以实现线程间的通信
-
wait和notify必须配合synchronized关键字使用
-
wait方法释放锁，notify方法不释放锁
单例模式
-
单例模式:最常见的就是饥饿模式和懒汉模式。一个直接实例化对象，一个在调用方法时实例化对象。
同步类容器/并发类容器
-
同步类容器都是线程安全的，但在某些场景下可能需要加锁来保护复合操作。(如Vector,HashTable)
-
同步类容器虽然实现了线程安全，但是严重降低了并发性，在多线程环境时，严重降低了应用程序的吞吐量。
-
并发类容器是专门针对并发设计的，使用ConcurrentHashMap来代替给予散列的HashTable，用CopyOnWriteArrayList代替Vector。前者是高性能的队列，后者是以阻塞形式的队列。
脏读、不可重复读和幻读的区别
脏读
（针对未提交数据）如果一个事务中对数据进行了更新，但事务还没有提交，另一个事务可以“看到”该事务没有提交的更新结果，这样造成的问题就是，如果第一个事务回滚，那么，第二个事务在此之前所“看到”的数据就是一笔脏数据。
不可重复读
（针对其他提交前后，读取数据本身的对比，数据内容不一致）不可重复读取是指同一个事务在整个事务过程中对同一笔数据进行读取，每次读取结果都不同。如果事务1在事务2的更新操作之前读取一次数据，在事务2的更新操作之后再读取同一笔数据一次，两次结果是不同的，所以，Read Uncommitted也无法避免不可重复读取的问题。
幻读
（针对其他提交前后，读取数据条数的对比，数据总数不一致） 幻读是指同样一笔查询在整个事务过程中多次执行后，查询所得的结果集是不一样的。幻读针对的是多笔记录。在Read Uncommitted隔离级别下， 不管事务2的插入操作是否提交，事务1在插入操作之前和之后执行相同的查询，取得的结果集是不同的，所以，Read Uncommitted同样无法避免幻读的问题
不可重复读和幻读区别
（1）不可重复读是读取了其他事务更改的数据，针对update与delete操作
解决：使用行级锁，锁定该行，事务A多次读取操作完成后才释放该锁，这个时候才允许其他事务更改刚才的数据。
（2）幻读是读取了其他事务新增的数据，针对insert操作
解决：使用表级锁，锁定整张表，事务A多次读取数据总量之后才释放该锁，这个时候才允许其他事务新增数据。
Redis常见面试题
https://blog.csdn.net/u010682330/article/details/81043419
https://www.cnblogs.com/jasontec/p/9699242.html
什么是Redis持久化？Redis有哪几种持久化方式？
1. 持久化就是把内存的数据写到磁盘中去，防止服务器宕机了内存数据丢失。
2. Redis提供了两种持久化方式：RDB（默认），AOF
Redis持久化：RDB和AOF比较
- aof文件比rdb更新频率高，优先使用aof还原数据
- aof比rdb更安全也更强大
- rdb性能比aof好
- 如果两个都配置了优先加载aof
经典排序算法比较
经典查找算法比较
java实现经典排序和查找算法
java实现快速排序，冒泡排序，插入排序，选择排序，堆排序等经典排序
两段锁协议
两段锁协议是指所有事务必须分两个阶段对数据项加锁和解锁：
1、在对任何数据进行读、写操作之前，要申请并获得对该数据的封锁。
2、 每个事务中，所有的封锁请求先于所有的解锁请求。
例如事务T1遵守两段锁协议，其封锁序列是：
Lock A, Read A, A:=A+100, Write A, Lock B, Unlock A, Read B, Unlock B, Commit;
mysql数据库的基本操作
group by 和聚合函数一起使用
group by 和聚合函数一起使用，可以统计出某个或者某些字段在一个分组中的最大值、最小值、平均值等。
having关键字指定条件表达式对分组后的内容进行过滤，需要注意的是，group by 一般和聚合函数一起使用。
单独使用 group by 关键字，查询的是每个分组中的一条记录。
例：将student表按照gender字段值进行分组查询，计算出每个分组中各有多少名学生。
select count(*),gender from student group by gender;spring面试题
抽象类和接口区别
抽象类：用abstract修饰，抽象类不能创建实例对象。抽象方法必须在子类中实现，不能有抽象构造方法或者抽象静态方法。
接口：抽象类的一种特例，接口中的方法必须是抽象的。
两者的区别：
- 抽象类可以有构造方法，接口没有构造方法
- 抽象类可以有普通成员变量，接口没有普通成员变量。
- 抽象类可以有非抽象的普通方法，接口中的方法必须是抽象的。
- 抽象类中的抽象方法访问类型可以是public，protected，接口中抽闲方法必须是public类型的。
- 抽象类可以包含静态方法，接口中不能包含静态方法。
- 一个类可以实现多个接口，但是只能继承一个抽象类。
- 接口中基本数据类型的数据成员，都默认为static和final，抽象类则不是。
ArrayList和LinkList的区别
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据，而查询和修改ArrayList占优势。
BeanFactory和FactoryBean的区别
BeanFactory：
以Factory结尾，表示他是一个工厂类接口，用于管理Bean的一个工厂，在spring中BeanFactory是ioc容器的核心接口，它的职责包括：实例化，定位，配置应用程序中的对象及建立这些对象间的依赖。
FactoryBean：
以Bean结尾，表示它是一个Bean。不用于其他Bean的是：它实现了FactoryBean接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果需要获取FactoryBean对象，请在ID前面加一个&符号来获取。
Java构造器和代码块执行顺序
Java类的初始化顺序(静态 代码块 构造函数等的执行顺序)
1. 父类的静态成员变量
2. 父类的静态代码块
3. 子类的静态成员变量
4. 子类的静态代码块
5. 父类的成员变量
6. 父类的代码块
7. 父类的构造函数
8. 子类的成员变量
9. 子类的代码块
10. 子类的构造函数
两个最基本的java回收算法：复制算法和标记清理算法
复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
标记-清理算法：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片
标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
两个概念：新生代和年老代
新生代：初始对象，生命周期短的
永久代：长时间存在的对象
整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。
P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法
Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法
Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
Parallel Old（并行）收集器，针对老年代，标记整理
CMS收集器，基于标记清理
G1收集器：整体上是基于标记 整理 ，局部采用复制
综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。
JDBC的使用步骤
- 加载JDBC驱动程序
- 提供JDBC连接的URL
- 创建数据库的连接
- 创建一个statement
- 执行sql语句
- 处理结果
- 关闭JDBC对象
Spring和Spring MVC配置
<!-- 配置spring核心监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-*.xml</param-value>
</context-param>
<!--spring MVC -->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-*.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>Spring MVC工作流程
1、 用户发送请求至前端控制器DispatcherServlet。
2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3、 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4、 DispatcherServlet调用HandlerAdapter处理器适配器。
5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6、 Controller执行完成返回ModelAndView。
7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9、 ViewReslover解析后返回具体View。
10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
11、 DispatcherServlet响应用户。
Spring IOC容器初始化过程
概述：BeanDifinition的Resource定位、BeanDifinition的载入与解析、BeanDifinition在Ioc容器中的注册
- 第一个过程是Resource资源定位。这个Resouce指的是BeanDefinition的资源定位（XmlBeanDefinitionReader）。这个过程就是容器找数据的过程，就像水桶装水需要先找到水一样。
- 第二个过程是BeanDefinition的载入过程。这个载入过程是把用户定义好的Bean表示成Ioc容器内部的数据结构，而这个容器内部的数据结构就是BeanDefition。
- 第三个过程是向IOC容器注册这些BeanDefinition的过程，这个过程就是将前面的BeanDefition保存到HashMap中的过程。
Spring AOP实现
- Advice（通知）定义在连接点做什么，为切面增强提供织入接口
- Pointcut（切点）决定Advice通知应该作用于哪个连接点，也就是说通过Pointcut来定义需要增强的方法的集合
- Advisor（通知器）把Advice通知和Pointcut切点结合起来
Spring AOP实现的核心技术是动态代理（JDK动态代理，CGLIB）
Ioc哪些方面的控制被反转了
答：依赖对象的获得被反转了——依赖注入
BeanFactory和ApplicationContext
- BeanFactory的实现是IOC容器的基本形式
- 各种ApplicationContext的实现是IOC容器的高级表现形式
IOC容器中Bean的生命周期
- Bean实例的创建
- 为Bean实例设置属性
- 调用Bean的初始化方法
- 应用可以通过IOC容器使用Bean
- 当容器关闭时，调用Bean的销毁方法
Spring有几种配置方式
- 基于XML配置
- 基于注解配置
- 基于Java配置
依赖注入的三种方式
- 构造器注入
- setter方法注入
- 接口注入
maven中聚合和继承的区别
两者的目的是不一样的，聚合的目的是能够快速的构建项目，继承的目的是减少重复配置。
聚合：
定义一个聚合模块，然后在pom文件中添加<module></module>标签，其中的内容是模块相对于当前模块的路径。那么在构建聚合模块的时候，在<module>中定义的模块也会跟着构建，不用逐个构建，因此加快了构建速度。
继承：
除了定义一个父模块，在父模块的pom文件中添加<module>标签，还要在子模块pom文件中添加<parent>标签，指向父模块。指向之后，那么在父模块中定义的插件和依赖都可以被子模块继承，就不用再子模块pom文件中重复配置了（减少了重复配置）。
常用ASCII码值
空格：32，数字0：48，'A'：65，'a'：97
闭包的概念
闭包就是能够读取其他函数内部变量的函数，函数没有被释放，整条作用域链上的局部变量都将得到保留。
由于在javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成‘定义在一个函数内部的函数’。
所以，在本质上，闭包就是将函数内部和函数外部连接的一座桥梁。
闭包的作用
闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
js函数作用域
在JavaScript中变量的作用域，并非和C、Java等编程语言似得，在变量声明的代码段之外是不可见的，我们通常称为块级作用域，然而在JavaScript中使用的是函数作用域（变量在声明它们的函数体以及这个函数体嵌套的任意函数体都是有定义的）。
注：JavaScript的函数作用域是指在在函数内声明的所有变量在函数体内始终是可见的，也就是说在函数体内变量声明之前就已经可用了。
JS中var和let的区别
ES6 新增了let命令，用来声明局部变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效，而且有暂时性死区的约束。
JS中的六大数据类型
js中有六种数据类型，包括五种基本数据类型（Number,String,Boolean,Undefined,Null）,和一种复杂数据类型（Object）。
Dubbo面试题
Dubbo是阿里巴巴开源的基于 Java 的高性能 RPC 分布式服务框架，现已成为 Apache 基金会孵化项目。
史上最全 40 道 Dubbo 面试题及答案，看完碾压面试官！
JVM原理和调优
JVM内存组成
JVM内存组成结构
JVM栈由堆、栈、本地方法栈、方法区等部分组成，结构图如下所示：
1）堆
所有通过new创建的对象的内存都在堆中分配，堆的大小可以通过-Xmx和-Xms来控制。堆被划分为新生代和旧生代，新生代又被进一步划分为Eden和Survivor区，最后Survivor由From Space和To Space组成，结构图如下所示：
-
新生代。新建的对象都是用新生代分配内存，Eden空间不足的时候，会把存活的对象转移到Survivor中，新生代大小可以由-Xmn来控制，也可以用-XX:SurvivorRatio来控制Eden和Survivor的比例
-
旧生代。用于存放新生代中经过多次垃圾回收仍然存活的对象
-
持久带（Permanent Space）实现方法区，主要存放所有已加载的类信息，方法信息，常量池等等。可通过-XX:PermSize和-XX:MaxPermSize来指定持久带初始化值和最大值。Permanent Space并不等同于方法区，只不过是Hotspot JVM用Permanent Space来实现方法区而已，有些虚拟机没有Permanent Space而用其他机制来实现方法区。
-Xmx:最大堆内存,如：-Xmx512m
-Xms:初始时堆内存,如：-Xms256m
-XX:MaxNewSize:最大年轻区内存
-XX:NewSize:初始时年轻区内存.通常为 Xmx 的 1/3 或 1/4。新生代 = Eden + 2 个 Survivor 空间。实际可用空间为 = Eden + 1 个 Survivor，即 90%
-XX:MaxPermSize:最大持久带内存
-XX:PermSize:初始时持久带内存
-XX:+PrintGCDetails。打印 GC 信息
-XX:NewRatio 新生代与老年代的比例，如 –XX:NewRatio=2，则新生代占整个堆空间的1/3，老年代占2/3
-XX:SurvivorRatio 新生代中 Eden 与 Survivor 的比值。默认值为 8。即 Eden 占新生代空间的 8/10，另外两个 Survivor 各占 1/10
2）栈
每个线程执行每个方法的时候都会在栈中申请一个栈帧，每个栈帧包括局部变量区和操作数栈，用于存放此次方法调用过程中的临时变量、参数和中间结果。
-xss:设置每个线程的堆栈大小. JDK1.5+ 每个线程堆栈大小为 1M，一般来说如果栈不是很深的话， 1M 是绝对够用了的。
3）本地方法栈
用于支持native方法的执行，存储了每个native方法调用的状态
4）方法区
存放了要加载的类信息、静态变量、final类型的常量、属性和方法信息。JVM用持久代（Permanet Generation）来存放方法区，可通过-XX:PermSize和-XX:MaxPermSize来指定最小值和最大值
JVM内存调优
首先需要注意的是在对JVM内存调优的时候不能只看操作系统级别Java进程所占用的内存，这个数值不能准确的反应堆内存的真实占用情况，因为GC过后这个值是不会变化的，因此内存调优的时候要更多地使用JDK提供的内存查看工具，比如JConsole和Java VisualVM。
对JVM内存的系统级的调优主要的目的是减少GC的频率和Full GC的次数，过多的GC和Full GC是会占用很多的系统资源（主要是CPU），影响系统的吞吐量。特别要关注Full GC，因为它会对整个堆进行整理，导致Full GC一般由于以下几种情况：
旧生代空间不足
调优时尽量让对象在新生代GC时被回收、让对象在新生代多存活一段时间和不要创建过大的对象及数组避免直接在旧生代创建对象
Pemanet Generation空间不足
增大Perm Gen空间，避免太多静态对象
统计得到的GC后晋升到旧生代的平均大小大于旧生代剩余空间
控制好新生代和旧生代的比例
System.gc()被显示调用
垃圾回收不要手动触发，尽量依靠JVM自身的机制
调优手段主要是通过控制堆内存的各个部分的比例和GC策略来实现，下面来看看各部分比例不良设置会导致什么后果
1）新生代设置过小
一是新生代GC次数非常频繁，增大系统消耗；二是导致大对象直接进入旧生代，占据了旧生代剩余空间，诱发Full GC
2）新生代设置过大
一是新生代设置过大会导致旧生代过小（堆总量一定），从而诱发Full GC；二是新生代GC耗时大幅度增加
一般说来新生代占整个堆1/3比较合适
3）Survivor设置过小
导致对象从eden直接到达旧生代，降低了在新生代的存活时间
4）Survivor设置过大
导致eden过小，增加了GC频率
另外，通过-XX:MaxTenuringThreshold=n来控制新生代存活时间，尽量让对象在新生代被回收
由内存管理和垃圾回收可知新生代和旧生代都有多种GC策略和组合搭配，选择这些策略对于我们这些开发人员是个难题，JVM提供两种较为简单的GC策略的设置方式
1）吞吐量优先
JVM以吞吐量为指标，自行选择相应的GC策略及控制新生代与旧生代的大小比例，来达到吞吐量指标。这个值可由-XX:GCTimeRatio=n来设置
2）暂停时间优先
JVM以暂停时间为指标，自行选择相应的GC策略及控制新生代与旧生代的大小比例，尽量保证每次GC造成的应用停止时间都在指定的数值范围内完成。这个值可由-XX:MaxGCPauseRatio=n来设置
JVM常见配置
堆设置
-Xms:初始堆大小
-Xmx:最大堆大小
-XX:NewSize=n:设置年轻代大小
-XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
-XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
-XX:MaxPermSize=n:设置持久代大小
收集器设置
-XX:+UseSerialGC:设置串行收集器
-XX:+UseParallelGC:设置并行收集器
-XX:+UseParalledlOldGC:设置并行年老代收集器
-XX:+UseConcMarkSweepGC:设置并发收集器
垃圾回收统计信息
-XX:+PrintGC
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-Xloggc:filename
并行收集器设置
-XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
-XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
-XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)
并发收集器设置
-XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
-XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数。
变量的原子性，可见性，有序性和指令重排
原子性：是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。
可见性：是指当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道这个修改。
有序性：对于一个线程的执行代码而言，我们总是习惯地认为代码的执行是从先往后，依次执行的。这么理解也不能说完全错误，因为就一个线程内而言，确实会表现成这样。但是在并发时，程序的执行可能就会出现乱序。给人直观的感觉是：写在前面的代码，会在后面执行。有序性问题的原因是程序在执行时，可能会进行指令重排，重排后的指令与原指令的顺序未必一致。
指令重排：指令重排是指在程序执行过程中, 为了性能考虑, 编译器和CPU可能会对指令重新排序。
乐观锁与悲观所
悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。
什么是自旋锁
自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。
分离锁stripingLock
分离锁是分拆锁定generalization，把一个集合看分成若干partition, 每个partiton一把锁。ConcurrentHashMap就是分了16个区域，这16个区域之间是可以并发的。
ReadWriteLock读写锁
如果在系统中，读操作次数远远大于写操作，则读写锁就可以发挥最大的功效，提升系统的性能。
| 读 | 写 | |
| 读 | 非阻塞 | 阻塞 |
| 写 | 阻塞 | 阻塞 |
GET和POST的区别
POST 方法比 GET 方法安全？
有人说POST 比 GET 安全，因为数据在地址栏上不可见。
然而，从传输的角度来说，他们都是不安全的，因为 HTTP 在网络上是明文传输的，只要在网络节点上捉包，就能完整地获取数据报文。
要想安全传输，就只有加密，也就是 HTTPS。
java实现单例模式的饿汉式和懒汉式
饿汉式
public class Singleton {
private Singleton() {
System.out.println("Singleton is create");
}
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}懒汉式
public class LazySingleton {
private LazySingleton() {
System.out.println("LazySingleton is create");
}
private static LazySingleton instance = null;
public static synchronized LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}用两个栈实现一个队列的功能?要求给出算法和思路!
入队：将元素进栈A
出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；如果不为空，栈B直接出栈。
用两个队列实现一个栈的功能?要求给出算法和思路!
入栈：将元素进队列A
出栈：判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素 以此出队列并放入队列B，直到队列A中的元素留下一个，然后队列A出队列，再把 队列B中的元素出队列以此放入队列A中。
error和exception有什么区别
Error（错误）表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。
Exception（违例）表示需要捕捉或者需要程序进行处理的异搜索常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。
Exception又分为运行时异常，受检查异常。
运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。
受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。
Java中什么是竞态条件
当两个线程竞争同一资源时，如果对资源的访问顺序敏感，就称存在竞态条件。导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。 界区实现方法有两种，一种是用synchronized，一种是用Lock显式锁实现。
Java死锁原理，检测死锁
死锁产生的四个必要条件：
- 互斥条件：该资源任意一个时刻只由一个线程占用。
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
线程死锁及解决办法
我们只要破坏产生死锁的四个条件中的其中一个就可以了。
破坏互斥条件
这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
破坏请求与保持条件
一次性申请所有的资源。
破坏不剥夺条件
占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
破坏循环等待条件
靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。
jsp:include,jsp:forward两种跳转分别是什么,有什么区别
<jsp:forward>从一个JSP文件传递request信息到另外一个JSP文件，<jsp:forward>后面的部分将不会被执行。
可以使用 <jsp:param> 传递参数。
<jsp:include>将包含的文件放在JSP中和其他一起执行。
JAVA异常处理机制
1.Exception（异常） :是程序本身可以处理的异常。
2.Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。
3.检查异常（编译器要求必须处置的异常） ： 除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
4.非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。
强引用、软引用、弱引用和虚引用的区别
hashmap容器实现查找O(1)时间复杂度
- 先根据key值计算出hash值以及h值（h值是java实现中处理得到的更优的index索引值）
- 查找table数组中的h位置，得到相应的键值对链表
- 根据key值，遍历键值对链表，找到相应的键值对，
- 从键值对中取出value值。
HashMap, HashTable，HashSet,TreeMap 的时间复杂度
Sorted set有序集合操作的时间复杂度
在redis sorted sets里面当items内容大于64的时候同时使用了hash和skiplist两种设计实现。这也会为了排序和查找性能做的优化。所以如上可知：
添加和删除都需要修改skiplist，所以复杂度为O(log(n))。
但是如果仅仅是查找元素的话可以直接使用hash，其复杂度为O(1)
其他的range操作复杂度一般为O(log(n))
当然如果是小于64的时候，因为是采用了ziplist的设计，其时间复杂度为O(n)
线程池的好处
- 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。 当任务到达时，任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
FixedThreadPool 的优缺点
FixedThreadPool的优点是能够保证所有的任务都被执行，永远不会拒绝新的任务；同时缺点是队列数量没有限制，在任务执行时间无限延长的这种极端情况下会造成内存问题。
UML类图关系
事务的隔离级别
1100
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
