面试题整理存档

1.jvm原理, 内存模型的五大部分

1.方法区
2.栈
3.本地方法栈
4.堆
5.程序计数器

2.java基础, == 和 equals的区别

== 解读: 对于基本类型和应用类型的== 的作用效果是不同的:
-基本类型: 比较的是值是否相同;
-引用类型: 比较的是引用的是否相同;
equals解读: equals 本质上是 == ,只不过String 和 Integer 等重写了equals 方法,把它变成了值比较

3.接口和抽象类的区别

实现: 抽象类的子类使用extends 来继承, 接口必须使用implements 来实现接口
构造函数: 抽象类可以有很多的构造函数;接口不能有
实现数量: 类可以是实现很多个接口,但是只能继承一个抽象类

4.java集合list 和 map 底层原理

  • 东西比较碎:
  • 分为三部分:
  • 第一块 list -->ArrayList , LinkedList, Vector(–>stack);
  • List(有序,可重复)
  •          ArrayList: 底层数据结构是数组,查询快,增删慢,线程不安全,效率高
    
  •          Vector : 底层数据结构和数组,查询快, 增删慢,线程安全,效率低
    
  •          LinkedList: 底层数据结构是链表, 查询慢, 增删快, 线程不安全, 效率高
    
  • Map(双列集合)
  •          A : Map集合的数据结构仅仅是针对键有效,与值无关
    
  •         B : 存储的是键值对形式的元素, 键值为一, 值可重复
    
  • 第二块 map --> HashMap,
  • HashMap: 底层数据结构哈希表, 线程不安全, 效率高
  • 哈希表依赖两个方法: hashCode() 和 equals()
  •                          执行顺序:  首先判断hashCode()值是否相同
    
  •                                      是: 继续执行equals() ,看其返回是true : 说明元素重复, 不添加,是false : 就直接添加到集合
    
  •                                      否: 就直接添加到集合
    
  •                            最终:  自动生成hashCode() 和 equals () 即可
    
  • HashTable: 底层数据结构是 哈希表, 线程安全, 效率低
  •                              哈希表依赖两个方法: hashCode() 和 equals()
    
  •                             执行顺序:
    
  •                                        首先判断hashCode()值是否相同
    
  •                                             是: 继续执行equals(), 看其返回值是true: 说明元素重复, 不添加,是false: 就直接添加到集合
    
  •                                             否: 就直接添加到集合
    
  •                            最终:  自动生成hashCode() 和 equals () 即可
    
  • TreeMap: 底层数据结构是红黑树. (是一种自平衡的二叉树)
  •                            如何保证元素的唯一性呢? 
    
  •                                            根据比较的返回值是否是 0 来决定
    
  •                           如何保证元素的排序呢? 
    
  •                                           两种方式:  1.自然排序(元素具备比较性), 让元素所属的类实现Comparable接口
    
  •                                                            2. 比较器排序(集合具备比较性) , 让集合接收一个Comparable的实现类对象
    
  • 第三块 set -->HashSet , LinkedHashSet , TreeSet
  • Set(无序,唯一)
  •          HashSet : 底层数据结构是哈希表,哈希表依赖两个方法: hashCode() 和 equals() 
    
  •          执行顺序: 首先判断hashCode()值是否相同
    
  •                  是 : 继续执行equals(), 看其返回值是true: 说明元素重复,不添加,是false : 直接添加到集合
    
  •                   否 : 就直接添加到集合
    
  •          最终 : 自动生成hashCode() 和 equals()即可
    
  • LinkedHashSet
  •          底层数据结构由链表和哈希表组成, 由链表保证元素有序, 由哈希表保证元素唯一
    
  • TreeSet
  •         底层数据结构是红黑树.(是一种自平衡的二叉树)
    
  •         如何保证元素唯一性呢?  根据比较的返回值是否是 0 来决定
    
  •          如何保证元素的排序呢?
    
  •          两种方式:   1. 自然排序(元素具备比较性) : 让元素所属的类实现Comparable接口
    
  •                             2. 比较器排序(集合具备比较性) : 让集合接收一个Comparator的实现类对象
    
  • 2.关于集合选取原则
  • 是否是键值对形式:
    
  •         是: Map
    
  •                键是否需要排序:
    
  •                        是: TreeMap
    
  •                        否: HashMap
    
  •                不知道, 就使用 HashMap.
    
  •        否: Collection
    
  •                元素是否唯一:
    
  •                       是: Set
    
  •                              元素是否需要排序:
    
  •                                          是: TreeSet
    
  •                                          否: HashSet
    
  •                              不知道,用使用HashSet
    
  •                      否: List 
    
  •                              要安全吗:
    
  •                                  是: Vector
    
  •                                  否: ArrayList 或者 LinkedList
    
  •                                          增删多: LinkedList
    
  •                                          查询多: ArrayList
    
  •                                  不知道, 就使用ArrayList
    
  •               不知道,就使用ArrayList
    
  • 3: 集合的常见方法及遍历方式
  •      **Collection :**
    
  •           add() , remove(), contains(), iteration(), size()
    
  •      遍历:  增强for  迭代器
    
  •      **List :**   get()    遍历: 普通 for
    
  •      **Set :**                 它不按照存储的顺序保存,具有不确定性,也就是说每一次遍历集合出的元素排序不一定相同;
    
  •      **Map :** put() , remove() , containskey() , containsValue() , keySet() , get() , value() , entrySet() , size() 
    
  •        遍历: 1.据键找值
    
  •                  2.根据键值对对象分别找键和 值
    

在这里插入图片描述

5.开发中经常遇到的异常(不要算数异常)
空指针异常
方法不存在异常
数组下标越界异常
文件找不到异常
指定类找不到异常
数据类型转换异常
scoketException异常
IOException IO异常
6.面向对象的抽象,封装,继承,多态
继承: 子类继承父类的方法,一种代码重用的方式
多态: 子类继承父类的,可以重写父类的方法,父类引用指向子类的对象
封装: 处处都要封装,封装的好处在于规整代码,重复利用,减少冗余。一个方法就是个封装啊,一个工具类,一个框架,我们一直都在封装。
抽象: 抽象是从众多的事物中抽取出共同的、本质性的特征,而舍弃其非本质的特征的过程。
7.stringbuilder 和 stringbuffer的区别
Stringbuffer和Stringbuilder最大的区别在于, StringBuffer是线程安全的,而StringBuilder是非线程安全的,但StringBuffer的性能却高于StringBuffer,所有在单线程环境下推荐使用StringBuilder,多线程环境下推荐使用StringBuffer.
8.treemap和treeset
1.TreeSet: 数据元素可以排序且不可重复
2.TreeMap: 要求键可以排序,与上TreeSet同理
9. mvc原理,工作流程
1.spring mvc 先将请求发送给DispatcherServlet
2.DispacherServlet查询一个或者多个HandlerMapping, 找到处理请求的Controller
3.DispacherServlet再把请求提交到对应的Controller
4.Controller进行业务逻辑处理后,会返回一个ModelAndView
5.DispacherServlet查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端
10.spring事务的传播机制,注解
@Transactional
11.ioc 和 aop
ioc: 控制反转是spring的核心,对于spring框架来说,就是由spring负责控制对象的生命周期和对象间的关系,
(简单来说: spring提供ioc技术,容器会帮助你管理依赖的对象,从而不需要自己创建和管理依赖duixiangle,更轻松的实现了程序的解耦)
aop:aop是面向切面编程,通过预编译方式和运行期动态代理实现程序功能的同一维护的一种技术
( aop: spring aop 是面向切面编程,是对spring oop 面向对象编程的一种补充,并不是替代了spring oop 只是补充
AOP 能够为不同过程提供更好的封装性,提高未来的互操作性。
理解: 通常在代码的编程时,我们会遇见许多公用的且重复的代码, 比如记录日志, 权限验证, 事务管理, 异常处理等,
aop的思想就是把这些重复的代码都单独的放到一个个的切面中,留下一个切点,当一个类或者多个类调用这些公共重复的代码或者方法的时,通过切点连入即可, 如果需要修改的时候,单独的修改切面中的方法或代码就行,不需要每个类,每个方法的去修改,节省了时间,并减少了代码的出错率)
12. springBoot 自动配置原理(要求详细一点)
1.SpringBoot应用标注在某个类上说明这个类是SpringBoot的主配置类,SpringBoot就会运行这个类的main方法来启动SpringBoot项目。
2.@SpringBootApplication是一个组合注解。
13.bean的生命周期
https://blog.csdn.net/w_linux/article/details/80086950添加链接描述
14.servlet生命周期

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程:

Servlet 通过调用 init () 方法进行初始化。
Servlet 调用 service() 方法来处理客户端的请求。
Servlet 通过调用 destroy() 方法终止(结束)。
最后,Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

https://www.runoob.com/servlet/servlet-life-cycle.html

15.starts理解,作用,是什么东西
java中实现多线程有两种途径:
继承Thread类或者实现Runnable接口。
在使用Thread的时候只需继承Thread,并且new一个实例出来,调用 start()方法即可以启动一个线程。
拓展:start()方法用于启动线程, run()方法用于星星线程的运行时代码.run()可以重复调用,而start()只能调用一次
16.mybatis一二级缓存的使用和实现原理

MyBatis的缓存分为两种
一级缓存基于sqlSession二级缓存基于namespace
缓存的作用缓存:1.提高加载速度 2.减轻服务(web,mysql)压力
关于脏数据因为当一级二级缓存都开启的时候,会发生数据碰撞,但是当运行二级缓存的时候,关闭一级缓存就不产生脏数据
一级二级缓存用的测试是不同的因为要测试多个Sqlsessioon,进行数据的查询修改,看数据会不会发生改变

在这里插入图片描述
17.为什么使用springcloud,运行维护成本高
1.微服务过多,治理成本高,不利于维护系统
2.分布式系统开发的成本高(容错,分布式事务等)対团队的挑战大
18.为什么要使用 Eureka ,Zuul,Ribbon,Hystrix
为了解决微服务面临的问题:
1.有那么多的小服务,如何来管理这些服务? 服务治理 : 注册,发现,剔除
2.有那么多的小服务,服务之间如何调用? openFeign : 微服务与微服务之间的调用
3.有那么多的小服务,客户端如何调用服务? gateWay : 网关 (zuul)
4.有那么多的小服务,一旦某个服务出错了,作为程序员如何快速的定位到那个服务? (nacos) 链路追踪
5.有那么多的小服务,一旦某个服务出错了,怎么处理? 服务容错: 防止级联拖垮 :宕机 ( 熔断,降级,兜底,限流)
19.微服务之间的调用,feign怎么调用的,怎么配置
https://blog.csdn.net/weixin_40170892/article/details/99644429添加链接描述
20.springcloud和dubble的区别?
https://blog.csdn.net/u010664947/article/details/80007767添加链接描述
21.redis常用的数据类型有那些?
1.List(列表)
2.Set(集合)
3.Hash(哈希)
4.Zset(Sort Set 有序集合)
5.String(字符串)
22.项目中使用redis存储什么数据,用来干什么的?
1、redis由于数据的读取和操作都在内存当中操作,读写的效率较高,所以经常被用来做数据的缓存。把一些需要频繁访问的数据,而且在短时间之内不会发生变化的,放入redis中进行操作。从而提高用户的请求速度和降低网站的负载,降低数据库的读写次数,就把这些数据放到缓存中。

2、一些常用的实时计算的功能。需要实时变化和展示的功能,就可以把相关数据放在redis中进行操作。大大提高效率。

3、消息队列,经常用来构建类似实时聊天系统的功能,大大提高应用的可用性。
23.redis穿透,击穿,雪崩是什么东西? 怎么解决?
4.4什么是缓存穿透?如何避免?什么是缓存雪崩?何如避免?

1.缓存穿透:
大量查询缓存中不存在的key,数据库中也不存在的key时。
2.如何避免:
1.再缓存中存放一个Null的对象,并且设置较短的时间。
2.使用bloomfilter,相当有一个大的bitMap对象,里面存放了所有的key值。
在这里插入图片描述

缓存雪崩:
当缓存服务器重启或者大量缓存集中在某一个时间段失效,这样在失效的时候,会给后端系统带来很大压力。导致系统崩溃。

1.在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
2:搭建集群
3:不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀

24.redis的持久化方式?
RDB (快照):快照形式 ,定期将当前时刻的数据保存磁盘中。会产生一个dump.rdb文件
特点:性能较好,数据备份。但可能会存在数据丢失。
AOF(只追加文件) :append only file (所有对redis的操作命令记录在aof文件中),恢复数据,重新执行一遍即可。
特点:每秒保存,数据比较完整。但耗费性能。
  【注】如果两个都配了优先加载AOF。(同时开启两个持久化方案,则按照 AOF的持久化放案恢复数据。)
25.redis两种持久化方式的各自的优缺点,应该如何选择?
26.nginx的算法
1.轮询(默认)
2.weight轮询权值
https://blog.csdn.net/weixin_42008778/article/details/80627300添加链接描述
27.mycat的作用,如何配置?
http://www.mycat.org.cn/
28.消息队列 kafka(rabbitmq)

感觉不会
29.项目如何切换环境的
配置文件中修改

30.分布式事务和分布式锁,如何实现?
31.sql的存储引擎
32.sql优化
33.事务的隔离级别
34.悲观锁和乐观锁如何实现, 原理, 效率(了解)
**35.创建一个 a , b 索引, 我查找使用 b索引, a会不会用索引 **
36.B数索引和位图索引的区别
37.索引的顺序
38.数据库三范式

1.每一列不可再分
2.基础上,有唯一依赖的主键
3.基础上,数据不能有传递性,直接依赖于主键

39.设计模式 (笔试)手写单例

40.简单介绍项目,详细介绍自己负责的模块
难点在于?
41.JDK1.8的优化? 在java容器方面有那些改进?
42.讲一下多线程和线程池的理解? 线程的安全怎么解决?
43.where 1= 1 作用? mybatis里怎么解决的?
44.IO AIO BIO NIO 的区别?
45. 缓存和数据库的一致性怎么保证?
46. 分布式锁的实现?
47.库存超卖怎么解决?
48. union 和 union all?
49.sql里的连接方式? 都有什么特点?
50.spring 怎么解决循环依赖的问题?
51. AOP的原理? 默认是那种? jdk还是 cglib
52. AQS的理解? Java中的应用?
53.数据结构的了解? 插入和快速排序?
54.消息队列的理解? 怎么解决重复消费? 消息丢失的问题?
55.关于线程, 反射方面的问题
56.集合方面 两个list怎么合成? 怎么排序?
57.reids缓存穿透力,如果你的项目里部署了redis集群,什么场景下会产生缓存穿透,怎么解决?
58.MQ队列消息从发送消息到接收消息,这个过程发生了什么?
59. rpc框架有什么?
60.索引创建了调用的还是全局扫描为什么?
61.mycat如何实现分库分表,读写分离?
62.如果有订单模块,详细讲一下业务如何实现的?
63.如何处理分布式事务?
64.feign和ribbon的区别?
65.定时任务怎么写?
66.shiro框架怎么实现认证 和 权限的
67. springboot如何实现统一异常处理
68.为什么使用es , es是怎么分片的?
69.你项目中遇到过什么问题? 如何解决的? 上家公司有多少人,人员怎么分配的?
70.并发量多少? 日活量多少?
71.日志怎么管理的?
72.hashmap底层 实现原理 自动扩容, 碰撞
73. ConcurrentHashMap有什么好处?
74.单例模式的静态内部类和枚举
75.工厂模式有那些? 常用的几个? 能写出来
76.jvm内存

1.双亲委派,
2.虚拟机栈,本地方法栈,程序计数器
3.调优
4.垃圾回收

77.算法

时间复杂度,空间复杂度

78.Mysql 索引为什么快? 数据引擎是什么?

79.Redis 为什么使用redis查询就会变快?
80.多路复用, io阻塞是什么? 解释下
81.分布式事务介绍, 分布式锁怎么实现

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值