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:以声明式方式创建,(自动注册、可以设置懒加载===》延迟加载)

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页