实用 - Java后端面试经历（经验分享）适用于2~3年

前言

因为某些个人原因，或者其他不可控因素，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.显示转换和隐式转换

     *

     * 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.Object    getClass(),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