JAVA面试题 + 答案

文章目录

持续更新中 . . .
Java基础
前后端交互技术Ajax
MySQL面试题
Spring面试题
Spring mvc面试题
springboot面试题
Mybatis面试题
数据结构和算法

持续更新中 . . .

Java基础

1、jdk、jre、jvm有什么区别的区别？

jdk (Java Development Kit)：java开发工具包，是专门针对java程序员的开发包，所以通过jdk可以编写java程序
jre (Java Runtime Environment)：Java运行时环境，是运行java的环境集合，它提供了一些java的标准实现，以及一些java的基本类库。简单点说jre是Windows或Linux平台上安装的运行环境，没有安装jre，就无法运行java程序
jvm (Java Virtual Machine)：Java虚拟机，jvm只能识别.class这种字节码文件，通过jvm可以将.class文件的字节码指令进行识别，并调用操作系统提供的api来完成预期的任务，所以jvm是java的核心。

1、为什么java可以跨平台，实现一次编写到处运行的功能？

java跨平台运行的核心在于jvm，因为不同的操作系统有不同的api，如果直接面向操作系统进行编程的话，是无法实现跨平台操作的，而java引入了字节码的概念，jvm只认识字节码，它们解析到操作系统的api调用，针对不同的操作系统，用不同的jvm实现（如、Windows上由不同的jvm实现，Linux上也有不同的jvm实现），而java程序被编译成字节码之后，它们都是一样的。所以说，java之所以可以跨平台，是通过jvm隐藏了操作系统最底层的api，所以java程序员只需要面对jvm层面进行开发即可，再由jvm转义到其它系统对应的api来完成对应的工作

1、常量、静态变量和变量的区别？

java中使用final修饰常量，常量定义后不予许被需改，并且常量名习惯全部大写。定义常量的目的是为了防止某些固定属性被调用后值被修改了。常量存放在常量池中，在类加载之前就已经被加载，不会发生改变。需要注意的是，为了节省内存，常量一般都会同时使用static修饰，使用static修饰的常量称为静态常量。
由static修饰的变量称为静态变量，
变量定义后允许被修改，变量被调用时需要初始化（赋值），存放在堆或栈中。

2、java有几种基本数据类型，分别是哪些？它们对应的字节长度是多少？

java有八种基本数据类型，分别是byte、short、int、long、float、double、char、boolean

基本类型	字节	位	封装类
byte	1	8	Byte
short	2	16	Short
int	4	32	Integer
long	8	64	Long
float	4	32	Float
double	8	64	Double
char	2	16	Character
boolean	1/8	1	Boolean

int是默认整型，所以为了区分，使用byte、short、long时需在尾部加上名称的大写首字母（如：byte a = 5B、short a = 5S、long a = 5L）
double是默认浮点型，所以使用float时需加上F（如：float a = 5.5F）
1byte（字节 | B） = 8bit（比特 | 位）

3、int是基本数据类型，Integer是int的封装类，那么Integer也是基本数据类型吗？

不是，Integer是引用数据类型，int的默认值是0，Integer的默认值是null

3、String属于基本数据类型吗？

String不是基本数据类型，String属于引用类型，它是一个被final修饰的类

4、谈谈你对final关键字的理解？

final是一个关键字，可以修饰在变量、方法和类上。
final修饰的变量一定要赋初始值，且赋值后不能改变。
final修饰的方法不能被子类重写覆盖
final修饰的类不能被继承，它的内容是完整的，如String

5、谈谈你对static关键字的理解？

static修饰过的变量只会初始化一次（对象创建的时候），第二次创建对象后不会再初始化了。

5、什么是装箱、拆箱？什么是自动装箱和自动拆箱？

装箱，就是将基本数据类型转换成对应的对象类型(如：int转化成Integer)。拆箱，是将对象类型转化成基本数据类型(如：Integer转化成int)
自动装箱，就是自动将基本数据类型转换成对应的对象类型（编译器编译时调用valueOf()方法将基本类型转换为对象类型。自动拆箱，就是自动将对象类型转化成基本数据类型（编译器编译时调用intValue()、doubleValue()等方法将对象类型转化成基本类型）

//手动装箱
int a = 10;
Integer b = Integer.valueOf(a);
//手动拆箱
Integer c = 10;
int d = c.intValue();//自动装箱
Integer a = 10;
//自动拆箱
int b = a;

基本类型	封装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

5、手写：随机生成30 ~ 100的随机数

public class RandomSample{//法1public Integer randomInt1(){int min = 30;int max = 100;int result = new Random().nextInt(max - min) + min;return result;}//法2public Integer randomInt2(){int min = 30;int max = 100;int result = (int)(Math.random() * (max - min)) + min;return result;}public static void main(String[] args){System.out.println(new RandomSample().randomInt1());System.out.println(new RandomSample().randomInt2());}
}

写其中一个方法就好，类和main函数之类的可以不用写

5、手写：找出1 ~ 1000内的质数  (高频面试题)

public class PrimeNumber(){public static void main(){for(int i =2; i <= 1000; i++){boolean flag = true;for(int j=2; j < i; j++){if(i % j ==0){flag = false;break;}}if(flag){System.out.println(i);}}}}

5、面向对象的三大特征 (高频面试题)

封装，继承，多态

封装：封装就是将同一类事物的特征和功能包装在一起，只对外暴露需要调用的接口。通俗点说就是，我想让你看到的你可以看到，不想让你看到的你就看不到。平时最能体现封装的地方就是接口的定义，在接口中没有任何具体的实现，只有一系列抽象的方法。对于使用者来说，只需知道接口定义了哪些方法，它是做什么用的即可，而无需关心它的内部实现，这就体现了封装的特性。在Java中，接口是体现封装最常用的办法。

封装的好处：

实现专业的分工（接口的使用者只需关心如何使用即可，而接口的开发者则关注接口的实现，二者没有必然联系。）
减少代码耦合（大家都在面向接口编程，互不干扰。）
可以自由修改实现类的内部结构（只要接口的定义没有变化，对于使用者来说是没有影响的。）

继承：继承就是从已有类中派生出新的类，新的类吸收了已有类的属性和行为，并扩充了新的功能。父类是子类的抽象化，反过来子类是父类的具体化。Java中的类不支持多继承（即一个子类只能有一个父类），但一个接口可以继承多个其它接口。

接口和继承的区别：接口主要用来约束程序的行为，即对使用者暴露哪些方法。继承主要用于实现类之间代码的复用

多态：多态是三大特性中最重要的，多态是指同一个行为具有不同的表现形式和形态能力。比如有一个接口，它有几个不同的实现类，并且实现类的底层实现也不同，那么我们调用不同的实例就可以实现不同的操作

public interface Inter {String eat();
}
public class InterImpl1 implements Inter {@Overridepublic String eat() {return "吃饭";}
}
public class InterImpl2 implements Inter {@Overridepublic String eat() {return "吃土";}
}
public class Test {public static void main(String[] args){Inter inter = new InterImpl1();System.out.println(inter.eat());;Inter inter2 = new InterImpl2();System.out.println(inter2.eat());;}
}

5、写出下面程序的执行结果

public class RandomSample {public static void main(String[] args){new Child();}}
class Parent{static {System.out.println("@1我是父类静态代码块");}{System.out.println("@2我是父类非静态代码块");}public Parent(){System.out.println("@3我是父类构造函数");}
}
class Child extends Parent{static {System.out.println("@4我是子类静态代码块");}{System.out.println("@5我是子类非静态代码块");}public Child(){System.out.println("@6我是子类构造函数");}
}

执行结果：
@1我是父类静态代码块
@4我是子类静态代码块
@2我是父类非静态代码块
@3我是父类构造函数
@5我是子类非静态代码块
@6我是子类构造函数

解题思路：
1、静态优先
2、父类优先
3、非静态优先于静态函数
4、构造函数也属于非静态块

5、谈谈java异常体系？

异常主要分为两大类Error和Exception，它们都继承了Throwable类。其中Error属于不可捕获异常，因为这类异常不是由程序错误引起的，一般是指系统奔溃，内存溢出等异常，对于这类异常我们是无法捕获处理的。Exception则是指代由程序引发的异常，这类异常是可以被捕获处理的。Exception又可分为CheckException（编译期异常）和 RuntimeException（运行期异常），CheckException属于编译期异常，编译器会捕获到这类异常，需要try catch捕获处理或throw抛出才能通过编译，比如IOException就属于CheckException异常。RuntimeException则是在程序运行后才会出现的异常，比如空指针异常，数组下标越界异常等

5、写出下列程序运行结果？

public class constantPool{public static void main(String[] args){String s1 = "abc";String s2 = "abc";String s3 = "abc" + "def";String s4 = "abcdef";String s5 = s2 + "def";String s6 = new String("abc");System.out.println(s1 == s2);System.out.println(s3 == s4);System.out.println(s4 == s5);System.out.println(s4.equals(s5));System.out.println(s1 == s6);}
}

运行结果：
true
true
false
true
false

解题思路：
1、不同的String对象引用相同的字符串的时候，它们都是指向同一个内存地址的。而==比较的是字符串的内存地址。
2、s2在编译期编译器可以确认它的内容，如果常量池中有这个字符串存在，则会直接将这个字符串的内存地址分配给s2，而不会在常量池中开辟一块新的内存。
3、s5中的s2属于引用类型，在编译期，编译器是无法确认它的内容的，所以会在在常量池中开辟一块新的内存地址分配给s5。
4、equals比较的是字符串的内容。
5、new String()创建的字符串对象是保存在堆中的，而不是保存在常量池中，它们的地址是不一样的。

5、String ，StringBuilder 和 StringBuffer的区别？（高频面试题）

String把数据存放在常量池中，以常量形式保存，且由final修饰，因此每一个String被创建好了之后就不会发生改变，是线程安全的。但这也造成了它的执行速度是最差的，因此String只适用于少量字符串的操作。
StringBuffer是线程安全的，因为它的底层使用了synchronized对方法进行同步处理，所以StringBuffer适用于多线程环境下操作大量字符串，它的执行速度比String快，比StringBuilder慢。
StringBuilder的执行速度最快，当它是线程不安全的，因此StringBuilder适用于单线程环境下操作大量字符串的场景。

5、List 和 Set的区别？

List 和 Set接口在存储上截然不同
1、List允许重复，同一个字符串或对象允许在List中存在多个副本。Set不允许重复，会通过Hash进行去重。
2、List允许将null放入集合中，而Set不允许null值
3、List是有序集合，保存的数据是按插入时的顺序来依次保存。而Set集合默认是无序的（但你也可以自己定义排序的规则来进行排序）

5、分别列举几种常见的List 和 Set的实现类？

List：ArrayList 和 LinkList
Set：HashSet，LinkdedHashSet，TreeSet

5、ArrayList（数组） 和 LinkList（链表）的区别？(高频面试题)

存储结构不同：ArrayList是一个动态数组，各个元素在内存中紧挨着存储，是一种紧密连续的结构。LinkList是基于链表存储的，链表是一个松散的结构，各个元素存储在内存中的不同地址中，元素与元素之间通过指针的方式进行连接。
遍历方式不同：ArrayList直接找到第一个元素的地址然后依次向下读取直到最后一个便完成了ArrayList的遍历。而LinkList则是先找到第一个地址，然后再通过第一个地址找到第二个地址，依此类推。
使用场景不同：ArrayList的底层是使用数组结构，所以在插入和删除指定位置的元素时，会导致新数组的创建，效率会很低，因此不适用于大数据量的增删操作，但由于数组允许通过索引的方式访问元素，查找元素非常便捷，适用于大数据量读取的场景，也就是查询操作。而LinkList的底层是双向循环链表，链表的每个元素通过指针来记住前一个和后一个元素来将所有元素连接起来，在增伤元素时，只需修改元素之间的引用关系即可，所以适用于频繁更新和插入操作

5、ArrayList（数组列表） 和 Array（数组）的区别？

Array在创建时需要指定长度，然后会在内分中分配一个固定的空间。而ArrayList内部封装了一个长度可变的数组对象，当插入的元素超过数组长度时，ArrayList就会在内存中分配一块更大的空间来存储，所以ArrayList可看成一个长度可变的数组。

5、HashSet 和 TreeSet 的区别？

排序方式不同：HashSet以hash值作为排序的依据，hash具有不确定性，所以不能保证顺序。而TreeSet可以按照预置的规则来排序
底层存储不同：HashSet是基于HashMap来存储。TreeSet是基于TreeMap来存储的。
底层实现不同：而HashSet的底层是hash表，而TreeSet的底层是基于二叉树来实现的。

5、编程：List排序？

public class User {private String name;private int age;public User(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}
}
public class RandomSample {public static void main(String[] args){List list = new ArrayList();list.add(new User("张三",15));list.add(new User("李四",25));list.add(new User("王五",35));/*** 要求: 将list按照升序排列输出*/Collections.sort(list, new Comparator<User>() {@Overridepublic int compare(User o1, User o2) {return (o2.getAge() - o1.getAge());}});System.out.println(list);}
}

如果是降序，则将o1.getAge() - o2.getAge() 改为 o2.getAge() - o1.getAge() 即可

5、谈谈Java IO中有几种类型的流，并分别列举几种它们的实现类？

按职能可分为输入流和输出流，输入流是指将程序外部的文件输入到文件中的流，输出流则是指将程序产生的文件进行输出
按内容可分为字节流和字符流，字节流通常就是我们所说的二进制，而字符流则是指我们可以阅读的字符

5、手写编程（无提示）：将e盘中的java.zip文件 复制到 e盘中的workspace文件夹中？

public static viod main(String[] args){File source = new File("e:/java.zip");File target = new File("e:/workspace/java.zip");InputStream input = null;OutputStream output = null;try{input = new FileInputStream(source); //创建字节输入流output = new FileOutputStream(target); //创建字节输出流Byte[] buf = new byte[1024]; //定义一个字节数组作为缓冲区，并指定一次读取多少个字节int len; //记住读入缓冲区的字节长度while(len = input.read(buf) != -1){ //判断是否读取到文件末尾output.write(buf, 0, len); //从第一个字节开始，向文件中写入len个字节}   }catch(FileNotFoundException e){e.printStackTrace();}catch(IOException e){e.printStackTrace();}finally{try{input.close(); //关闭文件输入流output.clase(); //关闭文件输出流}catch(IOException e){e.printStackTrace();}}
}

5、创建多线程有几种方式？

1、继承Thread类 2、实现Runnable接口 3、实现Callable接口（jdk1.5以后引入了线程池的概念，并添加该创建线程的方式）
不管是继承Thread类还是实现Runnable接口都需要重写run()方法

public class RandomSample {public static void main(String[] args){ThreadSample2 thread1 = new ThreadSample2();ThreadSample2 thread2 = new ThreadSample2();thread1.setName("兰博基尼");thread2.setName("法拉利");thread1.start();thread2.start();}}class ThreadSample2 extends Thread{@Overridepublic void run() {int speed = new Random().nextInt(100) + 100;for(int i = 1; i <= 10; i++){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "：已前进" + (i * speed) + "米");}}
}

public class ThreadSample {public static void main(String[] args){Thread thread1 = new Thread(new ThreadSample2());Thread thread2 = new Thread(new ThreadSample2());thread1.setName("兰博基尼");thread2.setName("法拉利");thread1.start();thread2.start();}}class ThreadSample2 implements Runnable{@Overridepublic void run() {int speed = new Random().nextInt(100) + 100;for(int i = 1; i <= 10; i++){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "：已前进" + (i * speed) + "米");}}
}

5、如果在一个类的main方法中新创建了3个线成，那么这个程序中有几个线程？

5条，新建的3个线程 + main主线程 + jvm额外分配的线程（用来监听线程状态和回收的线程）

5、线程有哪些状态？

线程有5中状态，分别为new新建，ready就绪，running运行中，blocked阻塞，dead死亡。它们对应着线程的5个阶段
1、线程执行start()方法后会，进入就绪状态。
2、jvm为该线程分配了cpu执行时间后，就会进入运行状态，这个时候就会run()方法中的代码。
3、在遇到I/O读写或sleep()睡眠时，线程就会进入阻塞状态
4、当读写操作完成了或sleep()睡眠时间过去了，线程就会重新进入就绪状态，等待cpu执行时间片。
5、线程执行完后悔进入死亡状态，这种死亡状态被称为自然死亡。除此之外，当程序遇到未被捕捉到的异常导致程序中断，这种死亡状态叫猝死。

5、谈谈线程安全问题？

线程安全问题是由多个线程同时访问同一个资源导致的，想要解决线程安全问题，就必须保证访问的资源在任意时刻只能有一个线程访问。

5、什么是线程同步？

当使用多个线程访问同一个资源的时候，非常容易发生线程安全问题。即使用多个线程访问同一个资源，没有达到预期的效果，这就是线程不安全。而解决这种问题的方法就叫线程同步机制

5、线程中有几种同步方式？

3种，
synchronized关键字，synchronized关键字可以定义在方法前（同步方法），也可以定义在方法中（同步代码块），将共享资源的操作放在synchronized定义区域，就会为这些操作加上了锁。当synchronized有个缺点，就是某个资源竞争非常激烈的情况下，synchronized的执行效率就会便的很差
wait() 和 notify()
Lock接口，Lock接口很稳定，所以高并发环境下，优先推荐使用Lock接口

5、你说你的项目中用到了Redis，为什么要用Redis？

因为关系型数据库如mysql已经不能使用于所有场景，在访问高峰期很有可能会导致数据库给搞崩。在我的这个项目中，针对首页的头条信息，店铺列别信息等较为固定(即不经常修改的数据)，却极为常用的数据，使用redis来缓存，可以减小数据库的压力。

5、Redis有哪些数据结构？

redis有5种基本数据结构：String(字符串)、Hash(散列)、List(列表)、Set(集合)、Sorted Set(有序集合)

前后端交互技术Ajax

5、什么是ajax？

Ajax = 异步JavaScript + XML，Ajax的核心对象是XmlHttpRequest（可扩展超文本传输请求），通过Ajax可以在不刷新页面的情况下，发送异步请求指后台，并获取后台返回的json数据。
在工作中，一般是使用Ajax的jquery写法，原生的js写法很繁琐，较为少用

MySQL面试题

1、什么是事务？

事务是指一个程序执行单元执行的一系列操作，它以结果为导向，要么完全执行，要么完全不执行，只要由一个动作失败，事务就会回滚到最开始的状态，仿佛什么都没发生过。

2、说说什么是ACID？

ACID是事务的4个特性，原子性、一致性、隔离性和永久性。

3、什么是事务并发问题，都有哪些？

事务并发问题是由事务并发执行过程中交叉执行而导致的，事务并发问题大致可以分为这三类，脏读、不可重复读和幻读。

4、什么是事务隔离级别，划分为几个等级？

事务隔离级别是为了解决事务并发问题产生的，共划分为4个等级：read-uncommitted（读未提交）、read-committed（读已提交）、repeatable-read（可重复读）、serializable（串行化）。其中serializable（串行化）的级别最高，级别越高，解决的问题越多，但执行效率就越低。MySQL支持4中隔离级别，默认使用repeatable-read（可重复读）。Oracle只支持serializable（串行化）和read-committed（读已提交）两种隔离级别，默认使用read-committed（读已提交）。

Spring面试题

1、什么是Spring？

Spring是一个轻量级的开源框架，为简化企业级应用开发而生，Spring可以使简单的JavaBean实现以前只有EJB才能实现的功能

2、谈谈你对IOC和DI的理解？

IoC控制反转是一种设计理念，就是将手动创建实例对象的权利，反转给spring容器，由Spring容器来管理对象的生命周期，这种方式可以使对象与对象之间的引用进行有效的解耦。当底层的类发生改变时，只需修改配置文件即可，大大提高了程序的管理和维护效率。
DI是IoC这种设计理念的具体实现，由ApplicationContext容器对象在运行时，动态注入对象。spring中使用反射+工厂来实现DI

2、Spring的两大核心是什么？

Spring的核心是IoC 和 AOP
- IoC控制反转，就是将原本在程序中手动创建实例对象的权利，反转给spring容器，有Spring容器来管理对象的生命周期
- AOP面向切面编程，AOP是通过预编译和运行期动态代理的方式来实现程序功能统一维护的一种方式，

3、使用Spring有哪些好处？

1、方便解耦，简化开发
- 将对象创建和对象之间依赖关系维护，交给Spring进行管理，避免硬编码造成程序的过度耦合
2、AOP编程支持
- Spring提供面向切面编程，可以将日志记录、权限拦截等服务从业务逻辑中分离出来，方便实现日志记录、权限校验等功能
3、声明式事务支持
- Spring提供声明式事务，只需通过配置就可以完成事务管理，无需手动编写事务管理代码
4、方便集成各种优秀框架
- Spring不排斥其它开源框架，内部提供了对mybatis、hibernate、struts等优秀框架的直接支持
5、方便集成各种优秀框架
- Spring支持junit4，可以通过@Test注解进行测试，提高测试效率
6、降低JavaEE API使用难度
- Spring对JavaEE开发中一些难用的API（JDBC、JavaMail . . .）进行了封装，使这些API的使用难度大大降低

4、BeanFactory 和 ApplicationContext 的区别？

BeanFactory 和 ApplicationContext都是接口。
功能上的区别：
- BeanFactory是Spring最底层的接口，提供了简单的容器功能（只提供了实例化对象和获取对象的功能）。
- ApplicationContext是BeanFactory的子接口，在BeanFactory的基础上扩展了统一加载资源、消息发送、国际化处理等功能。
初始化对象的时机不同？
- BeanFactory采取延迟机制，只有在第一次调用getBean()方法的时候，才会将配置文件中配置的bean加载到spring容器进行初始化。
- ApplicationContext在启动Ioc容器时，就会将配置文件中配置的所有bean都进行初始化。（这种方式的优点是可以快速发现配置文件中的错误，缺点是造成浪费）

5、Spring bean有几种实例化方式？

3种
使用类构造器实例化（这是最常用的方法），它包括有参构造和无参构造两种方式
使用静态工厂方法实例化
使用实例工厂方法实例化

5、DI属性注入有几种方式？

4种
1、setter设置注入（最常用）
2、构造器注入
3、注解注入
4、p命名空间注入

5、说明scope的作用和取值？

用于控制对象的数量，即是单例（singleton）还是多例（prototype），默认为singleton

5、@Autowired 和 @Resource的区别？

1、@Resource是官方注解，@Autowired是第三方注解
2、@Autowired只能根据类型来匹配，而@Resource 则可以根据名称来匹配
3、@Resource = @Autowired + @Qualifier

Spring mvc面试题

spring mvc的执行流程？

1、客户端发起请求，请求被DispatcherServlet接收
2、DispatcherServlet接收到请求后，会通过HandlerMapping将URL请求映射到对应的Handler中，映射成功后会返回一个HandlerExcutionChain处理器执行链(包括一个handler和至少一个HandlerInterceptor)
3、DispatcherServlet拿到handler后，通过HandlerAdapter执行handler的处理方法，handler处理方法执行完后，会返回一个ModelAndView模型数据和逻辑试图
4、DispatcherServlet拿到返回的ModelAndView后，将其交给ViewResolver视图解析器进行解析（将逻辑视图解析成物理视图），解析完成后会返回一个view视图对象，并将model模型数据填充到试图中,进行渲染并响应给客户端

你了解Restful风格？

Restful是一种规范，以URL表示要访问的资源。与HTTP通过URL访问资源的理念是一样的。
在Restful中不同的请求对应不同的操作。如GET/POST/PUT/DELETE分别对应服务器的查询，新增，修改，删除操作。而由于浏览器不支持PUT和DELETE请求，所以默认使用GET进行数据的查询操作，使用POST来完成数据的增删改操作。
Restful风格下，发送同一个URL使用不同的请求方式，服务器执行的操作和返回的结果是不一样的。
Restful只响应数据，不进行页面跳转，通常以json形式体现。在web开发中，如果服务端使用Restful风格，那么在客户端使用Ajax就会是一对绝配。

springmvc拦截器的作用，哪些场景下会用到springmvc拦截器？

springmvc拦截器用于对控制器方法进行前置、后置处理，在不修改源代码的前提下实现所需功能。springmvc拦截器的底层实现技术是AOP，定义拦截器必须继承HandlerInterceptorAdater类或实现HandlerIntercetor接口。
在登陆拦截，权限校验，字符集管理，日志记录等场景中可能会用到springmvc拦截器。

springboot面试题

spring、springmvc、springboot的区别？

1、spring是所有spring应用的基础，通过它提供的IoC控制反转和AOP面向切面编程的特性，可以轻松的对JavaBean进行管理
2、springmvc是spring的一个子项目用于提供web方面的支持，它主要作用是替代传统javaEE中的servlet。同时springmvc中的Controller也是需要spring容器进行管理的，并且springmvc拦截器底层也使用了spring的AOP技术来对Controller的行为进行扩展。
3、springboot是spring的敏捷开发框架。它使用了一套优秀的模板，可以通过简单的几行配置，就可以实现spring、springmvc中复杂的功能。并且springboot内嵌tomcat，无需打包部署，直接运行即可。

Spring Initializr是创建spring boot projects的唯一方法吗

不是，还可以使用maven手动构建。比如eclipse就没有spring initializr，它必须要通过maven手动构建。

springboot支持几种配置文件

springboot目前仅支持两种格式的配置文件 application.properties 和 application.yml。因为在使用spring、springmvc的时候，是使用xml格式的配置文件，但springboot觉得这种格式的配置文件太过笨重，所以就没有使用。

application.properties和application.yml的区别

application.properties采用的是单行配置，这种格式的配置可读性很差，且不利于后期的维护。
application.yml采用分层缩进的方式，将同一个种类的配置项都是集中在一起进行配置。这种配置的格式可读性强，且利于后期维护。springboot推荐使用这种格式的配置文件。

列举至少5个springboot中的配置选项

server.port 端口
server.servlet.context-path 上下文路径
server.tomcat.uri-encoding uri字符编码,springboot默认编码格式为UTF-8
logging.file 日志文件输出路径
logging.level 日志输出级别
spring.datasource.url
spring.datasource.username
spring.datasource.password
spring.datasource.driver-class-name
mybatis.type-aliases-package 别名
mybatis.mapper-locations 映射文件

Mybatis面试题

5、mybatis的开发流程？

5、你知道mybatis吗？

mybatis有两级缓存
一级缓存与sqlSeesion会话绑定，是默认开启的。
二级缓存是应用全局缓存（所有sqlSession共享），是默认不开启的，需要通过cache标签来配置开启

数据结构和算法