2021-2022秋招备战java个人珍藏版复习资料（最全）

Posted 2021-06-03 沉默着忍受

2021-2022秋招备战java个人珍藏版复习资料（最全）

提前批你不得不掌握的点（一）

---

文章目录

• 2021-2022秋招备战java个人珍藏版复习资料（最全）
• 前言
• 一、数据结构与算法是基础
• • 1.1 数据结构部分
  • 1.2 经典算法部分
• 二、手写代码是能力
• • 2.1.排序算法手写
  • 2.2.死锁
  • 2.3.更多手写代码常见题目
• 三 .java基础，数据库知识是主体
• • 3.1.常见题目
• 四.数据库sql基础命令是基操
• • 4.1. 创建数据库
  • 4.2.删除数据库
  • 4.3.创建新表
  • 4.4.删除新表
  • 5.5.数据库的基本操作必须掌握
  • 5.6.JDBC编程原理与实现
• 五.操作系统是灵魂
• • 这可能是最全面的操作系统知识细了，一定要收藏！
• 六.网络知识是升华
• • 6.1.TCP/IP知识
  • 6.2.1 TCP特性
  • 6.3.1 面向字节流
  • 6.3.2 沾包问题
  • 6.3.3 TCP异常情况
  • 6.4.1为什么TCP这么复杂?
  • 6.4.2 TCP/UDP对比
• 八.总结

---

前言

22届的小伙伴们估计正在疯狂准备暑期实习网申、笔试、面试吧？告诉你们一个最新消息，2022秋招提前批已经开启了！下面，快来和万能班长一起看看吧~为了提前抢到22届人才，各家大厂的招聘节奏越来越快！华为、华泰证券、三一集团、国泰君安、招行、毕马威、嘉实基金、小鹏汽车等早就把目光瞄准22届同学，开启了抢人模式！

提前批的重要性我就不说了，但是要强调一点的是，这相当于你多了一次机会，如果放弃这次机会，那么就只能等秋招了。
话不多说，我们来讲讲怎么去复习

一、数据结构与算法是基础

1.1 数据结构部分

推荐阅读：数据结构最全讲解
数据结构概念：数据结构分类细讲
数据结构java源码：经典数据结构及算法-Java实现-附源代码（可下载）

1.2 经典算法部分

推荐：
十大经典算法：https://www.cnblogs.com/ice-line/p/11753852.html

二、手写代码是能力

2.1.排序算法手写

1. 选择排序（Selection Sort）

代码实现：

import java.util.Arrays;

public class Demo {
    //选择排序
    /**
     *1.从待排序序列中，找到关键字最小的元素；
     * 2.如果最小元素不是待排序序列的第一个元素，将其和第二个元素交换；
     * 3.从余下的N-1个元素中，找出关建字最小的元素，重复1.2步骤，直到排序排序结束
     * 当增量因子微一时，整个序列长度为原来序列的长度；
     */

    public static void main(String[] args) {
        int[] arr  = {25,89,56,88,21,3,56,66,8,663,55};
        Selectionchose(arr);
        System.out.println("========================");
        int[] res = Selectchose1(arr);
        System.out.println(Arrays.toString(res));

    }
//展示选择的过程
    public  static  void Selectionchose(int[] arr){
        if(arr==null||arr.length==0) return;
        //开始遍历，寻找最小的元素，打印出来
        for(int i=0;i<arr.length-1;i++){
            int min = i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[min]){
                    min =j;
                }
            }
            if(min!=i){
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
                System.out.println(Arrays.toString(arr));
            }
        }
    }
//直接返回最终结果
    public static  int[] Selectchose1(int[] arr){
        if(arr==null||arr.length==0){
            System.out.println("序列不合法！");
            return null;
        }
        for(int i =0;i<arr.length-1;i++){
            int min = i;
            for(int j =i+1;j<arr.length;j++){
                if(arr[min]>arr[j]){
                    min =j;
                }
            }
            if(min!=i){
                int res = arr[i];
                arr[i] = arr[min];
                arr[min] = res;
            }
        }
       return arr;
    }
}

2、插入排序（Insertion Sort）

代码实现：

import java.util.Arrays;

public class Deom {
    /**
     * 插入排序
     */

    public static void main(String[] args) {
        int[] arr = {25,89,56,88,21,3,56,66,8,663,55};
        //insertionSort(arr);
        insertionSort1(arr);
    }
    //序列较少的情况下：
    public  static  void insertionSort(int[] arr){
       if(arr==null||arr.length==0) return;
       for(int i =1;i<arr.length;i++){
           int temp = arr[i]; //取出第二个元素；
           for(int j =i;j>=0;j--){
              if(j>0&&arr[j-1]>temp){//j-1为当前元素的前一个元素的下标，如果前一个数大于当前的元素，那么两个数据进行交换
                  arr[j] = arr[j-1];
                  System.out.println("inserting"+Arrays.toString(arr));
              }else{
                  arr[j]=temp;//如果大于或等于，那么保存当前数，并且进入下一次插入；
                  System.out.println("Sorting"+Arrays.toString(arr));
                  break;
              }

           }
       }
    }
//数据量比较多的时候
    public  static  void insertionSort1(int[] arr){
        if(arr.length==0||arr==null) return;
        for(int i =0;i<arr.length-1;i++){
            for(int j = i+1;j>0;j--){
                if(arr[j-1]<arr[j]){
                    break;  //如果前一个元素小于当前元素，不做处理
                }
                int temp = arr[j];  //如果前一个元素大于或等于当前元素时，交换数值，然后进入循环。
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

3、冒泡排序（Bubble Sort）

代码实现：

import java.util.Arrays;

public class Deom {
    public static void main(String[] args) {
        int[] arr = {25,89,56,88,21,3,56,66,8,663,55};
         BubbleSort(arr);
    }
    public  static  void BubbleSort(int[] arr){
        if(arr.length==0||arr==null) return;
        for(int i =0;i<arr.length;i++){  //表示第一个元素
            for(int j = i+1;j<arr.length;j++){ //表示第二个元素
                if(arr[i]>=arr[j]){ //如果第一个元素大于等于第二个元素，那么两个元素进行交换，直到不满条件；
                    int temp = arr[i];
                    arr[i] =arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

4、快速排序（Quick Sort）

代码实现：（递归方法）

import java.util.Arrays;

/**
 * 用伪代码描述如下：
 *
 * ①. i = L; j = R; 将基准数挖出形成第一个坑a[i]。
 * ②．j--，由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
 * ③．i++，由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
 * ④．再重复执行②，③二步，直到i==j，将基准数填入a[i]中
 * ————————————————
 *
 */

public class Deom {
    public static void main(String[] args) {
        int[] arr = {25,89,56,88,21,3,56,66,8,663,55};
        QuickSort(arr,0,arr.length-1);//以第一个数为基准
    }
    public static void QuickSort(int[] arr ,int low,int high){
        if(arr==null||arr.length==0) return;
        if(low>=high) return;
        int left = low;
        int right = high;
        int temp = arr[left]; //确定基准值；
        while (left<right){
            while (left<right&&arr[right]>=temp){  //从后往前，找到小于或等于基准的数进行交换
                right--;
            }
            arr[left] = arr[right];

            while (left<right&&arr[left]<=temp){  //从前往后走，找到大于或等于基准的数进行交换
                left++;
            }
            arr[right] = arr[left];
        }
      arr[left]=temp; //将基准值填到坑3中
        //开始递归；
        QuickSort(arr,low,left-1);
        QuickSort(arr,left+1,high);
        System.out.println(Arrays.toString(arr));
    }
   
}

     上面是递归版的快速排序：通过把基准temp插入到合适的位置来实现分治，并递归地对分治后的两个划分继续快排。那么非递归版的快排如何实现呢？
 因为递归的本质是栈，所以我们非递归实现的过程中，可以借助栈来保存中间变量就可以实现非递归了。在这里中间变量也就是通过QuickSort1函数划分
 区间之后分成左右两部分的首尾指针， 只需要保存这两部分的首尾指针即可。

import java.util.Arrays;
import java.util.Stack;

/**
 * 用伪代码描述如下：
 *
 * ①. i = L; j = R; 将基准数挖出形成第一个坑a[i]。
 * ②．j--，由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
 * ③．i++，由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
 * ④．再重复执行②，③二步，直到i==j，将基准数填入a[i]中
 * ————————————————
 *
 */

public class Deom {
    public static void main(String[] args) {
        int[] arr = {25,89,56,88,21,3,56,66,8,663,55};
       // QuickSort(arr,0,arr.length-1);//以第一个数为基准、
        quickSortByStack(arr);
    }
    public static void QuickSort(int[] arr ,int low,int high){
        if(arr==null||arr.length==0) return;
        if(low>=high) return;
        int left = low;
        int right = high;
        int temp = arr[left]; //确定基准值；
        while (left<right){
            while (left<right&&arr[right]>=temp){  //从后往前，找到小于或等于基准的数进行交换
                right--;
            }
            arr[left] = arr[right];

            while (left<right&&arr[left]<=temp){  //从前往后走，找到大于或等于基准的数进行交换
                left++;
            }
            arr[right] = arr[left];
        }
      arr[left]=temp; //将基准值填到坑3中
        //开始递归；
        QuickSort(arr,low,left-1);
        QuickSort(arr,left+1,high);
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 快速排序（非递归）
     *
     * ①. 从数列中挑出一个元素，称为"基准"（pivot）。
     * ②. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
     * ③. 把分区之后两个区间的边界（low和high）压入栈保存，并循环①、②步骤
     * @param arr   待排序数组
     */
    public static void quickSortByStack(int[] arr){
        if(arr.length <= 0) return;
        Stack<Integer> stack = new Stack<Integer>();

        //初始状态的左右指针入栈
        stack.push(0);
        stack.push(arr.length - 1);
        while(!stack.isEmpty()){
            int high = stack.pop();     //出栈进行划分
            int low = stack.pop();
            int pivotIdx = QuickSort1(arr, low, high);
            //保存中间变量
            if(pivotIdx > low) {
                stack.push(low);
                stack.push(pivotIdx - 1);
            }
            if(pivotIdx < high && pivotIdx >= 0){
                stack.push(pivotIdx + 1);
                stack.push(high);
            }
        }
    }

    private static int QuickSort1(int[] arr, int low, int high){
        if(arr.length <= 0) return -1;
        if(low >= high) return -1;
        int l = low;
        int r = high;

        int pivot = arr[l];    //挖坑1：保存基准的值
        while(l < r){
            while(l < r && arr[r] >= pivot){  //坑2：从后向前找到比基准小的元素，插入到基准位置坑1中
                r--;
            }
            arr[l] = arr[r];
            while(l < r && arr[l] <= pivot){   //坑3：从前往后找到比基准大的元素，放到刚才挖的坑2中
                l++;
            }
            arr秋招备战计划第一弹今天就开始备战秋招

 秋招备战计划第二弹最后俩月能提升的知识清单
 秋招备战计划第二弹最后俩月能提升的知识清单
 我,22届双非本科，150+场面试 拿到了20+offer
 我,22届双非本科，150+场面试 拿到了20+offer
 我,22届双非本科，150+场面试 拿到了20+offer