目录
- 一、Java
- Collections
- hashset源码
- hashmap源码
- hashset和hashmap的区别
- hashmap、hashtable原理，1.7,1.8的区别
- haspmap的底层实现put操作，扩容机制
- currenthashmap如何解决线程安全,1.7版本以及1.8版本的不同
- arraylist默认大小，如何扩展的
- 什么情况下会有线程安全的问题，怎么解决
- synchronized和reetrantlock锁
- cas
- volatitle
- 线程池
- 创建线程的方法
- java的线程和操作系统的线程什么关系
- 优先级队列，如何处理
- hash冲突的解决方式，如何判断各个方式的优劣
- 乐观锁 和悲观锁
- 如何实现让一个线程等待其他线程完成后在执行
- AQS同步器框架，countdowmlatch，cyclebarrier，semaphore，读写锁
- 线程池的参数，各种线程池
- string ，stringbuild，stringbuffer区别，string内部结构
- 拆箱装箱的原理
- Lambda表达式
- 如何实现list和map
- 锁以及锁的底层实现
- 队列和栈由什么实现的
- 重写和重载
- 二、JVM
- 三、数据结构与算法
- 四、操作系统
- 五、网络
- 六、数据库
- 七、设计模式
- 八、框架
- 九、智力题
一、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源码
hashset和hashmap的区别
hashmap、hashtable原理，1.7,1.8的区别
haspmap的底层实现put操作，扩容机制
currenthashmap如何解决线程安全,1.7版本以及1.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);
}
}
}
非递归方式实现二叉树的中序遍历
二叉树后序遍历
如何判断链表有环
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层？
| OSI七层网络模型 | 对应网络协议 |
|---|---|
| 应用层 | 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四次挥手
为什么三次握手和四次挥手
Server在LISTEN状态下，收到建立连接请求的SYN报文后，可以直接把ACK和SYN放在一个报文里发送给Client。而关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送。
http发送的包里面有什么
TCP/IP五层结构，每次层分别有哪些协议
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将请求分派给真正的视图对象，并反映到客户端