一、Java
Collections
java.util.Collections 是一个包装类（工具类/帮助类）。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，用于对集合中元素进行排序、搜索以及线程安全等各种操作，服务于Java的Collection框架。
常用方法：
- sort(Collection)方法的使用(含义：对集合进行排序)。
- reverse()方法的使用(含义：反转集合中元素的顺序)。
- shuffle(Collection)方法的使用(含义：对集合进行随机排序)。
- fill(List list,Object o)方法的使用(含义：用对象o替换集合list中的所有元素)
- copy(List m,List n)方法的使用(含义：将集合n中的元素全部复制到m中,并且覆盖相应索引的元素)。
- min(Collection),min(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)。
- max(Collection),max(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)。
- indexOfSubList(List list,List subList)方法的使用(含义：查找subList在list中首次出现位置的索引)。
- lastIndexOfSubList(List source,List target)方法的使用与上例方法的使用相同
- rotate(List list,int m)方法的使用(含义：集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来)。移动列表中的元素，负数向左移动，正数向右移动
- swap(List list,int i,int j)方法的使用(含义：交换集合中指定元素索引的位置)
- binarySearch(Collection,Object)方法的使用(含义：查找指定集合中的元素，返回所查找元素的索引)。
- replaceAll(List list,Object old,Object new)方法的使用(含义：替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false)。
hashset源码
hashmap源码
HashMap源码解析（JDK1.8）
hashset和hashmap的区别
hashmap、hashtable原理，1.7,1.8的区别
HashMap源码解析（JDK1.8）
haspmap的底层实现put操作，扩容机制
HashMap源码解析（JDK1.8）
currenthashmap如何解决线程安全,1.7版本以及1.8版本的不同
ConcurrentHashMap源码解析（JDK1.8）
arraylist默认大小，如何扩展的
ArrayList默认大小为10，扩容为原先数组大小的1.5倍，再判断新数组容量是否够用和长度是否大于最大值，再调用Arrays.copyOf复制到新数组上。
/** * 扩容，以确保它可以至少持有由参数指定的元素的数目 * * @param minCapacity 所需的最小容量 */ private void grow(int minCapacity) { // 获取到ArrayList中elementData数组的内存空间长度 int oldCapacity = elementData.length; // 扩容至原来的1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1); // 再判断一下新数组的容量够不够，够了就直接使用这个长度创建新数组， // 不够就将数组长度设置为需要的长度 if (newCapacity - minCapacity < 0) newCapacity = minCapacity; //若预设值大于默认的最大值检查是否溢出 if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // 调用Arrays.copyOf方法将elementData数组指向新的内存空间时newCapacity的连续空间 // 并将elementData的数据复制到新的内存空间 elementData = Arrays.copyOf(elementData, newCapacity); }
什么情况下会有线程安全的问题，怎么解决
互斥同步：推荐使用 synchronized 关键字进行同步, 在 concurrent包中有ReentrantLock类, 实现效果差不多. 还是推荐原生态的synchronized.
非阻塞同步：需要硬件指令完成.常用的指令有:
Test-and-Set
Fetch-and-Increment
Swap
Compare-and-Swap (CAS)
Load-Linked/Store-Conditional (LL/SC)
典型的应用在 AtomicInteger 中
无同步方案：将变量保存在本地线程中，就不会出现多个线程并发的错误了。
java中主要使用的就是ThreadLocal这个类。
synchronized和reetrantlock锁
cas
volatitle
volatile是变量修饰符，其修饰的变量具有可见性，Java的做法是将该变量的操作放在寄存器或者CPU缓存上进行，之后才会同步到主存，使用volatile修饰符的变量是直接读写主存，volatile不保证原子性，同时volatile禁止指令重排。
线程池
创建线程的方法
- 继承Thread类创建线程类，重写run方法，run方法就是代表线程需要完成的任务，调用线程对象的start()来启动该线程，线程类已经继承了Thread类，所以不能再继承其他父类。
- 实现Runnable接口创建线程类，定义Runnable实现类，重写run方法
- 实现Callable接口，重写call()方法，call()作为线程的执行体，具有返回值
- 线程池，使用线程池产生线程对象java.util.concurrent.ExecutorService、java.util.concurrent.Executors
java的线程和操作系统的线程什么关系
优先级队列，如何处理
hash冲突的解决方式，如何判断各个方式的优劣
- 开放定址法
- 链地址法
- 再哈希法
- 建立一个公共溢出区
乐观锁 和悲观锁
悲观锁：假定会发生并发冲突，则屏蔽一切可能违反数据完整性的操作
乐观锁：假定不会发生并发冲突，只在数据提交时检查是否违反了数据完整性（不能解决脏读问题）
如何实现让一个线程等待其他线程完成后在执行
- 通过一个线程安全的全局变量来控制, 每个其他线程执行结束该全局变量减一, 该线程判断全局变量为0时再向下执行
- 该线程分别其他子线程的对象, 然后对其他线程执行wait方法, 释放对其他线程对象的占用，其他线程在执行结束后, 获取自己线程对象的锁, 执行notify方法, 唤醒该线程
- join方法
- 使用 CountDownLatch
AQS同步器框架，countdowmlatch，cyclebarrier，semaphore，读写锁
线程池的参数，各种线程池
string ，stringbuild，stringbuffer区别，string内部结构
拆箱装箱的原理
在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。
public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } public int intValue() { return value; }
Lambda表达式
Lambda 表达式，也可称为闭包。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。
如何实现list和map
锁以及锁的底层实现
队列和栈由什么实现的
重写和重载
二、JVM
说说垃圾回收，回收算法
jvm内存分区
程序计数器:记录正在执行的虚拟机字节码指令的地址（如果正在执行的是本地方法则为空）。
Java虚拟机栈:每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
本地方法栈:与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
Java堆:几乎所有对象实例都在这里分配内存。是垃圾收集的主要区域（"GC 堆"），虚拟机把 Java 堆分成以下三块：
新生代又可细分为Eden空间、From Survivor空间、To Survivor空间，默认比例为8:1:1。
方法区：方法区（Method Area）与Java堆一样，是各个线程共享的内存区域。Object Class Data(类定义数据)是存储在方法区的，此外，常量、静态变量、JIT编译后的代码也存储在方法区。
运行时常量池：运行时常量池是方法区的一部分。Class 文件中的常量池（编译器生成的各种字面量和符号引用）会在类加载后被放入这个区域。除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。这部分常量也会被放入运行时常量池。
直接内存：直接内存（Direct Memory）并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用，而且也可能导致OutOfMemoryError 异常出现。避免在Java堆和Native堆中来回复制数据。
CMS垃圾收集器
类加载机制和双亲委派模型，以及为什么要实现双亲委派模型
虚拟机调优参数
三、数据结构与算法
链表反转
将当前节点和下一节点保存起来，然后将当前节点反转。
public ListNode ReverseList(ListNode head) { //head为当前节点，如果当前节点为空的话，那就什么也不做，直接返回null ListNode pre = null;//pre为当前节点的前一节点 ListNode next = null;//next为当前节点的下一节点 //需要pre和next的目的是让当前节点从pre.head.next1.next2变成pre<-head next1.next2 //即pre让节点可以反转所指方向，但反转之后如果不用next节点保存next1节点的话，此单链表就此断开了 //所以需要用到pre和next两个节点 //1.2.3.4.5 //1<-2<-3 4.5 //做循环，如果当前节点不为空的话，始终执行此循环，此循环的目的就是让当前节点从指向next到指向pre while (head != null) { //先用next保存head的下一个节点的信息，保证单链表不会因为失去head节点的原next节点而就此断裂 next = head.next; //保存完next，就可以让head从指向next变成指向pre了 head.next = pre; //head指向pre后，就继续依次反转下一个节点 //让pre，head，next依次向后移动一个节点，继续下一次的指针反转 pre = head; head = next; } //如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点 //直接输出pre就是我们想要得到的反转后的链表 return pre; }
利用递归走到链表的末端，然后再更新每一个节点的next值 ，实现链表的反转。
public ListNode ReverseList(ListNode head) { //如果链表为空或者链表中只有一个元素 if (head == null || head.next == null) return head; //先递归找到到链表的末端结点，从后依次反转整个链表 ListNode reverseHead = ReverseList(head.next); //再将当前节点设置为后面节点的后续节点 head.next.next = head; head.next = null; return reverseHead; }
跳楼梯
package Recursion;/** * 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。 */public class Solution04 { public static void main(String[] args) { Solution04 solution04 = new Solution04(); System.out.println(solution04.JumpFloor_2(3)); } /** * 直接用递归 * * 对于第n个台阶来说，只能从n-1或者n-2的台阶跳上来，所以 * F(n) = F(n-1) + F(n-2) * f(1)=1 * f(2)=2 * * @param target 台阶数 * @return 跳法 */ public int JumpFloor(int target) { if (target <= 1) { return 1; } if (target <= 2) { return 2; } else { return JumpFloor(target - 1) + JumpFloor(target - 2); } } /** * 用迭代的方法，用两个变量记录f(n-1) f(n-2) * * @param target 台阶数 * @return 跳法 */ public int JumpFloor_2(int target) { int one = 1, two = 2, fN = 0; if (target <= 0) { return 0; } else if (target == 1) { return 1; } else if (target == 2) { return 2; } else { for (int i = 3; i <= target; i++) { fN = one + two; one = two; two = fN; } return fN; } }}
不用乘法实现乘法
一个字符串找里面是否有重复的字符
数组的最大连续子串和
package Array;/** * 连续子数组的最大和 * 在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？ * 例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。(子向量的长度至少是1) */public class Solution01 { public static void main(String[] args) { int[] arr = {6,-3,-2,7,-15,1,2,2}; System.out.println(FindGreatestSumOfSubArray(arr)); } public static int FindGreatestSumOfSubArray(int[] array) { if(array.length==0) return 0; int sum = array[0];//保存每组的和 int maxSum = array[0];//连续子数组最大和 //动态规划 for(int i = 1;i<array.length;i++){ sum = Math.max(sum+array[i],array[i]); maxSum = Math.max(sum,maxSum); } return maxSum; }}
快排的思想，为什么是O(N)，每次的基准选择哪个
/** * 快速排序 * * @param array * @param _left * @param _right */ private static void quickSort(int[] array, int _left, int _right) { int left = _left;// int right = _right; int pivot;//基准线 if (left < right) { pivot = array[left]; while (left != right) { //从右往左找到比基准线小的数 while (left < right && pivot <= array[right]) { right--; } //将右边比基准线小的数换到左边 array[left] = array[right]; //从左往右找到比基准线大的数 while (left < right && pivot >= array[left]) { left++; } //将左边比基准线大的数换到右边 array[right] = array[left]; } //此时left和right指向同一位置 array[left] = pivot; quickSort(array, _left, left - 1); quickSort(array, left + 1, _right); } }
最好情况下时间复杂度最低的是那种排序
分层打印二叉树
package Tree;import java.util.ArrayList;import java.util.LinkedList;import java.util.Queue;/** * 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。 * 思路： * 按层次输出二叉树 * 访问根节点，并将根节点入队。 * 当队列不空的时候，重复以下操作。 * 1、弹出一个元素。作为当前的根节点。 * 2、如果根节点有左孩子，访问左孩子，并将左孩子入队。 * 3、如果根节点有右孩子，访问右孩子，并将右孩子入队。 */public class Solution8 { public static void main(String[] args) { int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9}; Solution8 solution8 = new Solution8(); TreeNode treeNode = solution8.createBinaryTreeByArray(array, 0); for (ArrayList list : solution8.Print(treeNode)) { System.out.println(list); } } /** * 层次遍历 * * @param pRoot 根节点 * @return arrayLists */ ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) { //存放结果 ArrayList<ArrayList<Integer>> arrayLists = new ArrayList<>(); if (pRoot == null) { return arrayLists; } //使用队列，先进先出 Queue<TreeNode> queue = new LinkedList<>(); //存放每行的列表 ArrayList<Integer> arrayList = new ArrayList<>(); //记录本层打印了多少个 int start = 0; //记录下层打几个 int end = 1; queue.add(pRoot); while (!queue.isEmpty()) { TreeNode temp = queue.remove(); //添加到本行的arrayList arrayList.add(temp.val); start++; //每打印一个节点，就把此节点的下一层的左右节点加入队列，并记录下一层要打印的个数 if (temp.left != null) { queue.add(temp.left); } if (temp.right != null) { queue.add(temp.right); } //判断本层打印是否完成 if (start == end) { //此时的queue中存储的都是下一层的节点，则end即为queue大小 end = queue.size(); start = 0; //把arrayList添加到结果列表arrayLists中 arrayLists.add(arrayList); //重置arrayList arrayList = new ArrayList<>(); } } return arrayLists; } private TreeNode createBinaryTreeByArray(int[] array, int index) { TreeNode tn = null; if (index < array.length) { int value = array[index]; tn = new TreeNode(value); tn.left = createBinaryTreeByArray(array, 2 * index + 1); tn.right = createBinaryTreeByArray(array, 2 * index + 2); return tn; } return tn; } public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } }}
非递归方式实现二叉树的层序遍历
- 思路：
- 访问根节点，并将根节点入队。
- 当队列不空的时候，重复以下操作。
- 1、弹出一个元素。作为当前的根节点。
- 2、如果根节点有左孩子，访问左孩子，并将左孩子入队。
- 3、如果根节点有右孩子，访问右孩子，并将右孩子入队。
public void levelOrder(TreeNode root) { //使用队列，先进先出 Queue<TreeNode> queue = new LinkedList<>(); queue.add(root); while (!queue.isEmpty()) { TreeNode temp = queue.poll(); System.out.print(temp.val + " "); if (temp.left != null) { queue.offer(temp.left); } if (temp.right != null) { queue.offer(temp.right); } } }
非递归方式实现二叉树的中序遍历
二叉树后序遍历
如何判断链表有环
剑指Offer-链表中环的入口结点
package LinkedList;import java.util.HashSet;public class Solution24 { /** * 假设x为环前面的路程，a为环入口到相遇点的路程， c为环的长度 * 当快慢指针相遇的时候： 此时慢指针走的路程为Sslow = x + m * c + a * 快指针走的路程为Sfast = x + n * c + a * 2 Sslow = Sfast * 2 * ( x + m*c + a ) = (x + n *c + a) * 从而可以推导出： x = (n - 2 * m )*c - a = (n - 2 *m -1 )*c + c - a * 即环前面的路程 = 数个环的长度（为可能为0） + c - a * 什么是c - a？这是相遇点后，环后面部分的路程。 * 所以，我们可以让一个指针从起点A开始走，让一个指针从相遇点B开始继续往后走， 2个指针速度一样， * 那么，当从原点的指针走到环入口点的时候（此时刚好走了x） 从相遇点开始走的那个指针也一定刚好到达环入口点。 * 所以两者会相遇，且恰好相遇在环的入口点。 * 时间复杂度：O(n) * 空间复杂度：O(1) * * @param pHead * @return */ public ListNode EntryNodeOfLoop_2(ListNode pHead) { if (pHead == null || pHead.next == null || pHead.next.next == null) return null; ListNode fast = pHead.next.next; ListNode slow = pHead.next; //先判断有没有环 while (fast != slow) { if (fast.next != null && fast.next.next != null) { fast = fast.next.next; slow = slow.next; } else { //没有环 return null; } } fast = pHead;//把fast指向头节点 //有环 while (fast != slow) { fast = fast.next; slow = slow.next; } return fast; } /** * 利用HashSet元素不能重复 * * @param pHead * @return */ public ListNode EntryNodeOfLoop(ListNode pHead) { HashSet<ListNode> hashSet = new HashSet<>(); while (pHead != null) { if (!hashSet.add(pHead)) { return pHead; } pHead = pHead.next; } return null; } public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }}
冒泡排序，如何优化
排序算法-冒泡排序
/** * 冒泡排序 * * @param array */ private static void bubbleSort(int[] array) { if (array == null || array.length == 0 || array.length == 1) return; for (int i = 0; i < array.length - 1; i++) { for (int j = 0; j < array.length - 1 - i; j++) {//注意数组边界 if (array[j] > array[j + 1]) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } } private static void bubbleSort(int[] array) { if (array == null || array.length == 0 || array.length == 1) return; boolean flag = true;//发生了交换就为true, 没发生就为false，第一次判断时必须标志位true int k = array.length - 1; int pos = 0;//pos变量用来标记循环里最后一次交换的位置 for (int i = 0; i < array.length - 1; i++) { flag = false;//每次开始排序前，都设置flag为未排序过 for (int j = 0; j < k; j++) {//注意数组边界 if (array[j] > array[j + 1]) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; flag = true;//表示交换过数据; pos = j; } } k = pos; //判断标志位是否为false，如果为false，说明后面的元素已经有序，就直接return if (flag == false) return; } }
合并两个有序数组
Leetcode#88. Merge Sorted Array（合并两个有序数组）
package Array;/** * 88. Merge Sorted Array（合并两个有序数组） * 给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。 */public class Solution88 { public static void main(String[] args) { Solution88 solution88 = new Solution88(); solution88.merge(); } /** * 从两个数组中的末尾开始进行合并，先找两个数组中较大的移动到正确的位置，将那个移动的位置值向前移动一个位置，再进行同样的操作，直到所有的元素处理完。 * * @param nums1 * @param m * @param nums2 * @param n */ public void merge(int[] nums1, int m, int[] nums2, int n) { int i = m - 1; int j = n - 1; int index = m + n - 1; while (i >= 0 && j >= 0) { if (nums1[i] > nums2[j]) { nums1[index--] = nums1[i--]; } else { nums1[index--] = nums2[j--]; } } while (j >= 0) { nums1[index--] = nums2[j--]; } }}
给一串数字，建最大堆，以及建堆的时间复杂度，然后就让手撕堆排序的代码
找两字符串中都存在的元素
四、操作系统
死锁产生的条件
- 互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
- 占有和等待：已经得到了某个资源的进程可以再请求新的资源。
- 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
- 环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在下一个进程所占有的资源。
产生死锁后如何解决
线程和进程的区别
进程：进程是操作系统资源分配的基本单位。每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。
线程：线程是CPU独立调度的基本单位。同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。
线程和进程的生命周期：新建、就绪、运行、阻塞、死亡
进程间的通信
作业调度算法
五、网络
osi，为什么是7层？
| 应用层 |
HTTP、TFTP、FTP、NFS、WAIS、SMTP |
| 表示层 |
Telnet、Rlogin、SNMP、Gopher |
| 会话层 |
SMTP、DNS |
| 传输层 |
TCP、UDP |
| 网络层 |
IP、ICMP、ARP、RARP、AKP、UUCP |
| 数据链路层 |
FDDI、Ethernet、Arpanet、PDN、SLIP、PPP |
| 物理层 |
IEEE 802.1A、IEEE 802.2到IEEE 802.11 |
tcp三次握手
所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。整个流程如下图所示：
- 第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
- 第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
- 第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。
tcp四次挥手
TCP三次握手和四次挥手
为什么三次握手和四次挥手
Server在LISTEN状态下，收到建立连接请求的SYN报文后，可以直接把ACK和SYN放在一个报文里发送给Client。而关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送。
http发送的包里面有什么
TCP/IP五层结构，每次层分别有哪些协议
计算机网络体系结构
TCP和UDP的区别
TCP和UDP的区别
如果网络情况不好，三次握手怎么保证认证
tcp拥塞控制机制，慢开始，拥塞避免，快重传，快恢复
浏览器输入网址按下回车后执行的全过程
域名解析 --> 发起TCP的3次握手 --> 建立TCP连接后发起http请求 --> 服务器响应http请求，浏览器得到html代码 --> 浏览器解析html代码，并请求html代码中的资源（如js、css、图片等） --> 浏览器对页面进行渲染呈现给用户
HTTP与HTTPS区别
session和cookie
六、数据库
对于redis的认识
mysql索引了解
数据库三大范式
解释脏读，幻读，可重复读
redis是单线程还是多线程，分布式锁
单线程
数据库隔离级别，每层级别分别用什么方法实现
- 未提交读（READ UNCOMMITTED）：事务中的修改，即使没有提交，对其它事务也是可见的。最低级别，任何情况都无法保证。
- 提交读（READ COMMITTED）：一个事务只能读取已经提交的事务所做的修改。换句话说，一个事务所做的修改在提交之前对其它事务是不可见的。可避免脏读的发生。
- 可重复读（REPEATABLE READ）：保证在同一个事务中多次读取同样数据的结果是一样的。可避免脏读、不可重复读的发生。
- 可串行化（SERIALIXABLE）：强制事务串行执行。可避免脏读、不可重复读、幻读的发生。
在MySQL数据库中，支持上面四种隔离级别，默认的为REPEATABLE READ(可重复读)。
三级封锁协议,共享锁排它锁，mvcc多版本并发控制协议，间隙锁
b+树和b数的区别，b+数的具体结构
innnodb和myisam的区别，各自的b数索引叶子节点分别存储什么
全文索引，索引什么时候会失效
索引的优化，最左前缀原则
事务的特性
七、设计模式
会那些设计模式
单例模式，工厂模式，代理模式，装饰器模式
八、框架
springboot介绍一下
SpringBoot就是对各种框架的整合，让框架集成在一起更加简单，简化了开发过程、配置过程、部署过程、监控过程。
@SpringBootApplication
aop和ioc理解和原理
IOC:控制反转也叫依赖注入，IOC利用java反射机制。所谓控制反转是指，本来被调用者的实例是有调用者来创建的，这样的缺点是耦合性太强，IOC则是统一交给spring来管理创建，将对象交给容器管理，你只需要在spring配置文件总配置相应的bean，以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类。
AOP是对OOP的补充和完善。AOP利用的是代理，分为CGLIB动态代理和JDK动态代理。OOP引入封装、继承和多态性等概念来建立一种对象层次结构。OOP编程中，会有大量的重复代码。而AOP则是将这些与业务无关的重复代码抽取出来，然后再嵌入到业务代码当中。实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码，属于静态代理。
反射，cglib代理，动态代理，如何实现
springboot的启动流程
spring中bean的生命周期
springmvc执行流程
- 客户端发送HTTP请求到服务器
- SpringMVC的核心DispatcherServlet将请求交给HandlerMapping处理
- HandlerMapping通过查询机制找到处理当前请求的Handler
- DispatcherServlet将请求交给这个Handler处理
- Handler处理完成后返回一个ModleAndView对象，这个对象包含视图逻辑名和数据对象
- 返回的视图逻辑名会通过视图解析器解析成真正的视图，并交给DispatcherServlet处理
- DispatcherServlet将请求分派给真正的视图对象，并反映到客户端
九、智力题
甲有n个白球，m个黑球，乙有无数个黑球。从甲抽两个球，都是白的，放回甲，一白一黑，从乙拿出黑给甲，都是黑，放回一个给甲。问甲中最后剩下一白一黑的概率
经验首页