前言 因为某些个人原因，或者其他不可控因素，IT行业跳槽肯定在所难免。
这也意味着，你会离开一个熟悉的环境，想方设法的去融入另一个陌生的环境，接触新的同事。希望你的同事人都超级棒~

这篇博客可能只适用于一些2~3年，每天勤勤恳恳写代码，按时完成日常任务的中级程序猿。
毕竟，技术宅男都是大佬，随便换工作，公司都是抢着要。

准备工作
求职简历：简历里面，我觉得有一点很重要，就是如果你对某个框架底层原理并不熟悉，只是项目中使用到了，那么，建议在简历里面这样写：了解并使用xxx框架/技术。
求职App：目前，App主要推荐：猎聘，Boss直聘。 诈骗公司，培训机构相对而言较少，HR回复也比较快（个人感触），app上面的信息都一一完善，包括个人信息，工作经验，项目经验等，尽可能的多写，不要嫌麻烦~~~ 朋友内推也是一种途径

小小建议
1、所谓不打无准备的仗，复习几天，再开始投简历！！不然，你一点没准备，突然通知你面试，又是你很想去的公司，那可能就错过了~
2、准备得差不多了，就可以试着投简历。投简历时仔细看公司招聘要求，有选择性，目的性的投（至少他写的技术你要会一大半吧）。
3、多面试，积累经验。一次两次没面上无所谓，总结失败原因（下来看技术面试时没答上来，或者自己一知半解的知识点，要有针对性的去学习，实践），为下一次面试做准备。

如何复习
工作这几年，每次面试之后，把面试中问到的技术包括一些题做了汇总。分享给大家，大体知识点如下：

一、Java基础
1.显示转换和隐式转换
2.== 和 equals()区别
3.集合源码
4.位运算（源码里面经常用到）
5.多线程
6.Java众多设计模式中常用的几种
7.反射机制
8.封装，继承，多态，抽象
9.java的八大基本数据类型你得记得吧？
10.java的自动拆箱和装箱
11.CountDownLatch的作用和源码

@SpringBootTest
class JavaStudyTest {

@Autowired
// @Qualifier("student")
// @Resource
private StudentService studentService;

public static void main(String[] args) {
System.out.println("ss");
Person person = new Student();
person.eat();
Integer i = 12;
Integer ii = Integer.valueOf(129);
Executors.newFixedThreadPool(4);
}

/**
* 1.显示转换和隐式转换
*
【面试|实用 - Java后端面试经历（经验分享）适用于2~3年】* byte -> char -> short -> int -> long ->float -> double -> boolean
* 隐式转换，计算时会编译器自动转换，从小到大
* 可查看target文件夹下面对应的字节码文件，编译之后的代码
*/
@Test
public void test1() {
try {
short s = 1;

//s += 1==s=(short)(s+1)
s += 1.1D;
System.out.println("s........." + s);
System.out.println("这里的s从double强转成short，会确实精度，结果不是2.1，而是2");
// s = s + 1;

String str = "abcd";
boolean equals = str.equals("ddd");

} catch (Exception e) {

}
}

/**
* 2.== 和 equals()区别
*
* java.lang.ObjectgetClass(),equals(),hashcode(),toString(),wait(),notify(),notifyAll,finalize(),
*
* Integer 能用==判断相等吗？-128~ 127 ，为什么？主要要有个缓存概念
*/
@Test
public void test2() {
String str1 = new String("abc"); //这个过程是运行时在堆内存中实时创建一个对象。
String str2 = new String("abc"); //这个过程是运行时在堆内存中实时创建一个对象。
System.out.println(str1.equals(str2)); //比较的是两个对象的值，是true
System.out.println(str1 == str2); //比较的是两个对象地址，是false
}

/**
* 3.集合
*
* Collection->List-> ArrayList（初始化大小10，扩容为为之前的1.5倍）,LinkedList,Vector(线程安全，扩容为之前的2倍)Set -> HashSet,
* Map->HashMap （阈值16，2的倍数，负载因子为0.75，当map的size超过0.75就扩容为之前的2倍）,TreeMap，HashTable(线程安全，key不能为null)->CurrentHashMap (高并发，保证线程安全)
*
* 重点：HashMap，CurrentHashMap(线程安全)的源码，包括默认的一些参数，put()，get()时大致流程，什么时候扩容，扩容过程，尽可能记清楚。
*/
@Test
public void test3() {

List list = new ArrayList();
List list1 = new LinkedList();
list1.add("");

Map map = new HashMap();
map.put("number", "");

Set set = new HashSet();
list.add("e");

if (list != null & "e".equals("d")) {
System.out.println("");
}

int[] intArray = new int[10];
intArray[0] = 1;

String[] strArray = {};
strArray[0] = "ll";

ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
concurrentHashMap.put("test", "xjc");
concurrentHashMap.get("test");
System.out.println(concurrentHashMap.get("test"));

/**
*
* ------
* 一. HashMap put过程
*
*
*
* 二. ConcurrentHashMap: put()过程cas + synchronized
* https://www.jianshu.com/p/5dbaa6707017 （很详细）
*
* 1.计算key的hash值，
*
* 插入过程使用无条件自循环
* table Node[]table;
* 3.如果table为空，还没初始化，先调用initTable（）初始化, cas, sizeCtl = -1:说明有其他线程在初始化
*
* 如果新node的hash=-1, 帮助扩容??扩容很复杂
*
* 4.如果索引所在位置为null，就直接使用cas（unsafe.compareAndSwapObject()）插入数组
*
* 5.否则，hash冲突，A.判断当前为链表，B.当前节点为红黑树，将新的键值插入到红黑树
* 6. 插入完再判断是否需要转换成红黑树
* 7。检查是否需要扩容，如果超过了实际大小*加载因子就需要扩容 addCount
*
*
* HashMap、Hashtable、ConccurentHashMap三者的区别？
* HashMap线程不安全，数组+链表+红黑树
* Hashtable线程安全，锁住整个对象，数组+链表
* ConccurentHashMap线程安全，CAS+同步锁，数组+链表+红黑树
* HashMap的key，value均可为null，其他两个不行
*/

}

/**
* 4.位运算
*
* >>右移/ 2
* <<左移* 2
* >>> 无符号右移
* &与两个操作数中位都为1，结果才为1，否则结果为0，
* |或两个位只要有一个为1，那么结果就是1，否则就为0，
* ^异或两个操作数的位中，相同则结果为0，不同则结果为1。不使用中间变量，交换两个变量的值
*
* https://www.cnblogs.com/shuaiding/p/11124974.html
* https://blog.csdn.net/weixin_37490221/article/details/90905087
*/
@Test
public void test4() {

int a = 1;
int b = 2;

/*
* 1.任何数和自己进行异或操作结果都为0
* 2.异或符合交换律，即a ^ b = b ^ a
* 3.任何数和0进行异或都是任何数本身
* a = a ^ b;
* b = b ^ a = b ^ (a ^ b) = a;
* a = a ^ b = (a ^ b) ^ (b ^ (a ^ b)) = (a ^ b) ^ a = b;
*/
a = a ^ b;
b = b ^ a;
a = a ^ b;

}

/**
* 5.多线程
* https://www.cnblogs.com/wxd0108/p/5479442.html
* https://www.cnblogs.com/zsql/p/11144688.html
*
* 实现方式：Runnable接口(run())，Thread类，Callable接口（call()）
*
* 多线程： 联想到线程安全
*
*
* synchronized原子性、可见性和有序性--> 阻塞锁，也叫悲观锁，锁住资源，其他使用该资源的线程全部进入阻塞队列，直到资源被释放
* volatile可见性和有序性
* lock---> 也叫非阻塞锁， 主要实现方式 cas算法, aqs, 也叫乐观锁---> cas -- 又有公平锁和非公平锁，源码在ReentrantLock相关类里面
*
* 搞清楚悲观锁和乐观锁的定义？对应实现方式？
*
* 多线程--->线程池--->
* 关于线程池的源码和使用，看ThreadPoolExecutor源码，一定要搞清楚这个类里面的几个参数是什么意思，
* 通过Executors创建线程池存在的弊端，如何使用ThreadPoolExecutor创建线程池？（可能会问，答案是通过Executors创建的线程池，对应参数都设置的max）
*/
@Test
public void test5() {
VolatileTest thread1 = new VolatileTest("thread1");
thread1.start();
try {
Thread.sleep(10000);
System.out.println("Now stop thead1.");
thread1.stopIt();
} catch (InterruptedException e) {
e.printStackTrace();
}

/* ExecutorService executorService = Executors.newFixedThreadPool(4);

Future future = executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println("ss");
}
});

Future