要领： 
* 一面、二面主要靠背，但是面试官，希望听到的是，结合你自己总结的语言描述，结合场景是最好的，而不是机械式地背。
* 面试中，总会遇到盲区，这都是正常的，主要盲区是否合理，能不能在盲区面前自圆其说。遇到盲区心态放平最重要。

1. String和StringBuffer，StringBuilder的区别？
     区别（靠背）。
     还要说，什么时候用谁？ 

     面试官追问：  什么是线程安全？ 
     线程安全就是保证，在多线程运行时，不会造成数据的不一致。 点出，线程安全未必非要加锁。 使用ThreadLocal也可以，使用栈封闭。

     你刚才说到ThreadLocal， 能详细说一下。 
     每一个Thread都有一个Map（Thread的内部类），Map的键值是ThreadLocal对象本身，值就是set方法的参数。
     什么时候需要使用ThreadLocal，JdbcUtils中可以使用。 

     
     
2. linux中如何查找文件，如何查询内存信息？（free）
       
   发散：说说你用过的linux命令。

   yum 
   tar 
   make
   vi 
   firewall-cmd
   ps -ef | grep ... 


3. Spring事务的级别都有哪些？ | 你对事务的理解 | Spring中如何控制事务隔离级别？ | ....

    什么是事务： 
    ACID
    多个事务并发下的问题，脏读， 不可重复读，幻读。 
    隔离性，四大隔离级别
    read uncommitted
    read committed
    repeatable read
    serialize

    MVCC（自己复习....）
    
    锁

    RR级别之下，如果一个查询没有命中索引，则会锁住整个表。


    Spring事务传播行为？
    事务嵌套
    1. REQUIRES_NEW  
    2. REQUIRED

    
4. 悲观锁 和 乐观锁 的区别 

     区别
     ABA
     什么时候用。
     
      分别在什么情况下使用 开发项目时，前期统一用悲观锁，后期调优时再使用乐观锁测试




5. 如何优化sql性能？ 
        一般做项目，不会过早优化sql，过早优化sql也是一个大忌，因为过早优化的方向可能是错误的。 性能如果能够接受，就暂时不做优化。 
        a. 从sql语句下手 in和exists如何选择 --> 要确保先被查询的是小表 数据量大的情况下，
            尽量不要使用like，而是使用全文检索框架。 聊一聊倒排索引。
          


        b. 合理增加冗余字段，减少连表操作出现的几率  举例：订单 和 订单项

                
        c. 从索引下手 
                索引就是提高查询速度的。
                聚集索引  非聚集索引 
                局部性原理 B+Tree  
                最左原则
                explaion all index range ref eq_ref const
                回表
                like ‘abc%’
                什么列适合使用索引， 什么列不适合。
                高性能MySQL。


        d. 生产环境调优，读写分离，缓存。

        e. 硬件优化



6. 索引这么好，那我就加得越多越好，是这样吗？



7. mysql中如何存储图片？视频？
    mysql中可以存储2进制文件，但是一般不这样做，是把文件的路径写入数据库。
    

8. 技术以外
        项目组几人：3-10人都是正常的，大多数都是开发，前端1-2个，测试人员不一定在项目组中。
 
        项目周期多久：很难下定论。有时你开发完部分功能，就被调到其他项目组了。 
        
        项目中有多少张表？ 一般100-200张表都是正常的，但是某一个人负责的应该只有10来张表。

9. spring ioc和aop的原理？
        ioc一般解释。
        作用： 主要起到了解耦的作用， ioc往往搭配DI               
        ioc是容器读取配置，来实例化bean， DI，是根据自动装配的方法，来进行注入。

        @Autowired
        IUserService  a
            
        UserSerceImpl2  完全解耦

        发散： 配置方式的不同。xml  javaconfig， ioc页感知不到，因为ioc容器只认识BeanDefination
        ioc原理，就是依靠反射机制 + 配置 + 工厂.


        aop: 面向切面编程。 能把多个业务中的公共逻辑抽离出来。 编写起来方便。

        aop，主要就是能够优雅地织入逻辑。编写 源代码的时候，是把核心业务逻辑和横切关注点分开编写，运行时再织入到一起。

        aop中的核心概念：核心关注点就是核心业务，横切关注点就是非核心业务， 切点就是根据切点epxression定位到的业务方法 
        切面就是横切关注点的集合，指明什么时候，在什么地方，干什么事情。

        @Component
        @Aspect
        class A {
                @Before("execution(com.woniu.service.impl.UserServiceImp.*(..))")
                public void f1() {
                    sout(...)
                }
              
        }

        原理懂就是一点。 动态代理+反射机制。
        jdk动态代理有一个显示，就是目标类必须实现接口。否则无法使用jdk的动态代理。

        如果目标类确实没有实现接口呢？ 就使用cglib。 原理是： 让代理类直接继承目标类 
        
        
                

10. 如何把一个java对象转换为json字符串？ 

        fastjson

        jackson-databind

        jsonlib 

        并谈谈对json的认识。 
        json的格式：
        
        1. { }
        2. 属性: 属性值
        3. "属性"  "属性值"，引号必须是双引号（*）
        4. 如果属性值是数字，则可以省略引号            

        json是一种数据格式，与xml相仿，都有两个作用
        1. 作为软件的配置信息
        2. 服务器间通信的信息流

        restful + json  

        前后端分离。 
        单页面应用是什么？
        就只有一个html页面，其他子页面都是以vue组件形式实现的，多个子组件之间靠子路由切换。

        单页面应用有什么缺点： 对搜索引擎不友好。

        



10.5 简述对线程安全的理解 

        当多个线程同时操作同一个资源时，资源的状态很可能出现不一致的情况。这就是线程不安全的表现。 
        可以使用synchronized或lock来加锁，保证线程安全。

        场景说一下
        if(num > 0) {
             num--
        }

        synchronized有什么缺点？ 悲观锁，并发性低。 
        java中的线程，是与操作系统对应的，在java中，要让一个线程进入阻塞状态，就得切换到内核态来完成，引起线程用户态到内核态的转换
        这个转换是有很大的性能代价的。

        synchronized在jdk11.6版本中进行了优化。
        1.6以前，synchronized就是重量级锁（用户态到内核态的转换）
        1.6以后，synchronized，锁的状态不仅仅只是重量级锁了，而是有4种状态：无锁状态，偏向锁，轻量级锁，重量级锁。

        synchronized和Lock的区别 
        

        CountdownLatch CyclicBairrer  Exchange Sephomre  Locak

        AQS框架
        HashMap 1.7 （Entry + 链表）和 1.8 (红黑树 Node + 连接)，  ConcurrentHashMap  1.7 （分段所）和 1.8（CAS+sync）

        

11. 你对BIO、NIO、AIO的理解？ 
        
       1. 阻塞  非阻塞  同步 异步。
       
       2. unix 5种IO模型

       
        BIO，同步阻塞式IO，每个线程只完成一个任务，多个任务就对应多个线程。  

        NIO，同步非阻塞式IO。


        AIO（NIO2），异步非阻塞式IO，与NIO一样，也支持多路复用机制。不同的是，


        NIO会主动轮询结果是否准备好，AIO是通过事件回调机制来获取结果


12. 谈谈使用过的缓存技术？ 
        a. orm框架的一级缓存和二级缓存。
        1级缓存都是session级别的缓存。 session一旦关闭，一级缓存中的内容就没有了。
        mybatis中，一旦执行了update、delete、就会把一级缓存清空。 clearCache。 一级默认是开的，也不能关闭。

        1级缓存，都是sessionfactory级别，跨session。 二级缓存默认是关系的，需要手动开启，手动开启以后，还需要指定哪些资源需要
        用到二级缓。

        

        二级缓存什么时候用？ 
        二级缓存缺点是： 修改数据的时候，还要额外修改二级缓存。针对于读多写少的情况，时候使用二级缓存。
        读少写多的情况就不要使用二级缓存了。           
        

        b. 二级缓存不同于一级缓存，二级缓存不会普遍应用，只针对局部手动开启，
           不适合所有业务，二级缓存适用于读多写少的情况。 


        c. 现在一般用redis替代二级缓存。redis的缓存命中等查询逻辑用spring-cache控制，
           但是要考虑到缓存雪崩、缓存穿透、缓存击穿的问题。

        



13. 如何对线程同步进行优化？ 

        大方向是减少排队

        单例模式的双重检查就是一种优化


        synchronized(str.intern())


        有的业务，可以考虑使用数据库层面的乐观锁

        synchronized可以用redis lock来代替


        jdk1.6自身对synchronized进行了优化

        

14. javascript中，prototype是什么？

         function Person(id, name) {
            this.id = id;
            this.name = name;

            this.eat = function() {
                console.log(this.name + "吃饭！！");
            }

        }


        function Student(address)  {
            this.address = address;
        }

        var p = new Person(11,"eason");

        Student.prototype = p;

        var s = new Student("北大街");
      
        
        console.log(s.id + " " + s.name + " " + s.address);


15. javascript中，闭包是什么？
        
        1. 在js中，function能不能嵌套定义？ 能！ 
        2. 闭包就是一个函数，该函数可以是定义在另外一个函数之内的函数，该函数可以访问外部函数的局部变量。 可以模拟java中的封装。


16. jsp中，如何访问一个request的attribute？
        
            1. request.getAttribute()
            2. ${requestScope.key }
            3. pageContext.getAttribute("key", Scope.REQUEST_SCOPE);
            4. pageContext.findAttribute("key");
  
17. Servlet中，doGet和doPost的区别是什么？
    当请求方式是get的时候，就会调用doGet
    当请求方式是post的时候，就会调用doPost

    get和post区别。

    restful  get查询  post增加  put修改 delete删除
    
    上传文件。
    
      
       

18. Servet中，forward和redirect的区别？
        
        会用。
        
        总结：



     

19. 请写出java中常见的排序算法（如冒泡排序等，请写出代码）



20. &和&&的区别？如何用最有效的方法计算2*16？     



21. 修改下面的代码，当j=5的时候，直接跳出(外层)循环，打印hello


        bb: for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {
                    if (j == 5) {
                        break bb;
                    }
                    System.out.println(j);
                }
            }

        System.out.println("hello");





22. 解释final、finally、finalize的区别

        final修改引用，引用本身不能变，但是所指向的对象的状态是可以变化的。


        final域只能被显示地赋值一次，但是这并不代表final域不能被多次初始化。     


        final保证了变量的可见性： 

        为了保证final域的值不会在未初始化的情况下被访问到，程序员只需要保证一点即可：
        即，在构造函数中，正在被构造的对象（this）没有“逸出”，那么不需要任何同步手段，
        就能保证任意线程看到的final域，包括基本类型和引用类型，都是已经被正确地通过构造函数初始化过了的。

        一个会使正在被构造的对象逸出的例子：
        public class FinalTest{
                final int i;
                static FinalTest obj;

                public FinalTest(){
                        i  =1;
                        /**
                                这里会使正在被构造的对象逸出，如果和上一句做了重排序，
                                那么其他线程就可以通过obj访问到还为被初始化的final域。
                                实际上，final修饰的变量不会让这样的情况发生的。
                        **/
                        obj = this; 
                     
                }
            }


        finalize() 。GC回收算法。 

23. 简单介绍Object的hashcode（粗判）方法和equals（细判）方法，并指出二者的关系.
        HashSet HashMap
        
        追问：HashMap是线程安全的吗？  不是。
        如果要保证HasmMap是线程安全的，要怎么办？    Hashtabl虽然线程安全的，但是效率太低。synchronized
        
        1.7 ConcurrentHashMap 分段锁，只锁当下操作的桶位。桶位默认有16个。 
        1.8 ConcurrentHashMap CAS+synchronized  ABA   cas cup汇编指令 lock cmpxchg 

        


24. 对一个List排序，Java里怎么做最简单？
        使用Collections.sort方法就可以了。

        如何List中元素是java内置类，可以直接加入。
        如果List中的元素是自定义的类，该类必须实现Comparable接口，或者加入比较器。

        int comparTo  
        返回值 > 0 表示新元素大于旧元素
        返回值 < 0 表示新元素小于旧元素
        返回值 = 0 表示新元素等于旧元素

        

25. 实现多线程有几种方法？
        说完4种方法。

        追问：你怎么理解线程池？
        1. 线程池的好处，所有的池化技术，都是提前创建资源，用完资源不释放，而是归还到池中。
        2. 原理： 线程池中的线程其实就是Worker类的对象， 底层是两个集合，Set<worker>  List<任务>
           10(core)  100（max） 
           队列：10000  10000 

        3. 你用过哪些线程池？
                FixPool
                CachePool
        

26. 简述JDBC调用数据库的基本步骤。
        
    发散：
    a. Statement和PreparedStatement的区别
    b. sql注入漏洞是什么，以及如何防止


27. 简述Servlet的生命周期

    生命周期，就是一个实体，在生命时候做生命事情。


    发散：
    Filter生命周期
    Thread生命周期
    Spring中Bean的生命周期  a. faxian bean
    只要是一个类，无论它是Servlet还是Filter，还是其他，它要运行，就必须要将class加载到内存！
    第一步：就是加载class到jvm
    第二步：就是实例化创建对象。
    第三步：就是对象中的方法就可以使用了，这个我们称之为运行/提供服务
    第四步：就是销毁。

    在这个共性基础上，你记得几个个性化的步骤，就加进去。如果不记得，就算了，这4步按照10分计算，7-8分已经入手了。

28. 你对线程池的理解？
        原理
        参数
        ...

29. 线程之间如何通信？
        1. 共享对象的wait和notify
        2. Lock，getConditoion.await()  singlenal
        3. volatile
        4. CountdownLatch 和 CyclicBairrer  

        追问： CountdownLatch 和 CyclicBairrer  区别？
        CountdownLatch一次性  CyclicBairrer 循环使用



30. spring ioc和aop？


        UserSerivce

        @Autowrite  
        UserDao

        dao1  dao2
        

        ioc xml  javaconfig   beandefinatoin 

        aop 

        spring aop中的切点都是方法，对比Aspectj  切面 要植入的逻辑，在什么时间，在什么地方 做什么事情 

        原理 动态代理+反射机制  jdk动态代理 cglib


        
        ioc发散：
        Spring的多种配置方式，其实都是得到BeanDefination对象
        引出依赖倒置


        xml的解析方式：dom解析 sax解析， 各自的优缺点， 适用场景。


        
        
31. ApplicationContext和BeanFactory的区别？
        
         ApplicationContext是BeanFactory的子接口
         
        BeanFactory是延迟实例化bean， ApplicationContext是立即实现
         BeanFactory手动设置支持BeanPostProcessor ApplicationContext原本就支持BeanPostProcessor
         ApplicationContext有更多的功能，国际化..


32. Spring中，Autowiring by name 和 Autowiring by type的区别？
  
    @Autowired
    IUserService service;

 
    @Component
    userServiceImpl1


    @Component
    userServiceImpl2

    
    @Resources

  
    发散：
    什么时候，需要按照名称注入？ 答：按类型匹配时，有多个符合类型的bean的时候。

    追问，自动装配有什么好处，为什么要自动装配？
    解耦 , 依赖导致。   

    springmbvc


 

33. 如何创建一个线程？start和run有什么区别？设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1，写出程序。
    
        总结：如果只有一个任务，则该任务就可以充当共享对象， 如果有多个任务，则要把共享对象单独定义。

34. 简述Collection和Collections的区别

            Collection
              |——List
                  |-- ArrayList
                  |-- LinkedList
                        |-- Vector
              |--Set  
                  |-- HashSet
                  |-- TreeSet

     

                      1.8 ConcurretHashMap  cas




            Colleciotns是集合框架中的一个工具类。其中的方法都是静态方法。其中sort是用来排序List的。reverse.
            shuffle swap fill  frequency

        
        


35. 应用开发过程中，需要将学生的姓名，年龄，班级，学科，分数，这些信息通过系统来进行管理。

        1. 提供该系统的 UML图（不会UML的可以提供该系统中设计对象的定义）

            抽取实体， 和实体的属性， 以及实体和实体的关系。

        2. 系统涉及对象的数据库建表语句

        3. 用sql查询出某一班级学科总分最高分的学生姓名

        4. 用sql查询出全部学生中各科成绩最高分的学生姓名

36. FIFO队列的定义如下：类似日常生活中的排队现象，数据元素只能从队尾进入，从队首取出。在队列中，数据元素可以任意增减，但数据元素
的次序不会改变。每当有数据元素从队列中取出，后面的数据元素依次向前移动一位。所以，任何时候从队列中读出的都是队首的数据。
请使用任意数据结构实现一个简单的FIFO队列，可以借助List实现。

37. Java中，8种基本类型？
        byte short int long 
        float double 
        boolean
        char

        追问：int和float谁的范围大？ float范围大！
        追问：int和floa都占4个字节，为什么float范围大？ float牺牲了精度，换来了范围。

        追问： 什么是自动类型转换？
            表达式中，有double，结果就为double， 有flaot，结果就为float， 有long，结果就为long，其余全为int

        追问：强制类型转换？



38. 请描述Java EE（J2EE）多层架构中，都有哪些层？

        web层  业务层 持久层

        view
        controller
        servlet
        filter
        lisenter
        model
        
        com.woniuxy.web.contorller
        com.woniuxy.web.filter
        com.woniuxy.web.listener

        com.woniuxy.service
        com.woniuxy.dao

        注意，三层架构与MVC的异同。MVC是表示层的东西。
        引申：说说MVC的流程？
            
            

        引申：SpringMVC与Struts2的比较
                1. 都是MVC框架，核心流程差不多

               


               
                2. 必须要提到，传参方式的不同
                        struts2的传参方式，使Action必须被设计为多实例的；而SpringMVC的传参方式则不同
                        struts2没有线程安全问题，是如何实现的？ 就是靠多例，所以struts2传参的方式不合理
                        再说说什么是线程安全？锁？volatile？synchronize.....
                        
                异常数据怎么处理？
                项目中如何处理异常？
                

               上线以后，如何维护restful接口

               /book/find/1
                   
            
               
               
                

39. 什么是值传递，什么是引用传递？
    

    a. java中只有值传递，没有引用传递。
    b. 形参的改变，能否影响实参。
            8种基本类型 + String 作为形参，绝对不会影响实参
            符合类型作为方法参数，有可能影响实参。

        发散    final修饰的对象，可以改内容，不能改引用
    
40. mybatis和hiberante，比较一下？
    1. 要点：mybatis可以灵活地直接编写sql语句，更容易手工优化sql；hibernate不能  
    2. Mybatis可以灵活地加插件
    3. Mybatis的缺点，移植性不好。 
    4. 其他的随便说一下就行....

41. sql表如何设计？

        一对一  user username passworod  salt    
        一对多  
        多对多 
        3NF也可以说，反范式也行
        1NF. 列不可在分，结合业务。 
        2NF. 表中的所有列，都必须完全依赖与主键，不能只依赖于主键的一部分。(针对于复合主键，多对多)
        3NF. 表中的所有列，只能依赖于主键，不能有局部依赖。



42. Tomcat，Apache，JBoss的区别？

        1. tomcat = web服务器 + servlet容器
        2. apache = web服务器， 也可以搭配tomcat 
        3. jboss = java ee容器， servlet容器 ejb , jmail ...  有免费版 和 收费版

43. TCP与UDP的区别？(出镜率比较高)
        TCP 面向连接的协议， 可靠， 占资源多
        UDP 不面向连接的协议，不可靠，占资源少

        TCP三次握手，为什么是3次，确认对方有接和发的能力，而不是2次，或4次。
                


44. 对Spring的理解， 项目中都用什么？ 怎么用的？ 对IOC和AOP的理解以及实现原理。
        Spring就是一个帮助我们做IOC和DI的框架，IOC就是借助容器读取配置来创建对象，DI就是把创建好的对象按需要拼装起来。
        可以写个IOC的伪代码例子。
        实现原理知道就说一说
        

        Aop是面向切面编程，目的是不用该目标代码，就能植入逻辑。

        切点：通过切点表达式选择出来的业务方法，切面：要植入到切点的逻辑。
        可以写个AOP的伪代码例子。
        实现原理知道就说一说。 

        
    

45. Spring MVC概述
        


46. Spring与Tomcat集成？
        a. springboot本身就集成了tomcat。针对于微服务。

            
        发散： spring如何集成servlet
        
        
        b. 代理过滤器 代理servlet
        
47. 下面程序的运行结果是？
public class X {
    private static int a;

    public static void main(String[] args) {
        modify(a);
        System.out.println(a);
    }

    private static void modify(int a) {
        a++;
    }
}

48. 如何实例化一个内部类的对象，请写出例子

class A {
    class B {
        
        
    }
}

public class App {
    public static void main(String[] args) {
        A a = new A();
        A.B b = a.new B();
    }
}

追问：为什么要使用内部类？ 内部类可以直接访问外部类的所有成员。


49. 抽象类和接口的区别？
        a. 先说作用
        抽象类的主要作用，就是为了提高代码的重用性。 比如模板方法设计模式。
        抽象类受到单继承的限制。 
        
        接口的作用：
        1. 完全解耦。  
        2. 提高程序扩展性
        3. 统一访问

        b. 再说语法


50. static关键字的作用？
        static 
                变量
                方法
                块
                内部类

        static 在工具类。


51. 泛型的作用以及擦除？
        
        引申：java中，为啥非要有个泛型擦除呢？

        java中的泛型是伪泛型，泛型在源代码级别存在，一旦编译完成，得到字节码，字节码中只保留的对泛型微弱的记忆。


52. 当父类是泛型类时，子类是否也必须是泛型类？
    不是的。
    比如BaseDao

53. 如下：
public class Foo {
    public void f1() {
        System.out.println("Foo.f1");
    }
    public void f2() {
        System.out.println("Foo.f1");
    }
}

class Bar extends Foo {
    @Override
    public void f1() {
        System.out.println("Bar.f1");
    }

    public void f3() {
        System.out.println("Foo.f3");
    }
}

问，用Foo foo = new Bar();构造实例后，分别调用foo.f1();foo.f2();foo.f3(); 会输出什么？

54. linux常用命令有哪些？
        yum 
        tar 
        make
        vi
        firewall-cmd
        systemctl start 
        grep ps -ef  kill
        cp mv

55. Redis中有哪些数据结构？
        1. String 使用场景
        2. hash 使用场景 
        3. list 使用场景  
        4. set 使用场景  
        5. zset 使用场景

56. Nginx的负载均衡策略有哪些？
        1. 先说Nginx中的轮询策略
        2. 再补充说项目中用的是spring could feign + ribbon的轮询策略  
            

57. Zookeeper全部挂掉时，dubbo服务是否可以正常被调用？ 为什么？
   

58. 什么是CAP理论？

59. 谈谈你对事务的理解？
        

60. 深克隆和浅克隆的区别？
        


61. 面向对象的三大特征
        封装： 对外隐藏复杂的实现细节，暴露出加单的使用方法。  
        继承：  
        多态： 
    
        

62. SpringMVC的工作流程？
        

63. 遍历一个List的方法？

Map values()  keySet() entrySet





64. HashMap的key能不能重复？ 可不可以为null？
        


65. 多线程下，如何保证HashMap是线程安全的？



66. 按需删除ArrayList中匹配的数据，有什么问题？ 如何解决
        这个题问题的是 快速报错

67. 调用第三方接口怎么用java发http请求？
        restTempalte.getForObject(url)
        httpclient
        feign + 注册中心

68. HashMap的容量，为什么必须是2的次方数？

69. 如果在创建HashMap时，传入的初始容量是9会怎么样？

/**
* Returns a power of two size for the given target capacity.
*/
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}


n = 9
00000000 00000000 00000000 00001001
00000000 00000000 00000000 00000100      (n >>> 1)
____________________________________
00000000 00000000 00000000 00001101     经过这步计算，2进制位中绝对不会出现“010”的片段

n = 13
00000000 00000000 00000000 00001101
00000000 00000000 00000000 00000011    (n >>> 2)
____________________________________
00000000 00000000 00000000 00001111     经过这步计算，2进制位中绝对不会出现“0110”的片段

n = 15
00000000 00000000 00000000 00001111
00000000 00000000 00000000 00000000     (n >>> 4)
____________________________________
00000000 00000000 00000000 00001111     经过这步计算，2进制位中绝对不会出现“011110”的片段

以此类推