java面试基础常问总结

它1.8之前是数组+链表，1.8后数组+链表/红黑树的数据结构，主体还是数组（Java7叫Entry在Java8中叫Node），数组每个地方都存有key-value这样的实例，当put一个值时，会通过哈希函数计算出插入的位置，再进行保存。而链表的存在是为了解决哈希冲突，因为哈希本身就存在概率性，再好的哈希函数都可能会出现哈希冲突，所以当出现哈希冲突到同一个存储地址值上，就形成了链表，index指向下一个节点，形成一个单链表。1.8之后当链表长度达到8会变成红黑树

红黑树？

1.8前是头插法，新来的值会取代原来的值，原来的值会顺推到链表中去，作者认为后来的值被查找性更大，提高效率

1.8之后都是尾插法，1、为了解决并发情况下出现的闭环造成死循环

负载因子默认为0.75

就比如当我们容量为100，当存入第76个判断发现需要进行resize，就需要进行扩容

1.7扩容步骤

1.8扩容

为什么重新Hash？

1.7先并发情况下会出现死循环或者数据丢失问题

1.8并发情况下会出现数据覆盖问题

在对table进行扩容到newTable后，会将数据转移到newTable中，转移使用的是头插法，也就是链表的顺序会翻转，这里是形成死循环的关键点

是线程安全的map结构，它的核心思想是分段锁。在1.7的时候，内部维护了segment数组，默认是16个，可以同时16个线程操作，segment继承了reentrantlock使用了互斥锁。而在1.8做了大改动，废除了segment，采用了cas +synchronize方式进行分段锁（还有自旋锁保证），而且节点对象也由HashEntiry改为Node。node支持链表和红黑树的转换。

1.7

1.8

先计算出hash值，根据hash值选出Node数组下标，（默认数组是空的，所以一开始put的时候会初始化，指定负载因子0.75，不可变

接着判断是否为空，如果空，则用cas的操作来赋值首节点，如果失败，则因为自旋，会进入非空节点的逻辑。

这时候会用synchronize加锁头节点（保证整条链路锁定）

这时候还会进行二次判断，是否同一个首节点，在分首节点到底是链表还是树结构，进行遍历判断

文件传输（FTP HTTP 对数据准确性要求高，速度可以相对慢）

发送或接收邮件（POP IMAP SMTP 对数据准确性要求高，非紧急应用）

远程登录（TELNET SSH 对数据准确性有一定要求，有连接的概念）

即时通信（QQ聊天 对数据准确性和丢包要求比较低，但速度必须快）

在线视频（RTSP 速度一定要快，保证视频连续，但是偶尔花了一个图像帧，人们还是能接受的）

网络语音电话（VoIP 语音数据包一般比较小，需要高速发送，偶尔断音或串音也没有问题）

请求成功

永久重定向

暂时重定向

客户端请求语法错误，服务端无法理解

未授权

服务端拒绝执行此访问（跨域）

未找到资源

服务器错误

网关错误

服务端未启动或未找到

向特定资源发送请求，查询数据，并返回实体

向指定资源提交数据进行处理请求，可能会导致新的资源建立、已有资源修改

向服务器上传新的内容

类似GET请求，返回的响应中没有具体的内容，用于获取报头

请求服务器删除指定标识的资源

可以用来向服务器发送请求来测试服务器的功能性

回显服务器收到的请求，用于测试或诊断

HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器

操作具体步骤：https://mp.weixin.qq.com/s/1M4n7G_KTUOGXfPqtHVU3w

其实就是先给Nginx1.18以上的版本安装这个模块，可以下载国外的ip库，放到服务器，接着根据配置文件访问判断访问的ip是否是国外的，如果是直接返回404即可

有序性

可见性

原子性

可重入性

修饰实例方法

修饰静态方法

修饰代码块

Spring实现事物隔离，使用Threadlocal的方式来保证单个线程中的数据库操作使用的是同一个数据库连接，同时采用这种方式可以使业务层使用事务时不需要感知并管理connection对象，通过传播级别，巧妙地管理多个事务配置之前的切换。

很多场景下的cookie、session等数据隔离都是通过ThreadLocal去做实现的。

在我们的系统里面我们常常使用了ThreadLocal类型参数进行存储租户信息，对于线程进行了数据隔离

初始化一个可以泛型的ThreadLocal对象，之后这个线程只要在remove()之前去get，都可以拿到之前set的值。做到了线程隔离，所以其他线程无法拿到其他的值。

每个线程Thread都维护了自己的threadLocals变量，所以每个线程创建ThreadLocal的时候，实际上数据都是存在自己的线程Thread的threadLocals变量里面的，别人没有办法拿到，从而实现了隔离。

在java中，栈内存是每个线程都存在的，栈内存可以理解为每个线程的私有空间，其存储的变量只属于自己线程。但是Threandlocal并不是将值放在栈内存中，ThreadLocal的值其实是被线程实例持有，它们都是位于堆上的，只是通过一些技巧将其修改成了线程可见，我记得是通过复制出n份数据出来给每个线程一份来实现。

继承了ThreadLocal，并重写了chilValue、getMap、createMap，对该类的操作实际是对线程ThreadLocalMap的操作。子线程能够读取父线程的数据，实际原因是新建子线程的时候会从父线程copy数据

在ThreadLocal没有外部强引用的时候，发生GC会被回收，如果创建ThreadLocal的线程一直处于持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄漏。垃圾回收优先级很低得线程，因此不一定很快发现弱引用的对象。

在代码最后使用remove（）清空就好了。

重复利用已经创建的线程降低线程创建和销毁造成的资源消耗

当任务到达时，任务不需要等到线程创建就可以立即执行

可以通过设置何立分配、调优、监控

核心线程池大小

线程池最大数

线程保持活动时间

keepAliceTime线程保持活动时间单位

任务队列

设置创建线程的工厂

饱和策略也叫拒绝策略

该任务需要大量的运算时候，没有阻塞，需要高速运算，这时需要的线程数较少，可以设置cup数+1

当任务不需要一直运算的时候，可以多分配一些线程数，如cup数*2

在程序中操作系统会给每个线程分配属于它自己的内存空间，称为栈内存

使用TheanLocal创建的变量，每个线程在运行时都会拷贝一份存储在自己本地。这些ThreadLocal数据是属于Thread类的成员变量级别的，从所在“位置”的角度来讲，这些ThreadLocal数据是分配在公共区域的堆内存中的。就是把堆内存中的一个数据复制成N份，每个线程认领一份。

在参数添加final，这样所以线程都动不了这个参数。只能读不能修改

如果公共区域（堆内存）的数据，要被多个线程操作时，确保数据的安全性或一致性，需要在数据旁边加一把锁，要想操作数据，需要先获取一把锁。

因为锁的获取和释放是要花费一定的代价，如果在线程数目特别少的时候，可能根本就不会有别的线程来操作数据，此时你还要获取锁和释放锁，可以说就是一种浪费。

新建线程对象，没有调用start（）方法前

抵用start方法后进入就绪状态，线程再睡眠和挂起中恢复的时候都会进入就绪状态

线程被设置为当前线程，开始执行run（）方法，就是线程进入运行状态

线程被暂停，比如说调用sleep（）后线程进入阻塞状态

线程执行结束

是指多个线程申请锁是按照顺序来获取锁的

是指不按照顺序申请来获取锁的，会造成优先级反转或者饥饿现象

只该锁只能一次只能一个线程所持有

只锁可被多个线程所持有

子主题

实现序列化通过实现Serializable即可

实现数据持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里）Redis的RDB

也可以利用序列化实现远程通信，即在网络上传送对象的字节序列。 Google的protoBuf

JDK原生

JSON

ProtoBuf

Hession

Kryo 等

考虑三个方面

java里面万事万物都是对象，但是有例外就是8个基本数据类型不是对象，因此会很不方便，所以对基本数据类型提供了对应的包装类

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

成员变量在类体内部，方法体外面
局部变量在方法体内部

成员变量的作用范围是整个类
局部变量的作用范围是方法体

   成员变量有默认值
局部变量没有默认值   

成员变量：位于堆内存
局部变量：位于栈内存

局部变量：随着方法进栈而诞生，出栈而消亡
成员变量：睡着对象创建而诞生，GC回收而消亡

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

因为实例对象是属于某个对象，而静态方法在执行的时候不一定有对象，所有不能使用实例对象，也不能使用this

其实真的原因是：JVM加载类的时，就会执行该static，静态优先于其他产生对象产生，就是satic调用非静态时并未产生对象，所有this不代表任何对象为null，未进行初始化操作

利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一格对象中都存储一份。可以直接被类名调用。

弊：生命周期过长，访问出现局限性（静态虽好，只能访问静态）

如果你正在编写实用程序类，则不应更改它们。
如果该方法未使用任何实例变量。
如果有任何操作不依赖于实例创建。
如果某些代码可以被所有实例方法轻松共享，则将该代码提取到静态方法中。
如果你确定该方法的定义永远不会更改或覆盖。由于静态方法不能被覆盖。

1、什么时候使用静态的成员属性：
当属于同一个类的所有对象出现共享数据时，需要将存储这个共享数据的成员变量用static修饰
2、什么时候使用静态的成员方法：
当功能内部没有访问到非静态的成员时（对象特有的数据），那么该功能可以定义成静态的。

==

equals

hashCode

如果两个对象相等，则 hashcode 一定也是相同的。两个对象相等,对两个对象分别调用 equals 方法都返回 true。但是，两个对象有相同的 hashcode 值，它们也不一定是相等的 。因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖。

hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

因为 hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode。
我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。

final可以用来修饰类，方法和变量（成员变量或局部变量）

修饰方法，把方法锁定，以防止继承类对其进行更改。

当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的

作为异常的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。

finally特殊情况也不一定执行：如对应的try语句块正常执行finally语块才执行。try中执行System.exit(0)语句，终止了虚拟机运行也不会运行

Object下的一个方法，这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。

特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。

int是java基本数据类型，Integer是int的包装类

Integer变量必须实例化之后才能使用，而int变量不需要实例化

Integer实际是对象的引用，生成一个指针指向对象，而int直接存数值

Integer默认值是null，int默认值是0

new两个Integer对象判断地址结构都是false

int i = new Integer(100); 与 Integer j = new Integer(100)； j会自动拆箱，i与j进行值的比较，返回false

Integer i = 100；与 Integer j = new Integer(100)；i指向的是java常量池中的对象，而j new出来的对象指向堆新建对象，两个地址不一致返回false

Integer i = 100；与 Integer j = 100；当值在-127~128之前会进行拆箱就是值进行比较

方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的是原始值的一个copy，此时内存中存在两个相等的基本类型，即实际参数和形式参数，后面方法中的操作都是对形参这个值的修改，不影响实际参数的值。

也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，函数接收的是原始值的内存地址；
在方法执行中，形参和实参内容相同，指向同一块内存地址，方法执行中对引用的操作将会影响到实际对象。

（1）基本数据类型传值，对形参的修改不会影响实参；
（2）引用类型传引用，形参和实参指向同一个内存地址（同一个对象），所以对参数的修改会影响到实际的对象；
（3）String, Integer, Double等immutable的类型特殊处理，可以理解为传值，最后的操作不会修改实参对象。

对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

强引用

弱引用

软引用

虚引用

浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。

深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

面向过程性能比面向对象高，因为类阿紫调用时需要实例化，开销比较大，比较消耗资源，所以一般性能是重要的考量因素的时候，比如单片机，嵌入式开发、liunx等都采用的是面向过程开发。但是面向过程没有面向对象易于维护、复用、扩展

面向对象易于维护、易于复用、易于扩展

没有足够的内存可以使用

内存中加载的数据量过于庞大，如一次从数据库中取出过多数据

集合类中有对对象的引用，使用完后未清理，使得jVM不能回收

代码中存在死循环或循环产生或多重复的对象实体

启动参数内存值设定得过小

强引用对象没有释放使用的内存空间，长时间的堆积造成

实现方式不同：

根本原因，实现方式

触发时机不同：

作用域

所谓过滤器顾名思义是用来过滤的，Java的过滤器能够为我们提供系统级别的过滤，也就是说，能过滤所有的web请求，这一点，是拦截器无法做到的。在Java Web中，你传入request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉）,或者在传入servlet或者struts的action前统一设置字符集，或者去除掉一些非法字符（聊天室经常用到的，一些骂人的话）。filter 流程是线性的，url传来之后，检查之后，可保持原来的流程继续向下执行，被下一个filter, servlet接收。

ava里的拦截器提供的是非系统级别的拦截，也就是说，就覆盖面来说，拦截器不如过滤器强大，但是更有针对性。Java中的拦截器是基于Java反射机制实现的，更准确的划分，应该是基于JDK实现的动态代理。它依赖于具体的接口，在运行期间动态生成字节码。拦截器是动态拦截Action调用的对象，它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码，也可以在一个Action执行前阻止其执行，同时也提供了一种可以提取Action中可重用部分代码的方式。在AOP中，拦截器用于在某个方法或者字段被访问之前，进行拦截然后再之前或者之后加入某些操作。java的拦截器主要是用在插件上，扩展件上比如 Hibernate Spring Struts2等，有点类似面向切片的技术，在用之前先要在配置文件即xml，文件里声明一段的那个东西。

Java的监听器，也是系统级别的监听。监听器随web应用的启动而启动。Java的监听器在c/s模式里面经常用到，它会对特定的事件产生产生一个处理。监听在很多模式下用到，比如说观察者模式，就是一个使用监听器来实现的，在比如统计网站的在线人数。又比如struts2可以用监听来启动。Servlet监听器用于监听一些重要事件的发生，监听器对象可以在事情发生前、发生后可以做一些必要的处理。

去重：是对请求或者消息一定时间内多次请求去重

幂等：则是保证请求或者消息在任意时间内进行处理，都需要保证他的结果一致性

子主题

是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且都能够调用它的任意一个方法；

反射首先是能够获取到Java中的反射类的字节码，然后将字节码中的方法，变量，构造函数等映射成 相应的 Method、Filed、Constructor 等类

1.类名.class(就是一份字节码)
2.Class.forName(String className);根据一个类的全限定名来构建Class对象
3.每一个对象多有getClass()方法:obj.getClass();返回对象的真实类型

开发通用框架

动态代理 

JDK

自定义注解

封装

继承

多态

父类throwable

算术异常

类转换异常

非法参数异常

下表越界异常

空指针异常

安全异常

？可以表示成占位符，它自己也不知道list集合中会存放多少种类型的数据，所以这样就表明我们的list中存放N种数据类型也是可以的。

泛型的本质是参数化类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

Java的泛型是伪泛型，使用泛型的时候加上类型参数，在编译器编译生成的字节码的时候会去掉，这个过程成为类型擦除。

如List<String>等类型，在编译之后都会变成 List。JVM 看到的只是 List，而由泛型附加的类型信息对 JVM 来说是不可见的。

可以通过反射添加其他类型元素

java类加载器负责将编译好的class 文件加载到 Java 虚拟机（JVM）中的运行时数据区中，供执行引擎调用

是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。

系统设计的各个抽象，往往有很多不同的实现方案，在面向的对象的设计里，一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制。

Java SPI就是提供这样的一个机制：为某个接口寻找服务实现的机制。有点类似IOC的思想，就是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。所以SPI的核心思想就是解耦。

数据库驱动加载接口实现类的加载，JDBC加载不同类型数据库的驱动

SLF4J加载不同提供商的日志实现类

Spring中大量使用了SPI,比如：对servlet3.0规范对ServletContainerInitializer的实现、自动类型转换Type Conversion SPI(Converter SPI、Formatter SPI)等

Dubbo中也大量使用SPI的方式实现框架的扩展, 不过它对Java提供的原生SPI做了封装，允许用户扩展实现Filter接口

1、当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名；
2、接口实现类所在的jar包放在主程序的classpath中；
3、主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；
4、SPI的实现类必须携带一个不带参数的构造方法；

区别

StringBuilder底层

String str =“abc”过程

String str = new String("abc") 过程

String底层原理？

String如何保证不变？

使用+连接符拼接String字符串的原理是什么？

用常量对String赋值和对String new的区别？

字符串常量池在那里

Object（）

registerNatives

clone（）

getClass（）

equals（）

hashCode（）

toString（）

wait（）

wait（long tieout）

wait（long tieout，int nanos）

notify（）

notifyAll（）

finalize（）

类图、对象图、实例联系图

系统图、功能图、项目结构图、部署图

流程图

时序图

状态图