java常见面试题总结（基础版）
get与post的区别
1. get是从服务器上获取数据，post是向服务器传送数据
2. get传送的数据量小，不能大于2KB，post传送的数据量较大
3. get安全性低，post高，但是执行效率上get好一些
4. 在进行文件上传的时候，只能使用post而不能使用get
ArrayList、Vector、LinkedList区别
1. ArrayList、LinkedList线程不安全，Vector线程安全。
2. 扩容的时候，ArrayList扩0.5倍，Vector扩1倍，LinkedList没有扩容机制。
3. ArrayList、Vector初始扩容值为10，LinkedList没有初始值。
4. ArrayList数组结构，查询快，增删慢，LinkedList链表结构，查询慢，增删快，Vector数组结构，查询快，增删慢。
string stringbuffer stringbuilder 区别及选用
1. string字符串常量，stringbuffer与stringbuilder是字符串变量
2. string长度不可变，stringbuffer与stringbuilder长度可变。因为String类中使用final关键字字符数组保存字符串，private final char value[]，所以String不可变。
3. string使用字符串拼接的时候是两个不同的空间，stringbuffer与stringbuilder则是直接在字符串后面追加,所以大数据量上不用string
4. StringBuffer线程安全，StringBuilder线程不安全，是因为StringBuffer对方法加了同步锁。
5. 执行效率上StringBuilder>StringBuffer>String
总结：对于操作少量的数据用String，大量的数据，单线程用StringBuiler，多线程用StringBuffer。
HashMap与Hashtable区别
1. HashMap非线程安全，HashTable线程安全，因为HashTable内部的方法都经过synchronized修饰。
2. HashMap允许null的键/值，HashTable不允许
3. HashMap性能优于Hashtable
4. 初始容量Hashtable默认11，每次扩充，容量变为原来的2n+1。HashMap默认16，每次扩充，容量变为原来的2倍。
5. 底层数据结构不同，jdk1.8之后，当链表长度大于阈值（默认为8）时，将链表转换为红黑树，来减少搜索时间，Hashtable没有这样的机制，Hashtable基本被淘汰了，少用。
HashSet和HashMap区别
1. HashMap实现Map接口，HashSet实现Set接口。
2. HashMap存储键值对，HashSet仅存储对象。
3. HashMap添加元素用put，HashSet用add。
4. HashMap速度快于HashSet，因为它是使用唯一的键获取对象。
Forword（请求转发）和Redirect（重定向）区别
1. 从数据共享上：Forword是一个请求的延续，可以共享request的数据。Redirect是开启一个新的请求，不可以共享request的数据
2. 从地址栏：Forword转发地址栏不发生变化。Redirect转发地址栏发生变化
内存泄漏和内存溢出的区别
1. 内存泄漏是指应用程序申请内存之后，无法释放已经申请的内存空间，一次内存泄露的危害可以忽略，但是如果任由其发展最终会导致内存溢出
2. 内存溢出是指应用程序申请内存之后，没有足够的内存空间任其使用，所以我们在项目中对于大批量数据的导入要采取分批次提交的方式
error和exception的区别
1. error是指程序无法处理的错误，比如：内存泄露，发生的时候jvm虚拟机一般会选择线程终止
2. Exception是指程序本身可以处理的异常，比如常见的：NullPointerException、RuntimeException、ArrayIndexOutOfBoundsException等。
字节流和字符流的区别
1. stream结尾的都是字节流，reader和writer结尾的都是字符流
2. 读写的时候一个按照字节读写，一个按照字符读写
3. 读写文件中对文件的内容进行处理的时候一般用字符流，只读写文件就用字节流。
接口和抽象类的区别
1. 一个类只能进行单继承，但是可以有多个接口
2. 有抽象方法的类一定是抽象类，但是抽象类中不一定有抽象方法
3. 接口和接口--继承，接口和抽象类--抽象类实现接口，类和抽象类--类继承抽象类，类和类--继承
console和alert的区别
1. alert对代码有阻塞作用，console.log()它是在控制台上进行打印，对代码没有阻塞的作用。
2. console.log()可以打印任何类型的数据，而alert()只能打印输出String，因为alert输出的对象会自动调用toString()方法
3. 在输出的是对象的时候，alert()输出的是[object object],这个时候使用console.log()在控制台就可以看到具体的对象对应的数据。
SimpleDateFormat中format 和 parse的区别
1. format() 需要的参数为Date ,parse()需要的参数是String
2. parse()返回的是一个Date类型数据 ,format返回的是一个StringBuffer类型的数据
equals方法和==的区别
1. ==是指引用是否相同，equals是指值相同。
2. ==是对内存地址进行比较，equals是对字符串内容进行比较。
3. ==是判断是不是指向同一个内存空间，equals是判断指向的内存空间的值是不是相同。
视图和表的区别
1. 表是物理存在的，视图是虚拟的内存表。
2. 对表可以增删改查，对视图只可查。
&和&&的区别
1. &：位运算符，不管前面的条件是否正确，后面都执行。
2. &&：逻辑运算符，前面不正确，就不执行后面的了。
div和span区别
1. div：块级元素，不会和其他元素在一行。
2. span：内联元素，可以和其他元素在一行。
ArrayList和LinkList区别
1. arraylist类似数组，访问读取时间时可根据索引直接找到。（读的快）
2. linklist类似链表，删除时只需修改下指针即可。（删除快）
ArrayList和Vector的区别
1. ArrayList是非线程安全的，效率高。
2. Vector是基于线程安全的，效率低。
进程和线程的区别
1. 进程是正在执行着的应用程序。
2. 线程是进程内部一个执行序列。
3. 一个进程可以有多个线程，线程又叫轻量级进程。
sleep()和wait()区别
1. sleep方法是属于thread类中的，wait方法是属于object类的。
2. sleep方法可以在任何地方使用，wait方法则只能在同步方法或者同步块中使用。
3. sleep方法正在执行的线程主动让出cpu，然后cpu就可以去执行其他任务，在sleep指定时间后cpu再回到该线程继续往下执行。（注意：sleep方法只让出了cpu，而并不会释放同步资源锁）
wait方法则是指当前线程让自己暂时退让出同步锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用notify方法，之前调用wait的线程才会接触wait状态，可以去参与竞争同步锁。
请求转发与响应重定向区别
1. 请求转发：请求一次，速度快，在服务端完成，不会执行转发后的代码，地址栏无变化。
2. 相应重定向：请求两次，速度慢，在客户端完成，会执行重定向后的代码，地址栏有变化。
char varchar varchar2区别
1. char长度不可变，varchar长度可变。
2. char速度快，varchar速度慢。
3. char英文1字节，汉字2字节，varchar都是2字节。
4. oracle中char=varchar sqlserver中 varchar=oracle中的varchar2。
5. oracle中 varchar2所有字符两字节 varchar汉字和全角2字节，数字和英文1字节。
6. oracle中 varchar2把空串按照null处理，varchar仍按照空串处理。
7. 建议用varchar2，保证更好的兼容性。
请求，会话，上下文属性比较
1. 作用域不同，范围 request<session<servletcontext
2. 请求：请求对象生命周期短，每个线程访问web组件，都会创建一个新的请求，只有请求转发时才将请求转发到下一个资源。
3. 会话：会话对象在一次会话过程中是一个唯一的对象，生命周期比请求长。
4. 上下文：上下文对象随容器启动而创建，只有容器关闭的时候才会销毁，所以生命周期长，而且一个应用只有一个上下文对象。
list set map区别
1. set（集）：不允许重复，无序，最多一个空值。
2. list（列表）：允许重复，有序，任意数量空值。
3. map（映射）：键不允许重复，无序，一个空键，任意数量空值。
4. 常用实现类：arraylist linkedlist vector HashMap Treemap有序 hashset TreeSet有序（字典顺序）。
重写和重载的区别
1. 参数列表：重载必须修改，重写一定不能修改。
2. 返回类型：重载可以修改，重写一定不能修改。
3. 异常：重载可以修改，重写可以减少或删除，但是一定不能抛出新的或者更广的异常。
4. 访问：可以修改，一定不能做更严格的限制（可以降低限制）。
throw和throws的区别
1. throw用在方法内，后面跟上要抛出的异常类对象。
2. throws修饰在方法上，告诉调用者此方法可能会抛出异常，后面跟上要抛出的异常类名。
异常处理try catch finally
1. try：用于捕获异常，后面可接0或者多个catch，如果没有catch，必须接一个finally。
2. catch：用于处理try捕获到的异常。
3. finally：必须被执行的代码，如果try catch中出现return语句，在return前会执行finally的内容。
finally块不会被执行的情况
1. finally内的语句出现问题
2. 前面的代码中使用了System.exit()退出程序。
3. 程序所在的线程死亡。
4. 关闭CPU。
hibernate与jdbc区别
1. 使用的sql语言不同，jdbc使用的是基于关系型数据库的标准sql语言。hibernate使用的是hql语言。
2. 操作的对象不同，jdbc操作的是数据，将数据通过sql语句直接传送到数据库中执行。hibernate操作的是持久化对象，由底层持久化对象的数据更新到数据库中。
3. 数据状态不同，jdbc操作的数据是瞬时的，变量的值无法与数据库中的值保持一致。hibernate操作的数据是可持久的，即持久化对象的数据属性的值是可以跟数据库中的值保持一致的。
static和final区别
1. static表示不用实例化就可以使用，且被所有对象共享。
2. final表示不可修改，不可覆盖，常量。
jsp和servlet区别
1. jsp本质就是servlet，jsp经编译后就变成了servlet
2. jsp更擅长页面显示，servlet更擅长于逻辑控制。
3. servlet中没有内置对象 ，在java代码中通过httpservletresponse对象动态输出html内容，jsp在静态html内容中嵌入java代码，java代码被动态执行后生成html内容。
readonly和disable区别
1. readonly：不可编辑，但可以选择和复制，值可以传到后台
2. disabled：不能编辑，不能复制，选择，值不可以传到后台
final finally finalize区别
1. finalize：方法名 主要是释放一些其他做法开辟的内存空间，以及做一些清理工作。
2. finally：在异常处理时提供finally块来执行任何清除操作。
3. final：可修饰变量/方法/类，修饰变量，值一旦变化不可改，修饰类，这个类不能被继承，类中所有方法都会被隐式定义为final方法，修饰方法，只能使用，不能重载，也就是没有子类。
int和integer区别
1. int是java的基本数据类型，integer是int提供的封装类。
2. int默认值是0，integer默认值是null
3. 声明为int的变量不用实例化，而声明为integer的变量要实例化。
4. int是基本类型，直接存储数值，integer是对象，用一个引用指向这个对象。
下面代码的执行结果
public static void main(String[] args) throws IOException { Integer a=100,b=100,c=150,d=150; System.out.println(a == b);//true System.out.println(c == d);//false }
collection和collections的区别
1. collection是集合类的上级接口，继承与他的接口主要由set和list
2. collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索，排序，线程安全等操作。
hashmap与hashtable比较
1. 继承类不同，hashmap继承AbstractMap，hashtable继承dictionary。
2. 执行效率不同，hashmap非线程安全，是hashtable的轻量级实现，效率高，hashtable线程安全，效率低。
3. 有无contains方法，hashmap没有，hashtable有。
4. put方法对key和value要求不同，hashmap允许entry的key或value为null，hashtable不允许，否则出现nullpointerexception。
thread类中start和run方法的区别
1. start用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run方法来执行任务。
2. 而单独的调用run方法就跟调用普通方法是一样的，已经失去线程的特性了，因此启动一个线程的时候一定要使用start而不是run。
html和xhtml的区别
1. html是一种基本的web网页设计语言。
2. xhtml是一个基于xml的置标语言，xhtml就是一个xml版本的html。
request.getSession()、request.getSession(false)、request.getSession(true)区别
1. getSession()/getSession(true)：当session存在时返回session，否则新建一个session并返回该对象。
2. getSession(false)：当session存在时返回该session，否则返回null。
page和PageContext的区别
1. page是servlet对象，使用this关键字，它的作用范围是在同一页面。
2. PageContext是作用域通信对象，通常使用setAttribute()和getAttribute()来设置和获取存放对象的值。
自动装箱与拆箱
1. 装箱：将基本类型用他们对应的引用类型包装起来；
2. 拆箱：将包装类型转换为基本数据类型；
谈谈对反射的理解
所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。
java的反射机制的实现需要借助于4个类：class、Constructor、Field、Method
class：代表时类对象，Constructor：类的构造器对象，Field：类的属性对象，Method：类的方法对象。
反射的作用
在java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。对于任意一个对象，可以调用它的任意一个方法。这种动态的获取类的信息以及动态调用对象的方法的功能来自于java语言的反射机制。
java反射机制提供功能
在运行时判断任意一个对象所属的类，在运行时构造任意一个类的对象，在运行时判断任意一个类所具有的成员变量和方法，在运行时调用任意一个对象的方法。
Object类的常见方法
1. public native int hashCode()：native方法，返回对象的哈希码值。
2. public boolean equals(Object obj)：用于比较两个对象的内存地址是否相同，String类对该方法进行了重写，所以比较的是值是否相同。
3. public String toString()：返回类的名字@实例的哈希码的16进制的字符串。
4. protected void finalize() throws Throwable{ }：实例被垃圾回收器回收的时候触发的操作。
5. public final native void notify()：唤醒一个在此对象监视器上等待的线程。
6. public final native void notifyAll()：唤醒所有在此对象监视器上等待的线程。
常用的端口号
1. mysql:3306
2. tomcat:8080
3. oracle:1521
4. mycat:8066
5. redis:6379
6. zookeeper:2181
7. dubbo:20880
8. ElasticSearch:9200
9. kibana:5601
10. ActiveMQ两个重要的端口，一个是提供消息队列的默认端口：61616 另一个是控制台端口8161
osi七层模型
1. 物理层
2. 数据链路层
3. 网络层
4. 传输层
5. 会话层
6. 表示层
7. 应用层
jdk常用的包
（1）java.lang：基础类包，包括String、math等功能。
（2）java.io：输入输出有关的类，比如文件操作等。
（3）java.net：与网络有关，比如URL，URLConnection等。
（4）java.util：系统辅助类，比如collection，List，Map等。
（5）java.sql：数据库操作类，Connection，Statement，ResultSet等。
多态的四种体现形式
（1）接口和接口的继承。
（2）类和类的继承。
（3）重载
（4）重写
jsp九大隐式对象
（1）输入/输出对象：request、response、out
（2）作用域通信对象：session、application、pageContext
（3）Servlet对象：page、config
（4）错误对象：exception
jsp九大隐式对象中四个作用域的大小与作用范围
四个作用域从大到小：application>session>request>page
application：全局作用范围，整个应用程序共享。生命周期为：应用程序启动到停止。
session：会话作用域，当用户首次访问时，产生一个新的会话，以后服务器就可以记住这个会话状态。
request：请求作用域，就是客户端的一次请求。
page：一个JSP页面。
request和page的生命周期都是短暂的，他们之间的区别就是一个request可以包含多个page页（include，forward）。
XML和JSON的特点和对比
XML：
（1）有且只有一个根节点
（2）数据传输的载体
（3）所有的标签都需要自定义
（4）是纯文本文件
JSON：
（1）分为JSON对象和JSON数组
区别：
（1）传输同样格式的数据，xml需要使用更多的字符进行描述
（2）流行的是基于json的数据传输
（3）xml的层次结构比json清晰
共同点：
（1）xml和json都是数据传输的载体，并且具有跨平台跨语言的特性。
获取用键盘输入常用的两种方法
1. 通过Scanner
2. 通过BufferedReader
public static void main(String[] args) throws IOException { //Scanner方式 Scanner input = new Scanner(System.in); String s = input.nextLine(); input.close(); //BufferedReader方式 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String str = br.readLine(); }
let和const区别
let 声明的变量只在 let 命令所在的代码块内有效。
这里假设有两张表a、b
inner join：在两张表进行连接查询时，只保留两张表中完全匹配的结果集。select * from a inner join b on a.id = b.id == select * from a,b where a.id = b.id 这种写法只对sqlserver生效 (单纯的select * from a,b是笛卡尔乘积。比如a表有5条数据，b表有3条数据，那么最后的结果有5*3=15条数据。)
left join：在两张表进行连接查询时，会返回左表所有的行，即使在右表中没有匹配的记录。
right join：在两张表进行连接查询时，会返回右表所有的行，即使在左表中没有匹配的记录。
full join：在两张表进行连接查询时，返回左表和右表中所有没有匹配的行。
mysql和oracle区别
1. 对事务的提交 mysql:默认提交 oracle：通过commit
2. 分页 mysql：limit oracle：通过伪列rownum和嵌套
3. 对事务的支持 MySQL在innodb存储引擎的行级锁的情况下才可支持事务，而Oracle则完全支持事务
4. 自动增长的数据类型处理 MYSQL：有自动增长的数据类型，插入记录时不用操作此字段，会自动获得数据值 oracle：没有自动增长的数据类型，需要建立一个自动增长的序列号，插入记录时要把序列号的下一个值赋于此字段。
5. 逻辑备份 mysql：备份数据的时候要锁定数据，才能保证备份数据是一致的 oracle：不锁定数据，数据也是一致的
6. 事务隔离级别 mysql：支持串行化、可重复读、读已提交、读未提交，默认可重复读 oracle：支持串行化、读已提交，默认读已提交。
事务四大特性
1. 原子性：事务是由一系列动作组成，原子性就是保证这些动作要么全部成功，要么都不起作用。
2. 一致性：一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。拿转账举例子，转帐前两个账户的总金额是100，那么转账之后总金额还要是100。
3. 隔离性：是当多个用户同一时刻访问数据库的同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
4. 持久性：是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
事务隔离级别以及可以避免的问题
1. 串行化：可避免脏读、不可重复读、幻读的发生。
2. 可重复读：可避免脏读、不可重复读的发生。
3. 读已提交：可避免脏读的发生。
4. 读未提交：最低级别，任何情况都无法保证。
说一下数据库中的脏读、不可重复读、幻读
1. 脏读：脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。
2. 不可重复读：不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。
3. 幻读：幻读是事务非独立执行时发生的一种现象。例：例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。
不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。
幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）
说一下数据库引擎oracle、mysql
1. oracle：不存在引擎的概念，数据处理大致可以分成两大类：
（1）联机事务处理OLTP：强调数据库内存效率，强调内存各种指标的命令率，强调绑定变量，强调并发操作等。
（2）联机分析处理OLAP：强调数据分析，强调sql执行市场，强调磁盘I/O，强调分区等。
2. mysql：
（1）ISAM：不支持事务处理等高级处理。
（2）MyISAM：强调的是性能，执行速度快于InnoDB，缺点是不能在表损坏后恢复数据。
（3）InnoDB：执行delete操作的时候，不会重新建立表，而是一行一行的删除。
sql优化
1. 查询少用 *，改成查询哪些列就写出哪些列。
2. 少用not in，会导致放弃索引，可以改成not exists
3. 少用is null和is not null ，会导致放弃索引，因为索引不索引空值的，可以使用缺省值 之后使用a>0或a>' '代替a is not nul即不允许字段为空。
4. 使用like注意：a like ‘%100%’，可以使用a like '100%' or a like '%100' 这种方式会使用索引进行两个范围的查询。
5. 使用union all代替union 因为union会有一个去除重复记录的操作。
6. where后面的条件的顺序，比如sex =1 and name = '张三' cup占用率会小于 name = '张三' and sex = 1
7. 在FROM后面的表中的列表顺序会对SQL执行性能影响，在没有索引及ORACLE没有对表进行统计分析的情况下，ORACLE会按表出现的顺序进行链接，由此可见表的顺序不对时会产生十分耗服物器资源的数据交叉。（注：如果对表进行了统计分析，ORACLE会自动先进小表的链接，再进行大表的链接）
8. 对于索引的字段不要进行函数\表达式的处理，否则会导致放弃索引。
9. 查询的列上和order by的列上尽量要加上索引。
10. 避免where语句对字段进行null判断，可以加上缺省值
11. 避免使用or 改成使用union all
12. 避免使用in 改成使用between
13. 建立索引，索引列对应的数据尽量不要重复。一个表不要大于6个
14. 尽量使用数值型 少用字符型 这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。
15. 尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。
16. 避免频繁创建和删除临时表，以减少系统表资源的消耗。
17. 在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。
18. 如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。
19. 尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。
springboot优缺点
1. 优点：
（1）springboot可以以jar包的形式独立的运行 java -jar xx.jar就可以成功运行项目，或者直接运行main函数。
（2）内置tomcat、jetty，无需部署war文件
（3）提供了基于http、ssh、telnet对运行时的项目进行监控；我们可以引入 spring-boot-start-actuator 依赖，直接使用 REST 方式来获取进程的运行期性能参数，从而达到监控的目的，比较方便。
2. 缺点：
（1）依赖太多，项目太大
（2）没有提供相应的服务发现与注册的配套功能，没有外围监控集成方案，没有外围安全管理方案，所以在微服务架构中，还需要 Spring Cloud 来配合一起使用。
解释一下mysql中的explain
https://www.cnblogs.com/tufujie/p/9413852.html
数据库去重几种方式
1. 使用distinct函数去重：SELECT distinct ftype FROM `test_jndi`
2. 使用group by 来去重：SELECT ftype from `test_jndi` group by ftype
数据库索引底层原理
二叉树
yml和properties文件加载顺序和区别
正常的情况是先加载yml，接下来加载properties文件。如果相同的配置存在于两个文件中。最后会使用properties中的配置。最后读取的优先集最高。
jdk1.8新特性
https://blog.csdn.net/qq_29411737/article/details/80835658
Lambda表达式
函数式接口
方法引用和构造器调用
Stream API
接口中的默认方法和静态方法
新时间日期API
接口、类、抽象类继承实现关系
（1）接口是一种特殊的抽象类。java类是单继承的。java接口可以多继承。
（2） 接口可以继承（多个）接口，抽象类不可以继承接口但可以实现接口。
（3）抽象类可以继承实体类。抽象类可以实现(implements)接口，抽象类是否可继承实体类前提是实体类必须有明确的构造函数。
（4）抽象类可以继承实体类，就是因为抽象类的可以继承性和有方法。
linux命令持续查看文件日志
tail -f 文件名
linux启动springboot的jar包
java -jar xx.jar
Spring事务的传播行为
（1）propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
（2）propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
（3）propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
（4）propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
（5）propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
（6）propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
（7）propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作
final关键字修饰变量、类、方法有哪些注意事项
1. final可以修饰成员变量、局部变量
（1）final修饰的变量的值不能更改，即不能再次赋值，即使赋的新值与旧值一样也不可以。
（2）final修饰的成员变量和局部变量需要在使用前赋值。对成员变量而言，可以在定义时直接赋初值,也可以先定义不赋初值，再在构造方法中对其赋值。就是说，对象创建好后，该对象的final成员变量要保证是赋了初值的，早点(定义时赋值)、晚点(在构造方法里赋值)都没关系。如果有多个构造方法就比较麻烦了，每个构造方法都要有赋值语句，否则会报错。如果静态成员变量被修饰为final，那么该变量可看成是全局变量，即在类的整个加载期间，其值都不可变。
（3）把成员变量和局部变量从变量的类型上来分，当变量为基本数据类型时，变量的值不可更改。当变量为引用类型时，变量本身的值不可更改，即该变量不能指向其他的对象或数组；但是变量指向的对象或数组本身的内容是可以改变的；
2. final可以修饰成员方法
（1）final修饰的成员方法不能被子类重写。即当父类的方法为final时，子类不能与父类有方法名、参数类型、参数个数及参数顺序都一样的方法；父类方法为private时除外。但子类可以调用父类的final方法。
（2）访问权限为private的方法默认为final的，但子类不可以调用private的方法
3. final可以修饰成员方法的参数
由final修饰的成员方法的参数也是不能更改的，其实参数就是变量
4. final可以修饰类
由final修饰的类不能被子类继承，其成员方法也默认为final的，但成员变量是可以改变的。
https://www.cnblogs.com/chanchan/p/7936388.html
说一下对继承封装多态的理解
1. 继承
（1）定义
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
（2）子类可以从父类中继承的有
继承public和protected修饰的属性和方法,不管子类和父类是否在同一个包里.继承默认权限修饰符修饰的属性和方法,但子类和父类必须在同一个包里.
（3）子类无法继承父类的有
无法继承private修饰的属性和方法。 无法继承父类的构造方法
（4）重写
如果从父类继承的方法不能满足子类的需求,在子类中可以对父类的同名方法进行重写(覆盖),以符合要求.
2. 封装
（1）定义
就是隐藏对象的属性和实现细节,仅对外提供公共访问方式。
（2）封装的具体步骤
修改属性的可见性来限制对属性的访问;为每个属性创建一对赋值(setter)方法和取值(getter)方法,用于对这些属性的存取;在赋值方法中,加入对属性的存取控制语句.
（3）封装的好处主要有
隐藏类的实现细节;让使用者只能通过程序员规定的方法来访问数据;可以方便的加入存取控制语句,限制不合理操作.
（4）封装的权限控制符
3. 多态
定义
多态(Polymorphism):是指具有表现多种形态的能力特征.更专业的说法是:同一个实现接口,使用不同的实例而执行不同的操作
多态的三个条件
（1）继承的存在（继承是多态的基础没有继承就没有多态）
（2）子类重写父类的方法(多态下调用子类重写的方法).
（3）父类引用变量指向子类对象(子类到父类的类型转换).
子类转换成父类时的规则
将一个父类的引用指向一个子类的对象,称为向上转型(upcastiog),自动进行类型转换. 此时通过父类引用调用的方法是子类覆盖或继承父类的方法,不是父类的方法.此时通过父类引用变量无法调用子类特有的方法.
如果父类要调用子类的特有方法就得将一个指向子类对象的父类引用赋给一个子类的引用,称为向下转型,此时必须进行强制类型转换.
说一下对MVC设计模式的理解
MVC是三个单词的首字母缩写，它们是Model（模型）、View（视图）和Controller（控制）。
M：用于封装与应用程序的业务逻辑相关的数据以及对数据的处理方法。
V：展示给用户的操作界面。
C：它负责转发请求，对请求进行处理。
负载均衡的5种算法
（1）轮询（默认）
每个请求按时间顺序逐一分配到不同的后端服务器，它均衡地对待后端的每一台服务器，而不关心服务器实际的连接数和当前的系统负载。
（2）加权轮询
根据服务器的配置和负载的不同，配置不同的权重。权重越高，进入的几率越大。
（3）随机
通过系统的随机算法，根据后端服务器的列表大小值来随机选取其中的一台服务器进行访问。由概率统计理论可以得知，随着客户端调用服务端的次数增多，其实际效果越来越接近于平均分配调用量到后端的每一台服务器，也就是轮询的结果。
（4）加权随机法
与加权轮询法一样，加权随机法也根据后端机器的配置，系统的负载分配不同的权重。不同的是，它是按照权重随机请求后端服务器，而非顺序。
（5）源地址哈希法
源地址哈希的思想是根据获取客户端的IP地址，通过哈希函数计算得到的一个数值，用该数值对服务器列表的大小进行取模运算，得到的结果便是客服端要访问服务器的序号。采用源地址哈希法进行负载均衡，同一IP地址的客户端，当后端服务器列表不变时，它每次都会映射到同一台后端服务器进行访问。
（6）最小连接数法
最小连接数算法比较灵活和智能，由于后端服务器的配置不尽相同，对于请求的处理有快有慢，它是根据后端服务器当前的连接情况，动态地选取其中当前 积压连接数最少的一台服务器来处理当前的请求，尽可能地提高后端服务的利用效率，将负责合理地分流到每一台服务器。
负载均衡的实现方式
（1）重定向
这种方式，是通过将请求全部发送到前置机，由前置机通过算法 得出要分配给那台 应用服务器，然后响应给客户端，由客户端重定向到应用服务器的一种方式。这种方式，由于每一个的请求，都要重定向一下，所以效率不是很高
（2）反向代理
这种方式，是通过在前置机，使用反向代理的方式，将请求分发到应用服务器，客户端无需再请求一次，实现方式通常有两种，一种是用交换机实现，还有一种是用nginx这一类的软件实现这种方式，由于不需要再次重定向，所以较第一种，效率较高，但是由于请求和响应都是通过前置机来的，所以对前置机的考验很大.
（3）数据链路返回
这种方式，通过给应用服务器设置虚拟IP，然后通过修改mac地址的方式，将请求分发出去，而应用服务器 收到请求后，可以直接响应给客户端，而不需要经过前置机。这种方式，由于 前置机 只需要接受请求，不需要响应数据，所以，效率较第二种较高。
IO和NIO的区别
IO面向流，阻塞。单线程一次只能应付一个连接。
NIO面向缓存，非阻塞，拥有选择器。可以单线程管理多个连接。
JDK8新特性
lambda表达式、方法引用、函数式接口、默认方法、stream、Optional类、Nashorn，JavaScript引擎、新的日期时间API、 Base64
java类加载器
JDK自带有三个类加载器：bootstrap ClassLoader、ExtClassLoader、AppClassLoader。
BootStrapClassLoader是ExtClassLoader的父类加载器，默认负责加载%JAVA_HOME%lib下的jar包和class文件。
ExtClassLoader是AppClassLoader的父类加载器，负责加载%JAVA_HOME%/lib/ext文件夹下的jar包和class类。
AppClassLoader是自定义类加载器的父类，负责加载classpath下的类文件。
HashMap原理
HashMap采用了链表加数组的形式来存放数据。它里面的每一个元素都会存放在一个内部类Entry中。默认初始化大小为2的整数倍16，每次扩容*2，负载因子为0.75。对元素操作时，会先根据key的hash值与数组长度计算在数组中的存放位置，找到位置后再判断key是否相同，不相同则作为链表遍历，相同则替换value。在jdk1.8后为了防止hash碰撞发生太过频繁，增加了红黑树的结构，在特定的情况下会替换链表结构。
HashSet原理
HashSet继承自Set，是无需不可重复集合，而Set又与List继承自Collection。HashSet底层采用HashMap来实现，每一个存放在Set中的元素，实际都是存放在了HashMap的Key中，所有元素的Value都是一个private final static Objcect OBJECT = new Object()。同样的可以添加null数据。
ConcurrentHashMap的原理
ConcurrentHashMap底层同样采用数组加链表的结构。与HashMap的区别在于前者是线程安全的，并且采用了分段锁。同时在JDK1.8后对其中的部分方法进行了更新，对数据的操作使用了Unsafe类中的方法直接对内存进行操作（除了删除是直接在方法上添加Synchronized）。
Object中常见的方法
getClass()：获取当前类对象
hashcode()：返回对象的hash值
equals(Object obj)：判断两个对象是否相等
clone()：创建并返回此对象的副本
toString()：返回该对象的字符串表示。
notify()：唤醒一个等待的线程。
notifyAll()：唤醒所有等待的线程。
wait()：另当前线程等待
finalize()：垃圾回收器回收该对象前会先执行一次该方法。
两个对象的hashCode相同，则equals一定相同嘛？
两个obj，如果equals()相等，hashCode()一定相等。两个obj，如果hashCode()相等，equals()不一定相等（Hash散列值有冲突的情况，虽然概率很低）。
final 在 java 中有什么作用？
final可以修饰类,函数,变量
修饰类时:意思是修饰类为最终类,任何类不能再继承它.
修改函数时:意思是该方法在类里是最终方法,继承它的方法不能去重写它.
修饰变量时:意思是被修饰的变量是常量或者叫终态变量,一旦初始化后就不能再改变变量的值.
如何将字符串反转
https://www.cnblogs.com/lanseyitai1224/p/6955609.html
8种基本数据类型和包装类
8种基本数据类型： boolean byte char short int long float double
对应的基本类型包装类：Boolean Byte Character Short Integer Long Float Double
代码中如果报错被catch，事务会生效嘛，该如何处理？
当有try catch后捕获了异常，事务不会回滚，处理办法如下：
（1）需要catch后 throw new RuntimeException 让事务回滚；
（2）或者TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();手动让事务回滚。
（3）使用@Transactional(rollbackFor = { Exception.class })，抛出捕获的非RuntimeException异常
对称加密和非对称加密定义和区别
定义：
1. 对称加密指的就是加密和解密使用同一个秘钥，所以叫做对称加密。对称加密只有一个秘钥，作为私钥。
常见的对称加密算法：DES，AES，3DES等等。
2. 非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。
常见的非对称加密算法：RSA，ECC
区别：
对称加密：加密解密用同一个密钥，被黑客拦截不安全
非对称加密：公钥加密，私钥解密；公钥可以公开给别人进行加密，私钥永远在自己手里，非常安全，黑客拦截也没用，因为私钥未公开。著名的RSA加密算法用的就是非对称加密。
持续更新！！！
