2020年我的面试准备（第一弹）

1、数据库的联合索引

 有没有这个概念，在哪儿用
 
     1）用过联合索引
          
我理解的联合索引，比如说我们有一个查询评委份数的表，其中有主题ID，会议ID，模板ID等，我们将这三个ID当成联合索引
 
 查询时，查询条件必须是从左开始     比如有   主题ID      主题ID、会议ID      主题ID、会议ID  和  模板ID，索引会生效
 
 当最左侧字段是常量引用时，索引就十分有效。
 
 索引生效
 （1）select * from myTest  where a=3 and b>7 and c=3;       a b用到了索引，b用的是范围值，算是断点，C会失效
 （2）select * from myTest  where a=3 and c=7;        a用到了索引
 （3）select * from myTest  where  c=4 and b=6 and a=3;      会自动优化，   a b c 均可以用到索引
 （4）select * from myTest  where b=3 and c=4;   --- 联合索引必须按照顺序使用，并且需要全部使用====》   a   b   c均没有用到索引
 （5）select * from myTest  where a>4 and b=7 and c=9;    只有a用到了索引
 （6）select * from myTest  where a=3 order by b     =====》a  b  用到了索引===》a用到了索引，b在结果排序中也用到了索引的效果
 （7）select * from mytable where b=3 order by a;    =====》都没有用到索引
 
索引失效
   is null,is not null    、  不等于（会导致全表扫描） 、   like（失效会变成全表扫描的操作） 等
   
解决  like  '%name%'索引失效的问题 

当这个作为模糊查询的条件字段（例子中的name）以及所想要查询出来的数据字段（例子中的 id & name & age）都在索引列上时，才能真正使用索引

=========》我的理解：
=========》         当查询条件  以及要查询的字段   都在索引上  ，才不会失效
   
Oracle 创建联合索引

ALTER TABLE PERSONTEST  ADD CONSTRAINT PA PRIMARY KEY (INFOMATION_TYPE, INFOMATION_PERNR, OPERATION_FLAG)

2、arrayList如何实现变长
我的理解：
1）arrayList不给写大小时，默认大小为 10
2）当数据add到10的时候，ArrayList就会自动增长为 10+10/2=15（1.5倍）
然后将之前的数据拷贝到新的数组中，并且将要新增的数据追加到数组尾

    ======》和vector的区别    ======>按2倍增长
          Vector是按照100%延长。这里在添一点就是：ArryList是线程不安全的，Vector是安全的

3、HashMap的实现

  ===========>背景：    数组：查询快、增减慢       链表：查询慢、增减快
              hash表====》数组+链表=====》查询和增减都快
              数据位置按hash去查     ======》hash(key)%数组length====>位置
  ============》解决hash冲突问题： 连地址法======》有冲突，就将数据存入这个数组位置的链表后面
                   取值的时候，
                          1）通过hash(key)%length找到在数组上的位置，然后用equals方法找到链表中所需要的元素
                          
 =============》负载因子：0.75====》当使用率达到0.75时，hashMap会自动扩容为之前的2倍
               0.75是时间换空间的考虑，0.75的碰撞频率还可以接受，0.95的碰撞过于频繁，会导致星能下降
               
===============》工作原理： hash算法找到数组位置、存入其链表上，当位置相同，则拉链

CocurrentHashMap是hashMap的升级版，在hashMap钱加上了Segment段，=》用了分段锁机制，多线程下=》可保证线程安全
》我的理解：CocurrentHashMap将数组切成多个hashMap=》每个map用lock上锁
put的时候=》hash(key.hashCode())找到对应的分段 ====>在进行相应的操作

=====>涉及到红黑树：

4、HashMap和HashTable有什么区别
==========>HashMap是线程不安全的，其性能比较高
都可以被序列化，
HashTable多了contains方法

5、java的IO有几种

IO模型：
    1）同步阻塞IO：(BIO)====>数据的读取写入必须阻塞在一个线程内等待其完成(相当于单线程)
    2）同步非阻塞IO：（NIO）===============》关注的同时还会去做一些其他的事
    3）多路复用IO：================》买多种东西，好了去下一家，完成了叫号
    4）异步IO：====================》（没有意义）


  同步阻塞：BIO，自己一直关注，不能去做其他事情，呆呆的等着他发行程信息

  同步非阻塞：NIO,自己关注，可以做其他事情，只是需要时不时的自己回来看看他有没有发新行程

  异步非阻塞：AIO/Ajax，（多路复用IO）他有新的行程会通知你，这期间你可以去做其他事情

  异步阻塞没实际意义了。。 （有行程会通知）     

6、NIO和以前的IO有什么区别
IO:面向流的，NIO是面向块的（缓冲区）
IO：阻塞的 NIO是非阻塞的

7、都用过哪些常用的Linux命令
跟踪日志的 tail
查看进程的 PS top pstree -aup
杀死进程 kill -9
解包和压包的 tar
su root
拷贝 cp
删除的 rm
mkdir 创建文件夹

8、线程这块有用到吗

9、有没有写过脚本

10、前端也开发是吗

11、老干部管理平台是做什么用的

12、数据库涉及的多吗？有没有设计过
设计的多，有用过powerdisener设计过
添加过索引

13、数据库的联查、左右连接的区别、内连接

14、java常用的数据，分别占几个字节
byte(1) short(2) int(4) long(8) char(2) float(4) double(8) boolean(4)

=================================

数据库引擎 行锁 表锁 行专列 mylsam inodb

spring 三级缓存

mybatis的二级缓存----》namespace、 一级缓存 sqlsession

15、JVM的内存模型
分为： 堆、栈（栈帧）、方法区、本地方法栈、程序计数器

 栈中存储的  栈帧：每个对应每个方法的每次调用======》局部变量、参数、中间结果
              1）局部变量区：存方法中的局部变量和参数
              2）  操作数栈：存方法执行过程中产生的中间结果
 程序计数器：存下一条要执行的指令在方法的偏移量==============》每个线程都有程序计数器，相当于线程的指针
 
 堆：存对象
 
 本地方法栈：存  native方法
 
 方法区：存  1）方法代码  和  符号表
             2）要加载的   类信息、静态变量、final类型常量、属性  、方法信息
             
 栈：线程创建时创建、线程销毁时销毁

16、JVM的工作原理

  1）源码编译机制======》词法、语法分析等====》字节码文件
  2）类加载机制=======》（1）根类：lib/rt.jar    （2）扩展类：lib/ext/*.jar     （3）classpath下的类
  3）类执行机制========》基于堆、栈的操作

17、垃圾回收：GC

  新域：1）Eden:最早活动的对象
        2）辅助生存空间
        
   1）作用域：方法区 和 堆
   2）怎样判断对象已死？
       （1）计数算法：每次对象引用就+1，最后为0的就是已死的======》难判断两对象互相调用
       （2）可达性算法：以要看的对象为root，向下搜索=====》引用链=====》没有任何引用链的证明不可达
                 ========》可作为root的对象：栈中引用的对象、本地方法栈中Native方法引用的对象、方法区静态属性引用的对象、方法区常量引用的对象
   3）根据对象引用类型======》GC处理不同：
               （1）强引用：大多数是=====》只有此对象实例没被其他对象引用时，被回收
               （2）软引用：适用于缓存=====》内存不够时被GC
               （3）弱引用：在GC时一定会GC
               （4）虚引用：只用于得知对象是否被GC
   4）垃圾回收算法：
           （1）标记-清除算法：
                  标记需要回收的对象====》标记完成后统一回收
                          ==========================> 1）内存碎片   2） 效率不高
            （2）复制算法：
                    ========》（1）将内存均分成2份，每次只用一份
                              （2）当一块内存用完了=====》将还活着的对象   复制到  另一块====》刚刚用完的清理掉====》解决了碎片问题
                                          ==========》内存缩小为一半了
            （3）标记-整理算法：
                  ========》标记对象====》让或者的对象  向另一侧移动======》最后清掉边界的内存
            （4）分代收集算法：
                   ======》堆：新生代、老年代
                       方法区：永久代
                          （现在时元空间）=====》  永久代：使用内存
                                                   元空间：使用物理内存
            新生代：复制算法
            老年代：标记-清除      标记-整理
            永久代：

18、事务的隔离级别

@Transactional(isolation= Isolation.READ_UNCOMMITTED)    

事务传播类型：(propagation)
    1）REQUIRD:====》没有事务=====》新建
    2）SUPPORTS====>支持当前事务/无事务===》非事务执行
    3）MANDATORY===>没有事务====》抛异常
    4）NEVER=======>非事务执行===》有事务则抛异常
    5）NESTED======>有事务，则套事务执行=====》无事务，则新建
    6）REQUTERS_NEW==》新建事务===》有的话就将当前事务挂起
   
**事务的相关问题：**
     1）不可重复读：两个事务去同时操作一个数据，事务1写还没结束、事务2读了=====》两侧不一样
     2）幻读：事务1修改、事务2新增======》最终发现突然多出了几个没修改的数据
     3）脏读：事务1改完之后====》回滚了=====》事务2读到了回滚前的数据

为了解决这样的问题，引入了事务的隔离级别：（isolation）
默认====》读已提交？
1）读未提交数据：=>最低》会产生： 不可重复读、脏读、幻读
2） 读已提交：=》会造成 =》可重复读
3） 可重复读：=》可以防止脏读、可重复读==》会产生幻读
4) 串型化：=》最可靠》可都防止===》保证顺序执行
5) 数据库默认：=====》会造成 =====》可重复读

19、spring的 前置、后置、环绕 通知

    1）他们都可以获得方法的签名，参数列表，被代理的目标对象，但是只有后置通知才可以获得方法的返回值。(beforeAdvice、afterAdvice)
    2）环绕通知（roundAdvice）：没有办法获取方法的参数列表，方法前面，代理对象的信息了
    3）异常通知（throwsAdvice）

  注：异常通知和后置通知不一样，后置通知可以获取方法的返回值，异常通知无法获取方法的返回值（因为发生异常了）。
  后置通知和环绕通知还不一样，后置通知无法改变方法的返回值，环绕通知可以修改方法的返回值，因为环绕通知是基于一种回调的方式来进行的代理。
  
  1. 一个代理对象只能代理一个目标对象
  2. 从容器中获取的 bean 的 id 是代理对象的 id，而不是目标对象的 id
  3. 通知只能切入到目标对象的所有方法，不能指定切入具体的某个方法
  
  
  ===========通知：方法前后要做的动作
  1）前置通知：   before  
       =======》记录日志（方法将被调用）
  2）后置通知：   after_returning   =====>方法执行后的通知=====》抛异常则不通知
        记录日志（方法已经被成功调用）
  3）环绕通知：around   ========》方法执行之前和之后都执行的通知
       控制事务、控制权限
  4）异常通知：after-throwing
       异常处理、控制事务
  5）最终通知：after=======》方法执行之后=====》怎样都会通知
       记录日志（方法已调用，不一定成功）

20、设计模式

 1） 单例模式：一个类只有一个实例=====》该实例易于外界访问
       场景========》每个类的对象只能存在一个时
 
 2）工厂模式：为创建对象提供接口
       场景========》1）编码时不知道需要创建那种类型的实例
                     2）系统不依赖于产品实例如何被创建、组和和表达的细节
 3）策略模式：定义了算法族，分别封装====》互相替换===》让算法的变化独立于算法的客户
              场景=====》1）一个事情有很多方案实现
                         2）可以做任何事，决定采用哪种实现
                         3）未来可能增加更多的方案
                         4）让方案的变化不会影响到使用方案的客户
              业务场景：
                   1）算法一：日志记录到数据库中     
                   2）算法二：连不上数据库时写到文件中
                   这些调用方不关心，只负责写
  4）观察者模式：（发布/订阅模式）====》对象间一对多依赖，对象改变状态===》依赖者收到通知也会改变
             场景：=====》1）对一个对象状态的更新，需其他对象同步更新====》其他对象的数量动态可变
                          2）对象仅需要将更新通知给其他对象===》不用知道细节
                          
  5）迭代器模式：提供一种方法顺序访问一个聚合对象中各种元素，又不暴露该对象内部表示
        场景========》当需要访问一个聚集对象，且不管这些对象是什么，都需要便利时
  6）模板方法模式：定义一个操作中的算法骨架，将一些步骤延迟到字类中，=======》模板使字类不改变一个算法结构===》就可重定义该算法的某些步骤
        场景========》对一些功能，在不同对象身上展示不同的作用，但功能的框架一样
        
   ===========================================================================================================
   ===========================================================================================================
   （1）工厂模式====》beanfactory====》简单工厂
   （2）单例模式====》bean默认为单例
   （3）代理模式====》   aop==》JDK动态代理、CGLib
   （4）模板方法====》   解决代码重复
   （5）观察者模式==》  对象一对多===》一对象状态改变===》所有依赖它的对象都要重新制动

21、AOP
1）什么是AOP====》与业务无关，当对多个对象产生影响的====》抽取并封装成一个独立的模块
2）好处：》解耦，可维护性提高
权限认证、事务、日志等
3）实现：=》基于动态代理：（1）JDK动态代理====》接口
（2）CGLIB==========》继承父类

 4）AOP分为：（1）Spring AOP:=====>运行时增强、简单
             （2）AspectJ AOP:====>编译时增强=====》静态代理=====》切面太大时用
                       比Spring AOP 快很多
                       =====》支持构造函数切点====》可以向构造函数进行通知
              =======》可以拦截属性

**22、IOC控制反转：======》spring框架管理对象**

   Spring：XML配置
   Spring boot:注解配置

三种注入方式： 构造器注入、setter注入、注解注入

构造器注入：====》类中每个参数代表一个对其他类的依赖
setter注入: ====》bean的setter方法

23、beanFactory和applicationContext
1）benafactory：延迟加载====》注入bean===》使用bean时才会实例化
2）applicationContext:容器启动时，一次性创建所有的bean=====》有助于启动及发现配置问题
3）beanFactory:以编程方式创建，
4）applicationContext：以声明式方式创建，（自动注册、可以设置懒加载===》延迟加载）