面试题汇总

旧城等待， 2023-10-11 18:22 149阅读 0赞

#### 文章目录 ####

*  1.Java的基础知
 *   *  1.1 java 1.8新特性
     *  1.2 有哪些集合？
     *  1.3 HashMap
     *  1.4 HashMap 是线程安全的吗，会有什么线程安全问题？
     *   *  如何处理HashMap的线程不安全的问题
     *  1.5 ConcurrentHashmap 用什么方式实现的？Segment 继承了什么类？-- ReentrantLock）
     *  1.6 HashMap 为什么要使用红黑树？
     *  1.7 ArrayList 扩容的函数方法名是什么？
     *  1.8. final、finally、finallize？
     *  1.9 finally 是在 return 之前执行还是之后？finally 块里的代码一定会执行吗？
     *  1.10 lambda 表达式了解吗？使用 lambda 表达式怎么实现两个 list 的 交集（提示：filter）？
     *  1.11 深拷贝和浅拷贝
     *  1.12 Java 序列化和反序列化为什么要实现 Serializable 接口？
     *  1.13 private修饰的方法可以通过反射访问，那么private的意义是什么？
     *  1.14 带你彻底认识String
     *  1.15 谈谈你对Map的理解
     *  1.16 isEmpty 和 isBlank 的用法区别
     *  1.17 类与对象的关系是什么
     *  1.18 Java 序列化和反序列化为什么要实现 Serializable 接口？
     *  1.19 SimpleDateFormat是线程安全的吗
     *  1.20 简述一下受检异常和非受检异常
     *  1.21 并行和并发有什么区别
     *  1.22 Object类的子类
     *  1.23 JDK中常用的设计模式
     *  1.24 公共类的作用
     *  1.25 怎么调用总部接口
     *  1.26 equals == 区别
     *  1.27 Java中线程不安全的原因
     *  1.28 包装类和基本数据类型区别？为什么有包装类？
     *  1.29 IO体系
     *   *  IO流的分类
 *  2.Spring篇
 *   *  简单谈谈你对Spring的理解
     *   *  理解Sping
         *  面向切面AOP
         *  Spring支持的几种bean的作用域
         *  使用Spring框架的好处
     *  2.1 Spring事务
     *   *  Spring 事务实现方式有哪些？
         *  @Transactional 实现原理
         *  spring声明式事务哪些场景会失效
         *  事务的隔离级别
         *  有哪些事务传播行为？
     *  2.2 Spring 用到了哪些设计模式？
     *  2.3 IOC与AOP
     *   *  谈谈你对IOC的理解
         *   *  IOC容器
             *  控制反转
             *  依赖注入
         *  简述Spring Aop原理
         *   *  创建代理对象阶段
             *  拦截目标对象阶段
             *  调用代理对象阶段
             *  调用目标对象阶段
     *  2.4 Spring中的Bean是线程安全的吗？
     *  2.5 谈谈你对Spring Bean的理解
     *   *  什么是Spring Bean
         *  定义Spring Bean有哪些方式
         *  Spring容器是如何加载Bean的
     *  2.6 Spring为何需要三级缓存解决循环依赖而不是二级缓存
     *   *  什么是循环依赖
         *  哪些情况会出现循环依赖
         *  Spring如何解决循环依赖
         *  Spring中哪些情况下不能 解决循环依赖问题
     *  2.7 简述Spring MVC的执行流程
     *   *  配置阶段
         *  初始化阶段
         *  运行阶段
     *  2.8 AOP有哪些实现方式？
     *   *  静态代理
         *  动态代理
         *   *  JDK动态代理和CGLIB动态代理的区别？
             *   *  JDK动态代理
                 *  CGLIB来动态代理
                 *  两者的区别：
     *  2.9 Bean注入容器有哪些方式？
     *  2.10 @Autowired和@Resource的区别？
     *  2.11 @Qualifier 注解有什么作用
     *  2.12 @Bean和@Component有什么区别？
     *  2.13 @Component、@Controller、@Repositor和@Service 的区别？
     *  2.14 Spring实现异步调用的方式有哪些
     *  2.15 谈谈你对SpringMVC中九大组件的理解
 *  3.计算机网络篇
 *   *  3.1 tcp,ip协议
     *  3.2 请简述 TCP 和 UDP 的区别
     *  3.3 请详细介绍 一下TCP 的三次握手机制
     *  3.4 TCP握手为什么是三次 ，为什么不能是 两次 ？不能是四次
     *  3.5 TCP四次挥手过程?
     *  3.6 TCP挥手为什么需要四次
     *  3.7 为什么客户端在TIME-WAIT阶段要等2MSL？
     *  3.8 说说TCP是如何确保可靠性的呢？
     *  3.9 聊聊TCP的滑动窗口
     *  3.10 TCP和UDP分别对应的常见应用层协议有哪些？
     *  3.11 OSI七层模型
     *  3.12 输入url到页面展示的过程？
     *  3.13 HTTP的状态码
     *  3.14 既然有 HTTP 协议，为什么还要有 RPC
     *  3.15 get和post的区别
     *  3.16 Https和http的区别？介绍一下https？https是如何实现的？
     *   *  什么是Http、Https
         *  https和http有什么区别
         *  https是如何实现的
 *  4.SpringBoot篇
 *   *  4.1 SpingBoot 也有定时任务？是什么注解？
     *   *  fixedRate/fixedDelay区别
     *  4.2 Cookie和session区别
     *  4.3 SpringBoot自动装配原理
     *  4.4 SpringBoot启动流程
 *  5.多线程篇
 *   *  5.1 synchronized和lock
     *  5.2 JUC 的原子类是怎么实现原子性的？
     *  5.3 说下 CAS 算法？
     *  5.4 CAS的工作原理
     *  5.5 说一下voliate
     *  5.6 volatile能保证原子性吗？为什么？(类似：i++为什么不能保证原子性?)
     *  5.7 说下volatile的应用场景?
     *  5.8 Volatile是否用得越多越好？
     *  5.9 之前32位机器上共享的long和double变量的为什么要用volatile? 现在64位机器上是否也要设置呢?
     *  5.10 Volatile怎么实现的？
     *  5.11 synchronized和Volatile区别是什么?
     *  5.12 说下原子性、可见性、有序性？
     *  5.13 死锁的概念。如何避免死锁。
     *  5.14 说下一个线程获取锁时非常长的时候，比如1小时，如何处理这种情况
     *  5.15 threadLocal
     *  5.16 Thread.sleep(0)到底有什么用
     *  5.17 谈谈FastLocal为啥这么快
     *  5.18 线程两次调用start()会出现什么问题
     *  5.19 当任务数超过线程池的核心线程数时，如何让他直接启用最大线程数
     *  5.20 聊一聊AQS
     *   *  AQS的核心原理
     *  5.21 公平锁与非公平锁的区别
 *  6.JVM篇
 *   *  6.1 JVM 内存模型？（JMM）
     *  6.2.说下类加载器与类加载？
     *  6.3 JVM的类加载机制：
     *  6,4双亲委派机制是什么，有什么好处，怎么打破
     *  6.5 使用双亲委派模型好处？
     *  6.6 CMS 与 G1 的区别，G1 改进了什么，说下二者的垃圾收集过程
     *   *  CMS垃圾回收器
         *  G1垃圾回收器
     *  6.7.垃圾回收算法（也叫垃圾回收策略）
     *  6.8 jvm堆内存的分代划分
     *  6.9 详解JVM内存模型
     *  6.10 JVM中一次完整的GC流程是怎样的
     *  6.11 JVM调优的几种主要的JVM参数
     *  6.12 JVM调优
     *  6.13 Jdk1.7到Jdk1.8 java虚拟机发⽣了什么变化?
     *  6.14 你们项目如何排查JVM问题 ？
     *  6.15 说⼀下JVM中，哪些可以作为GC root
     *  6.16.JVM诊断工具有哪些？
     *  6.17.为什么要使用STW？
     *  6.18 JVM锁优化和逃逸分析
     *  6.19 jvm堆内存的分代划分
     *  6.20 JVM内存结构
     *   *  程序计数器
         *  Java虚拟栈
         *  本地方法栈
         *  堆
         *  方法区
         *  运行时常量池?
         *  什么时候抛出StackOverflowError?
         *  Java7和Java8在内存模型上有什么区别?
         *  程序员最关注的两个内存区域?
     *  6.21 JVM中为什么使用元空间替换永久代
     *  6.22 JVM诊断工具有哪些？
     *  6.23 为什么要使用STW？
     *  6.24 JVM内存结构分析：为什么需要S0和S1
 *  7.数据库篇
 *   *  7.1 索引建立的原则？怎么建立索引，有哪些索引？你对索引了解多少？
     *  7.2 聚集索引和非聚集的区别
     *  7.3 聚集索引的优势与缺点
     *  7.4 导致索引无法命中的原因
     *  7.5 MyISAM 与 InnoDB 引擎的区别？
     *  7.6 为什么要使用 B+树
     *  7.6 MySQL是将索引加载到内存中，是按页存储的，那么每页的内存占多大？
     *  7.7 说说最左前缀法则？
     *  7.8 MySQL的Explain主要看哪几个关键词
     *  7.9 哈希索引
     *  7.10.怎么建立索引，复合索引
     *  7.11 数据库三范式
     *  7.12 数据库语句的执行顺序
     *  7.13 数据库redolog和binlog
     *   *  binlog
     *  7.14数据库索引的重构过程
     *  7.15 为什么少用offset 和 limit 分页了
     *  7.16 分库分表-ShardingSphere
     *  7.17 千万级并发架构下，如何进行关系型数据库的分库分表
     *  7.18 数据库锁机制或者问如何避免脏读幻读等机制
     *  7.19 数据库大数据量的优化方案
     *  7.20 select......for update会锁表还是锁行
     *  7.21 mysql设置主从数据库的同步
     *  7.22 谈谈你对nosql的理解
     *  7.23 为什么增加索引能够提升查询效率
     *  7.24 Mysql如何解决幻读问题
     *  7.25 简述你对MVCC的理解
     *  7.26 Mybatis 中的 DAO 接口和 XML 文件里的 SQL 是如何建立关系的？
     *  7.27 MonogoDB
     *   *  基于文件存储，那么它的存储结构是什么？
         *  什么是BSON格式，与JSON的区别，有什么优势？
         *  MongoDB与Mysql的区别？
         *  说说MongoDB的索引
         *  说说MongoDB索引底层原理实现，与mysql有什么区别，有什么优势？
         *  说说MongoDB适用哪些场景？如何选择？
         *  你在实际开发中怎么使用MongoDB的？
         *  如何选择使用MongoDB？
         *  说说MongoDB的数据模型，如何选择？
         *  说说MongoDB的存储引擎，有什么优势？
         *  如何保证MongoDB高可用？
     *  7.28 Mybatis的二级缓存
     *  7.29 说一下你对行锁，临键锁，间隙锁的理解
     *  7.30 Mysql的左连接、右连接、内连接
     *  7.31 聊一聊Mybatis的SQL注入
     *   *  模糊查询
         *  in 之后的多个参数
         *  order by 之后
     *  7.32 Mybatis缓存机制
     *  7.33 Mybatis与Hibernate有哪些不同？
     *  7.34 为什么会出现nosql
 *  8.操作系统篇
 *   *  8.1 select, poll, epoll你了解多少
     *  8.2.BIO、NIO 与 AIO 区别
     *  8.3.IO多路复用 和 信号驱动IO？
     *  8.4 查看一个文件有多少行，查看一个文件有多大
     *  8.5 进程通信方法
     *  8.6
 *  9.Redis
 *   *  9.1 了解布隆过滤器吗
     *  9.2 Redis缓存一致性处理
     *  9.3.redis雪崩、穿透、击穿
 *  10.分布式篇
 *   *  10.1 了解 RPC 吗
     *  10.2 说一些你对rpc与api的理解，讲讲区别
     *  10.3 分布式锁的实现
     *  10.4 token 过期后，如何自动续期？
     *  10.5 谈谈你对时间轮的理解
     *   *  什么是时间轮
         *  时间轮的工作原理
         *  时间轮优缺点分析
     *  19.6 说下redis分布式锁误解锁的情况
     *  10.7 什么是幂等？如何解决幂等性问题
     *   *  什么是幂等
         *  如何解决幂等性问题
     *  10.8 在秒杀场景中，常见的限流算法有哪些
     *   *  计数器限流算法
         *  滑动窗口限流算法
         *  漏桶限流算法
         *  令牌桶限流算法
     *  10.9 谈谈你对分布式开发中的服务治理的理解
     *  10.10 负载均衡有哪几种实现方式？
     *  10.11 使用MQ的时候，怎么确保消息100%不丢失？
     *  10.12 分布式事务解决方案
     *  10.13 短链接系统的设计
     *  10.14 分布式id解决方案
     *  10.15 如何保证数据库和缓存双写一致性
     *  10.16 如何解决TCC中的悬挂问题
     *  10.17 分布式服务架构的设计方案
     *  10.18 分布式缓存
     *  10.19 如何保证token的安全
     *  10.20 Java分布式锁
     *  10.21 java实现延时处理
     *  10.22 分布式服务架构的设计方案
     *  10.23 负载均衡的常见几种算法
     *  10.24 说一些你对rpc与api的理解，讲讲区别
     *  10.25 负载均衡四层和七层的区别
     *  10.26 服务网关与流量网关
 *  11.算法篇
 *   *  11.1 快排
     *  11.2 排序算法—堆排序
     *  11.3 排序算法—选择排序
 *  12.设计模式
 *   *  12.1 迭代器与组合模式
     *  12.2 策略模式
     *   *  策略模式的实际应用场景
 *  13.分布式架构篇
 *   *  13.1 Spring Cloud Gateway夺命连环10问，带你彻底了解gateway
     *  13.2 一文梳理Dubbo常见面试问题
     *  13.3 springCloud alibaba：Nacos Config-服务配置
     *  13.4 springCloud alibaba：Sleuth--链路追踪
     *  13.5 springCloud alibaba：Seata--分布式事务
     *  13.6 SpringCloud alibaba
     *  13.7 springCloud alibaba：Sleuth--链路追踪
     *  13.8 springCloud alibaba： Sentinel--服务容错
     *  13.9 谈谈你对zookeeper的理解
     *  13.10
 *  14.消息队列
 *   *  14.1 RabbitMq是如何实现消息路由的
     *   *  工作流程
         *  路由策略
         *   *  Direct Exchange
             *  Topic Exchange
             *  Fanout Exchange
 *  15.Linux篇
 *   *  15.1 生产环境服务器变慢，如何处理诊断
     *  15.2 查找文件
     *  15.3 查看一个程序是否运行
     *  15.4 查看文件，包含隐藏文件
     *  15.5 通过端口查看进程id
     *  15.6 修改文件权限
     *  15.7 压缩文件
     *  15.8 查看文件前几行或者后几行
     *  15.9 查看端口属于哪个程序
     *  15.10 以树状图列出目录的内容
     *  15.11 文件下载
     *  15.12 打印信息
     *  15.13 远程登录
     *  15.14 kill命令详解
 *  16.项目
 *   *  16.1 海硅人才智库系统
     *   *  业务背景
     *  16.2 微证书系统
 *  17.Hr面
 *   *  17.1 工作中遇到的最大挑战是什么，你如何克服的
     *  17.2 你最大的优点和缺点，各自说一个
     *  17.3 未来的职业发展，短期和长期规划是什么

## 1.Java的基础知 ##

### 1.1 java 1.8新特性 ###

![在这里插入图片描述][ba4bfc6c068445b5bd24843f378be839.png_pic_center]

### 1.2 有哪些集合？ ###

![format_png][]  
**java.util.Collection** 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。

Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。

### 1.3 HashMap ###

[《Map到HashMap的一步步实现》][Map_HashMap]  
1.7 及之前数组+链表  
1.8 数组+（链表+红黑树）

数据比较少的时候，链表的性能要好于红黑树，所以HashMap一上来并没有直接采用红黑树

树化的阈值为8，为什么呢，因为正常业务情况下都不会出现链表的长度超过8。只有在恶意被攻击的情况下，如：DOS攻击，等才会出现大量的链表长度超过的情况，所以使用红黑树用来避免DOS攻击，防止链表超长时性能下降，同时，一般情况下认为树化是偶然情况。

其次，hash值如果足够随机，则在hash表内按**泊松分布**，在**负载因子0.75**的情况下，长度超过8的链表出现的概率是0.00000006，选择8的原因就是让树化的几率非常小。

树化的两个条件：链表长度超过树化阈值8，而且数组容量>=64

HashMap 扩容的特点：默认的table 表的大小是 16，threshold 为 12。负载因子 loadFactor .75，这些都是可以构造是更改。以后扩容都是 **2** 倍的方式增加。

对于为何负载因子是0.75的问题，下面我简单说一下我的感想

首先负载因子的作用是什么？

比如说当前的容器容量是16，负载因子是0.75,16\*0.75=12，也就是说，当容量达到了12的时候就会进行扩容操作。

他的作用很简单，相当于是一个扩容机制的阈值。当超过了这个阈值，就会触发扩容机制。

那么为何是0.75呢？

当负载因子为1.0时，意味着只有当HashMap装满之后才会进行扩容，虽然空间利用率有大的提升，但是会导致大量的Hash冲突，使得查询效率变低。

当负载因子为0.5时或者更低的时候，，hash冲突降低，查询效率提高，但由于负载因子太低，导致原来只需要1M的空间存储信息，现在用来2M的空间，最终结果是空间利用率太低。

*  退化的情况1：在扩容拆分树时，树元素个数小于等于6则会退化为链表退化情况2：remove树节点时，若root、root.left、root.right、root.left.left有一个为空，也会退化为链表

HashMap 从链表到红黑树的转变,如果链表的长度（冲突的节点数）已经达到8个，此时会调用 treeifyBin() ，treeifyBin() 首先判断当前hashMap 的 table的长度，如果不足64，只进行resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树。

**treeifyBin() 决定了一个链表何时转化为一个红黑树**

链表转化为红黑树的时候并不是直接去转，而是先构建一个标准查询二叉树，然后在标准查询二叉树然后调整为一个红黑树。而balanceInsertion() 实现了调整。

红黑树的性质：

*  每个结点或是红色的，或是黑色的
 *  根节点是黑色的
 *  每个叶结点（NIL）是黑色的
 *  如果一个节点是红色的，则它的两个儿子都是黑色的。
 *  对于每个结点，从该结点到其叶子结点构成的所有路径上的黑结点个数相同。

红黑树也是一种平衡二叉树，每个节点有一个储存位表示节点的颜色，可以是红色或者黑色。通过对任意一条从根到叶子的路径上各个节点着色方式的限制，红黑树确保**没有任意一条从根到叶子的路径超过最短路径的两倍**，因此红黑树是一种**弱平衡二叉树**。相对于AVL树来说，红黑树的**旋转次数少**，对于搜索、插入、删除多的操作下用红黑树。

### 1.4 HashMap 是线程安全的吗，会有什么线程安全问题？ ###

HashMap在并发场景中不是线程安全的。

比如A希望插入一个key-value对到HashMap中，当获取到对应的链表结点位置时，此时线程A的时间片用完了，而此时线程B被调度得以执行，可能线程B占用了A计算得到的位置，插入了数值。而线程A被切换回来的时候，不知道B已经插入了元素，仍然将元素插入此前计算好的位置，这样就会将B线程的插入记录覆盖掉了，这对应了多线程的put可能导致元素的丢失；

JDK1.7的时候采用头插法，多线程同时插入的时候，A线程在插入节点B，B线程也在插入，遇到容量不够开始扩容，重新hash，放置元素，采用头插法，后遍历到的B节点放入了头部，这样形成了环。

JDK1.8采用尾插法，会造成两种情况两个线程同时插入只有一个成功插入，还有就是可能会造成两次resize(++size>threshold) 。

#### 如何处理HashMap的线程不安全的问题 ####

使用线程更安全的HashTable或Current类，如：CurrentHashMap，以及使用使用Collections.synchronizedMap方法，对方法进行加同步锁；

### 1.5 ConcurrentHashmap 用什么方式实现的？Segment 继承了什么类？-- ReentrantLock） ###

HashTable 是线程安全的。HashTable 容器使用 synchronized 来保证线程安全，但在线程竞争激烈的情况下 HashTable 的效率非常低下.

ConcurrentHashMap 是由 **Segment 数组结构**和\*\* HashEntry 数组\*\*结构组成。

Segment 是一种可重入锁 **ReentrantLock**，在 ConcurrentHashMap 里扮演锁的角色

HashEntry 则用于存储键值对数据。一个 ConcurrentHashMap 里包含一个 Segment 数组，Segment 的结构和 HashMap 类似，是一种数组和链表结构， 一个 Segment 里**包含一个 HashEntry 数组**，每个 HashEntry 是一个**链表结构**的元素， 每个 Segment 守护者一个 HashEntry 数组里的元素, 当对 HashEntry 数组的数据进行修改时，必须首先获得它对应的 Segment 锁。

使用ConcurrentHashMap ，分段锁的思想，将 HashMap 进行切割，把 HashMap 中的哈希数组切分成小数组，每个小数组有 n 个 HashEntry 组成，其中小数组继承自ReentrantLock（可重入锁），这个小数组名叫Segment（JDK1.7）  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpeXVlNTIx_size_16_color_FFFFFF_t_70][]  
JDK1.8中取消了Segment 分段锁，采用 CAS + synchronized 来保证并发安全，ConcurrentHashMap 中 synchronized 只锁定当前链表或红黑二叉树的首节点，只要节点 hash 不冲突，就不会产生并发  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpeXVlNTIx_size_16_color_FFFFFF_t_70 1][]

[那些年你啃过的ConcurrentHashMap][ConcurrentHashMap]

### 1.6 HashMap 为什么要使用红黑树？ ###

1.7 及之前数组+链表  
1.8 数组+（链表+红黑树）

数据比较少的时候，链表的性能要好于红黑树，所以HashMap一上来并没有直接采用红黑树

树化的两个条件：链表长度超过树化阈值8，而且数组容量>=64

**treeifyBin() 决定了一个链表何时转化为一个红黑树**

红黑树的性质：

### 1.7 ArrayList 扩容的函数方法名是什么？ ###

**底层实现**：ArrayList底层实现是基于动态数组，对内存要求比较高，需要一块连续的内存空间  
LinkedList底层使用的是双向链表数据结构，不需要连续的内存空间，元素分散存储在内存里

**效率**：ArrayList增删慢，查询快，对元素必须连续存储，查询复杂度o(1)，新增复杂度o(n^2)  
LinkedList，查询复杂度o(n)，插入复杂度o(n)

**默认容量和扩容机制**：ArrayList，默认容量是**10**，如果初始化时一开始指定了容量，或者通过集合作为元素，则容量为指定的大小或参数集合的大小，扩容机制是新增到原来的**1.5**倍数，如果新增后超过这个容量，则容量为新增后所需的最小容量，然后使用Arrays.copy这样一个方法把老数组的数据拷贝的新的数组里面，扩容完成以后，再把当前需要插入的元素插入到新数组当中。

扩容的主要方法是grow()，我的理解是扩容最小应该满足的容量（因为ArrayList的扩容并不是每次扩容一位的，所以这个是最小的）

### 1.8. final、finally、finallize？ ###

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。

finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。

finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System的gc()方法的时候，由垃圾回收器调用finalize(),回收垃圾。

### 1.9 finally 是在 return 之前执行还是之后？finally 块里的代码一定会执行吗？ ###

try-catch-finally 中，如果 catch 中 return 了，finally也会执行，只不过是在return之前执行  
![在这里插入图片描述][f1e8339a98094a13a4b29e5e10edbdfd.png_pic_center]

![在这里插入图片描述][09e99876fbe6409492ec5f10aab71cdc.png_pic_center]

![在这里插入图片描述][3dfdcf32e3ca4c8a924f4f6358223b3c.png_pic_center]

### 1.10 lambda 表达式了解吗？使用 lambda 表达式怎么实现两个 list 的 交集（提示：filter）？ ###

lambda表达式本质是为了解决**匿名内部类**的问题，使代码变得简洁。

Lambda表达式是JAVA 8中提供的一种新的特性，基于**函数式**编程的思想，支持以代码作为方法参数，Lambda表达式本身没有名称，也不需要强制其归属于某个类，同时它又能有参数列表，方法体，返回值等，可以想象成是一种表达方式更简洁的匿名函数，所以可以编写Lambda表达式来优化匿名内部类的使用，提高代码的可读性。

lambda表达式取交并补

// 交集
            List<Student> interp = list1.stream().filter(list2Set::contains).collect(toList());
            System.out.println("---得到交集 interp---");
            interp.parallelStream().forEach(System.out::println);
    
            // 差集 (list1 - list2)
            List<Student> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(toList());
            System.out.println("---得到差集 reduce1 (list1 - list2)---");
            reduce1.parallelStream().forEach(System.out::println);
    
            // 差集 (list2 - list1)
            List<Student> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(toList());
            System.out.println("---得到差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
    
            // 并集
            List<Student> listAll = list1.parallelStream().collect(toList());
            List<Student> listAll2 = list2.parallelStream().collect(toList());
            listAll.addAll(listAll2);
            System.out.println("---得到并集 listAll---");
            listAll.parallelStream().forEach(System.out::println);
    
            // 去重并集
            list1Set.addAll(list2Set);
            List<Student> listDistinctAll = new ArrayList<>(list1Set);
            System.out.println("---得到去重并集 listDistinctAll---");
            listDistinctAll.parallelStream().forEach(System.out::println);

### 1.11 深拷贝和浅拷贝 ###

深拷贝和浅拷贝就是指对象的拷贝，一个对象中存在两种类型的属性，一种是基本數据类型， 一种是实例对象的引用。

1.浅拷贝是指，只会拷贝基本数据类型的值，以及实例对象的引用地址，并不会复制一份引用地址所指向的对象， 也就是浅拷贝出来的对象,内部的类属性指向的是同一个对象

2深拷贝是指，既会拷贝基本数据类型的值，也会针对实例对象的引用地址所指向的对象进行复制，深拷贝出来的对象，内部的类执行指向的不是同一个对象

### 1.12 Java 序列化和反序列化为什么要实现 Serializable 接口？ ###

[https://blog.csdn.net/zhiyikeji/article/details/126547155?spm=1001.2014.3001.5501][https_blog.csdn.net_zhiyikeji_article_details_126547155_spm_1001.2014.3001.5501]

### 1.13 private修饰的方法可以通过反射访问，那么private的意义是什么？ ###

[https://blog.csdn.net/zhiyikeji/article/details/125922970?spm=1001.2014.3001.5501][https_blog.csdn.net_zhiyikeji_article_details_125922970_spm_1001.2014.3001.5501]

### 1.14 带你彻底认识String ###

[https://blog.csdn.net/zhiyikeji/article/details/125883773?spm=1001.2014.3001.5501][https_blog.csdn.net_zhiyikeji_article_details_125883773_spm_1001.2014.3001.5501]

### 1.15 谈谈你对Map的理解 ###

[https://blog.csdn.net/zhiyikeji/article/details/124717489?spm=1001.2014.3001.5501][https_blog.csdn.net_zhiyikeji_article_details_124717489_spm_1001.2014.3001.5501]

### 1.16 isEmpty 和 isBlank 的用法区别 ###

[https://blog.csdn.net/zhiyikeji/article/details/123200038?spm=1001.2014.3001.5501][https_blog.csdn.net_zhiyikeji_article_details_123200038_spm_1001.2014.3001.5501]

### 1.17 类与对象的关系是什么 ###

类和对象之间是抽象与具体的关系。类是一个模板，是对一类事物的抽象描述，而对象用于表示现实中该事物的个体。类是在对象之上的抽象，对象则是类的具体化，是类的实例。

类必须通过对象才可以使用，而对象中的属性和行为必须在类中定义。

什么是对象？

对象（Object）是一个应用系统中的用来描述客观事物的实体，是有特定属性和行为（方法）的基本运行单位。是类的一个特殊状态下的实例。对象可以是一个实体、一个名词、一个可以想象为有自己标识的任何东西，可以概括来说：万物皆对象。

什么是类？

类（Class）是Java代码的基本组织模块，使用来描述一组具有共同属性和行为对象的基本原型。是对这组对象的概括、归纳和描述表达。类是对象的模板，它定义了本类对象的所拥有的属性集和行为集，是对一组具有相同属性和相同方法的对象的定义。

### 1.18 Java 序列化和反序列化为什么要实现 Serializable 接口？ ###

[https://blog.csdn.net/zhiyikeji/article/details/126547155?spm=1001.2014.3001.5501][https_blog.csdn.net_zhiyikeji_article_details_126547155_spm_1001.2014.3001.5501]

### 1.19 SimpleDateFormat是线程安全的吗 ###

SimpleDateFormat不是线程安全的，因为他的内部维护了一个Calendar的一个对象引用，他是用来存储和这个SimpleDateFormat相关的日期信息，当我们把SimpleDateFormat作为多个线程共享资源来使用的时候，意味着多个线程会共享SimpleDateFormat里面的一个Calendar引用，那么多个线程对同一个Calendar对象的一个操作，就会出现数据脏读导致一些不可预料的一些错误，在实际应用过程中呢，我认为 有四种方法可以解决这个问题：

1.把SimpleDateFormat定义成一个局部变量，每个线程调用这个方法的时候都会创建一个新的实例；

2.我们可以使用ThreadLocal这样一个工具，把SimpleDateFormat变成一个线程私有的

3.加一个同步锁，在同一个时刻只允许一个线程去操作，如：Syschronized关键字。

4.在Java8里面呢引入了一些线程安全的日期API，比如说像LocalDateTimer，比如说像LocalDateTimerFormatter等

### 1.20 简述一下受检异常和非受检异常 ###

对于这个问题可以通过两个方面回答：

**第一个是异常的本质**

受检异常和非受检异常都是派生自Throwable，他有两个子类的实现：

*  error
 *  Exception

error是指程序无法处理的错误，他和程序本身没有关系

而exception是指程序运行的时候他需要处理的异常

受检异常和非受检异常都是派生自exception类

**第二个是对于受检异常和非受检异常的定义**

受检异常是指在编译阶段必须要主动捕获的异常，遇到该异常他有两种处理办法：

*  通过try catch捕获
 *  或者通过throw把异常抛出

非受检异常是指程序不需要主动捕获，一般发生在程序运行期间，比如：Nullpointexception，当然我们可以选择去主动捕获这些异常。

出现这些异常的时候虽然说我们无法通过 捕获异常来实现异常的恢复，但是这些异常信息可以帮助我们快速去定位问题。

### 1.21 并行和并发有什么区别 ###

*  并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。
 *  并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。
 *  在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群。所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

### 1.22 Object类的子类 ###

*  registerNatives() //私有方法
 *  getClass() //返回此 Object 的运行类。
 *  hashCode() //用于获取对象的哈希值。
 *  equals(Object obj) //用于确认两个对象是否“相同”。
 *  clone() //创建并返回此对象的一个副本。
 *  toString() //返回该对象的字符串表示。
 *  notify() //唤醒在此对象监视器上等待的单个线程。
 *  notifyAll() //唤醒在此对象监视器上等待的所有线程。
 *  wait(long timeout) //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
 *  wait() //用于让当前线程失去操作权限，当前线程进入等待序列
 *  finalize() //当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

### 1.23 JDK中常用的设计模式 ###

1.单例模式

*  作用：保证一个类只有一个实例
 *  JDK中的体现：Runtime类

2.静态工厂模式

*  作用：代替构造函数创建对象，方法名比构造函数清晰
 *  JDK中的体现：包装类。比如：Intefer.valueOf()，Class.forName()等

3.抽象工厂模式

*  作用：创建某一种类的对象
 *  JDK中的体现：Java.sql包

4.原型模式

*  作用：原型模式的本质是拷贝原型来创建新的对象，拷贝是比new更快的创建对象的方法，当需要大批量创建新对象，而且都是同一个类的对象的时候可以考虑原型模式
 *  JDK中的体现：clone()方法

5.适配器模式

*  作用：是不兼容的接口相兼容。
 *  JDK中的体现：InputStream、OutputStrem

6.装饰器模式

### 1.24 公共类的作用 ###

“这个主要是保护属性的作用,防止在其他类对它进行改变。  
我们可以想象,如果定义成public的话,那么在任何地方都可以进行访问,那么是相当危险的。有些变量我们需要让外界访问的话,可以提供一个get方法。还有属性本来就是一个类私有的东西,定义成private没有什么错误。

### 1.25 怎么调用总部接口 ###

Java：

@Autowired
        private RestOperations restTemplate;
         MultiValueMap<String, Object> bodyMap = new LinkedMultiValueMap<>();
          bodyMap.add("file", new FileSystemResource(image));
            bodyMap.add("fileName", null);
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.MULTIPART_FORM_DATA);
            /**此处的请求头设置是必要的，您只有在注册之后才能够使用我们的文件上传服务**/
            headers.add("X-Token", token);
            HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(bodyMap, headers);
            RestTemplate restTemplate = new RestTemplate();
            ResponseEntity<BaseResult> res = restTemplate.exchange("远程ip+端口地址",
                    HttpMethod.POST, 
                    requestEntity, BaseResult.class);
            String reImgUrl = res.getBody().getData().toString();//返回的在线地址
            return res.getBody();

要记得将restTemplate添加到Bean中：

@Configuration
    public class ConfigBean {
       
         //@Configuration 相当于 spring中的 application.xml
    
        @Bean
        RestTemplate restTemplate(){
       
        
            return new RestTemplate();
        }
    }

ajax:

var ip = "ip+端口号";
                $.ajax({
       
        
                    url: ip,
                    data: formData,
                    dataType: "json",
                    type: "post",
                    success: function(data) {
       
        
                        console.log(data)
                    }
                });

axios：

python：

import requests
    
      headers2 = {
       
        'Content-Type': 'application/json'}
      data = {
       
        "name": "ninesun", "age": 21}
      r = requests.post('http://localhost:3010/v1/carstatistic-3003/carInfo/countCarInfo', headers=headers2,json=data,verify=False)
      r.headers
      print(r.text)

### 1.26 equals == 区别 ###

equals方法对于字符串来说是比较内容的，而对于非字符串来说是比较其指向的对象是否相同的。

== 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。

String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以是true。

对于基本类型的包装类型，比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量，==是比较地址的，而equals是比较内容的。

### 1.27 Java中线程不安全的原因 ###

首先什么是线程安全，线程安全就是多个线程修改同一个变量的时候，修改的结果需要和单线程修改的结果相同。如果修改的结果和预期不符，那就是线程不安全。导致线程不安全的原因有：

1.抢占式执行，这取决于cpu的调度，我们没有权力去改变。

2.多个线程修改同一个变量，注意，这里是同一个变量，通过上面这个图我们看的出来，当线程1在读一个数据的时候，线程2也可能读了原本的数据。在线程1保存之后，线程2还是修改的原来读的值，再进行保存，然后就会覆盖掉线程1修改的值，所以我们本来期望a这个变量是自增两次，但是到最后只自增了一次，与预期结果不符。多线程修改同一个变量这是我们可以改变的，只要我们不修改同一个变量，那每个线程自己干自己的事情，就不会导致线程不安全。

3.原子性，原子性就是这个操作不可以进行拆分，要么全部都执行，要么全部不执行，不能在被执行一半的时候被中断。上面举的例子a++这个操作就是可以拆分的操作，首先需要先读取a的值，再进行++操作，然后给a赋值，所以a++这个操作不是原子性操作，但是如果我们只是读一个或者单纯的赋值操作那就是原子性操作。上面的图就是因为a++这个操作不是原子性，然后线程间抢占式执行带来的结果。所以但是我们保证了操作的原子性，还是会发生线程不安全

4.内存可见性，是指一个线程的操作对于另一个线程来说是可以见的，称为内存可见性，就像上面的图，线程1进行a++这个操作，然后线程2在线程1进行a++之后，读的值并不是a++之后的值，而是原本的值，线程1 a++这个操作对于线程2是不可见的，所以他们不存在内存可见性。

5.指令重排序，指令重排序是编译器自己优化的结果，我们写的代码执行的顺序，可能不是书写的顺序，编译器会自动优化这个代码的顺序，可能会导致线程不安全。

### 1.28 包装类和基本数据类型区别？为什么有包装类？ ###

在Java中，new的对象存储在堆里，通过栈中的引用来使用这些对象；但是对经常用到的一系列类型如int，如果我们用new将其存储在堆里就不是很有效——特别是简单的小的变量。所以就出现了基本类型，同C++一样，Java采用了相似的做法，对于这些类型不是用new关键字来创建，而是**直接将变量的值存储在栈中**，因此更加高效。

有了基本类型为啥还要有包装类型？

Java是一个面向对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基

[ba4bfc6c068445b5bd24843f378be839.png_pic_center]: https://img-blog.csdnimg.cn/ba4bfc6c068445b5bd24843f378be839.png#pic_center
[format_png]: https://img-blog.csdnimg.cn/img_convert/d3e8d33cdb515d23dcf84ddd19550815.webp?x-oss-process=image/format,png
[Map_HashMap]: https://blog.csdn.net/zhiyikeji/article/details/124717489
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpeXVlNTIx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210706212620814.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpeXVlNTIx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpeXVlNTIx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210706212808962.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpeXVlNTIx,size_16,color_FFFFFF,t_70
[ConcurrentHashMap]: https://blog.csdn.net/zhiyikeji/article/details/126453116?spm=1001.2014.3001.5501
[f1e8339a98094a13a4b29e5e10edbdfd.png_pic_center]: https://img-blog.csdnimg.cn/f1e8339a98094a13a4b29e5e10edbdfd.png#pic_center
[09e99876fbe6409492ec5f10aab71cdc.png_pic_center]: https://img-blog.csdnimg.cn/09e99876fbe6409492ec5f10aab71cdc.png#pic_center
[3dfdcf32e3ca4c8a924f4f6358223b3c.png_pic_center]: https://img-blog.csdnimg.cn/3dfdcf32e3ca4c8a924f4f6358223b3c.png#pic_center
[https_blog.csdn.net_zhiyikeji_article_details_126547155_spm_1001.2014.3001.5501]: https://blog.csdn.net/zhiyikeji/article/details/126547155?spm=1001.2014.3001.5501
[https_blog.csdn.net_zhiyikeji_article_details_125922970_spm_1001.2014.3001.5501]: https://blog.csdn.net/zhiyikeji/article/details/125922970?spm=1001.2014.3001.5501
[https_blog.csdn.net_zhiyikeji_article_details_125883773_spm_1001.2014.3001.5501]: https://blog.csdn.net/zhiyikeji/article/details/125883773?spm=1001.2014.3001.5501
[https_blog.csdn.net_zhiyikeji_article_details_124717489_spm_1001.2014.3001.5501]: https://blog.csdn.net/zhiyikeji/article/details/124717489?spm=1001.2014.3001.5501
[https_blog.csdn.net_zhiyikeji_article_details_123200038_spm_1001.2014.3001.5501]: https://blog.csdn.net/zhiyikeji/article/details/123200038?spm=1001.2014.3001.5501