分享一波中高级测试面试题（偏Java）

dubbo协议介绍下

Dubbo是一款高性能、轻量级的开源RPC框架，支持多种协议，其中之一就是Dubbo协议。

Dubbo协议是一种基于TCP的高性能传输协议，它是Dubbo框架默认的传输协议。Dubbo协议采用了一种自定义的数据传输格式，采用简单的消息头和消息体结构，实现了较高的传输效率和性能。

Dubbo协议的消息格式主要包括三部分：

Header：消息头，包含了消息的长度、协议版本、序列化方式、消息类型、消息ID等信息。
Body：消息体，包含了需要传输的数据。
EndFlag：消息结束标志，表示一条消息传输结束。

Dubbo协议还支持多种序列化方式，如Java原生序列化、Hessian、JSON、XML等，用户可以根据自己的需要选择合适的序列化方式。

Dubbo协议具有以下特点：

高性能：Dubbo协议采用了自定义的传输格式，实现了较高的传输效率和性能。
支持多种序列化方式：Dubbo协议支持多种序列化方式，可以根据需要选择合适的序列化方式。
支持心跳机制：Dubbo协议支持心跳机制，可以检测连接的健康状态，保证通信的稳定性。
支持双向通信：Dubbo协议支持双向通信，可以实现客户端和服务端之间的双向通信。
支持多种传输协议：Dubbo框架支持多种传输协议，如Dubbo协议、HTTP协议、Hessian协议等，可以根据需要选择合适的传输协议。

rpc，tcp的异同点是什么

RPC（Remote Procedure Call）和TCP（Transmission Control Protocol）是两个不同的概念，它们之间有以下的异同点：

相同点：

都是计算机网络中常用的通信协议，用于实现网络通信；
都是基于客户端/服务器模型，通过请求和响应进行通信。

不同点：

RPC是一种远程过程调用协议，用于实现分布式系统中的服务调用，而TCP是一种传输层协议，用于实现网络数据传输；
RPC通常基于TCP或其他传输层协议实现，用于数据的传输，而TCP则是一种具体的传输层协议；
RPC通常使用自定义的协议格式进行数据的编码和解码，而TCP则采用标准的协议格式；
RPC的调用过程比TCP复杂，包括服务发现、服务注册、负载均衡等，而TCP则是一种简单的通信协议，只涉及到建立连接、数据传输和断开连接。

总的来说，RPC和TCP是两个不同的概念，RPC是一种应用层协议，TCP是一种传输层协议。RPC通常基于TCP实现数据传输，但它包含了更多的功能，如服务发现、服务注册、负载均衡等。而TCP则是一种简单的通信协议，只负责建立连接、传输数据和断开连接。

冒泡排序

void bubbleSort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++) {
// 内层循环从后往前比较相邻元素
for (j = n - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
// 如果相邻元素顺序错误，则交换它们的位置
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}

冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。虽然冒泡排序的效率较低，但是它的思路简单，代码易于实现和理解，因此在某些特殊情况下，仍然具有一定的实用价值。

斐波那契数列

public static int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}

1000以内水仙花数等的算法编写

public static void findNarcissisticNumber() {
for (int i = 100; i <= 999; i++) {
int sum = 0;
int temp = i;
while (temp != 0) {
int digit = temp % 10;
sum += Math.pow(digit, 3);
temp /= 10;
}
if (sum == i) {
System.out.print(i + " ");
}
}
}

在这个代码中，我们遍历了所有 3 位数，对于每个数，我们通过除以 10 和取余数的方式逐位计算它的各位数字的立方和，并与原数进行比较。如果它们相等，就说明这个数是一个水仙花数，我们就把它输出出来。

需要注意的是，这个算法的时间复杂度为 O(nm)，其中 n 表示数的位数，m 表示数的范围（1000）。因此，它的时间复杂度是比较低的，可以在短时间内求解出 1000 以内的所有水仙花数。

内存溢出和内存泄漏的区别

内存溢出和内存泄漏都是与内存管理有关的问题，但它们的含义不同。

内存溢出（Memory Overflow）指的是程序在申请内存时，请求的内存超出了系统所能提供的最大内存限制，导致内存分配失败的情况。通常情况下，内存溢出会导致程序异常终止或者崩溃。内存溢出的主要原因是程序中存在内存泄漏，或者程序本身占用内存过大。

内存泄漏（Memory Leak）指的是程序中已经不再使用的内存空间，因为程序未能将其释放，导致这些内存空间无法再被其他程序所使用。随着程序运行时间的增长，内存泄漏会导致系统的内存资源越来越紧张，最终会导致系统崩溃或者异常终止。内存泄漏通常是由于程序中存在逻辑错误或者编程不当所导致的。

可以用一个简单的比喻来理解内存溢出和内存泄漏的区别：内存溢出就像水桶装水太满而导致溢出，而内存泄漏则像是一个有漏洞的水桶，会不断地流失水。

为了避免内存溢出和内存泄漏问题的发生，程序员需要遵循一些内存管理的最佳实践，例如及时释放不再使用的内存空间，避免循环引用，使用缓存等等。同时，开发人员也可以使用一些工具来帮助发现和解决内存溢出和内存泄漏问题，例如 Java 中的内存分析工具（如 Eclipse Memory Analyzer）和代码检查工具（如 FindBugs）。

java中常用的锁的含义，乐观锁与悲观锁，阻塞锁和非阻塞锁等

Java 中常用的锁包括 synchronized、ReentrantLock、ReadWriteLock、StampedLock 等。这些锁主要用于保证多线程环境下的线程安全性。

悲观锁和乐观锁是两种常见的锁思想。悲观锁认为数据在并发情况下随时会被其他线程修改，因此每次操作都要先加锁，以保证数据的一致性。常见的悲观锁包括 synchronized 和 ReentrantLock。而乐观锁则认为数据在并发情况下很少会被修改，因此不加锁，而是在修改前先检查数据是否被其他线程修改过，如果没有就执行修改操作，否则就回滚并重试。常见的乐观锁实现方式包括 CAS（Compare and Swap）和版本号控制等。

阻塞锁和非阻塞锁是两种常见的锁模式。阻塞锁会在获取锁时，如果锁已经被其他线程占用，则当前线程会进入等待状态，直到获取到锁才能继续执行。常见的阻塞锁包括 synchronized 和 ReentrantLock。而非阻塞锁则不会让线程进入等待状态，而是立即返回失败信息，让线程可以继续执行其他任务，常见的非阻塞锁包括 CAS 等。

总的来说，Java 中的锁机制包括了多种不同的锁类型和锁思想，可以根据实际需求选择不同的锁机制来保证程序的线程安全性。同时，在使用锁时需要注意避免死锁等问题，确保程序的正常运行。

集合与数组的区别是什么

数据类型：数组可以存储任何类型的数据，包括基本数据类型和对象类型，而集合只能存储对象类型的数据。
大小：数组的大小在创建时就已经确定，不能动态增加或减少，而集合的大小是可以动态增加或减少的。
增删元素：对于数组，如果要增加或删除元素，需要重新创建一个新的数组，并将原数组的元素复制到新数组中；而集合可以直接调用相应的方法进行添加或删除操作。
遍历方式：数组可以使用 for 循环或者增强 for 循环进行遍历，而集合可以使用迭代器、foreach 循环等方式进行遍历。
检索方式：对于数组，可以使用下标直接访问元素，而集合需要使用相应的方法进行访问。

总的来说，数组和集合都有各自的优势和适用场景。数组适合于存储固定大小的数据，可以直接访问元素，效率较高；而集合适合于存储动态大小的数据，提供了更多的操作方法，方便进行增删改查等操作。

map的常见实现类有什么,分别有啥区别

在 Java 中，常见的 Map 实现类有 HashMap、TreeMap、LinkedHashMap、ConcurrentHashMap 等。

HashMap：基于哈希表实现，可以快速插入、删除、查找元素。具有 O(1) 的时间复杂度。HashMap 不保证元素的顺序，因为元素的插入顺序不一定与哈希值的顺序相同。HashMap 允许存储 null 键和 null 值。
TreeMap：基于红黑树实现，元素按照键值的顺序排序。因为基于树结构，所以查找元素的时间复杂度为 O(log n)。TreeMap 不允许存储 null 键，但可以存储 null 值。
LinkedHashMap：基于哈希表实现，具有 HashMap 的所有特性，同时还保留了元素的插入顺序。因为需要维护插入顺序，所以相比于 HashMap，LinkedHashMap 需要额外维护一个双向链表，所以空间复杂度略高于 HashMap。LinkedHashMap 允许存储 null 键和 null 值。
ConcurrentHashMap：与 HashMap 类似，但是是线程安全的。ConcurrentHashMap 内部采用分段锁实现，并发性能更好。ConcurrentHashMap 不保证元素的顺序，也允许存储 null 键和 null 值。

在选择 Map 实现类时，需要根据实际需求来进行选择。如果不需要保证顺序，且对并发性能要求不高，可以选择 HashMap；如果需要保证顺序，可以选择 TreeMap 或 LinkedHashMap；如果需要在多线程环境下使用，可以选择 ConcurrentHashMap。

多线程怎么实现的，常用的线程池有哪几个

多线程实现主要有两种方式：继承 Thread 类和实现 Runnable 接口。具体来说，继承 Thread 类需要重写 run 方法，在 run 方法中实现需要并发执行的代码逻辑；实现 Runnable 接口需要实现 run 方法，将需要并发执行的代码逻辑写在其中，然后将实现了 Runnable 接口的类实例作为参数传递给 Thread 类的构造函数。

在实际开发中，由于 Thread 类的单继承限制以及 Runnable 接口更符合面向对象的设计思想，一般采用实现 Runnable 接口的方式实现多线程。

常用的线程池有以下几个：

FixedThreadPool：线程数固定的线程池。线程数被固定时，无论空闲与否，都会一直存在。
CachedThreadPool：线程数不固定的线程池。如果线程池的线程都处于活动状态，那么新来的任务就会等待，否则就会创建新的线程来处理任务。
SingleThreadExecutor：单线程的线程池。线程池中只有一个线程，保证所有任务按照指定的顺序执行。
ScheduledThreadPool：可以执行定时或周期性任务的线程池。

线程池的使用可以有效地避免线程创建和销毁的开销，提高程序的并发性能。根据实际需求，选择合适的线程池可以更好地利用系统资源，提高程序的性能和可靠性。

final,finally,finalize的区别

final 是一个关键字，可以用来修饰类、方法和变量。final 修饰的类不能被继承，final 修饰的方法不能被重写，final 修饰的变量是一个常量，只能被赋值一次，一旦被赋值后就不能再被修改。
finally 是一个关键字，用于定义在 try-catch 代码块的末尾，无论异常是否发生，都会执行 finally 代码块中的代码。通常在 finally 中进行清理工作，比如关闭文件流等。
finalize 是一个方法名，是 Object 类中的一个方法，被用于在垃圾回收器将对象从内存中清除之前调用。该方法通常被子类重写以实现资源释放和清理工作，但由于 finalize 方法的调用不可预测且开销较大，因此不建议过多地使用。

综上所述，final 是一个关键字，用于修饰类、方法和变量；finally 是一个关键字，用于定义在 try-catch 代码块的末尾，无论异常是否发生都会执行；finalize 是 Object 类中的一个方法，被用于在垃圾回收器将对象从内存中清除之前调用。

队列与栈的区别是什么

队列和栈都是常见的数据结构，其主要区别在于数据的插入和删除方式以及数据的访问顺序。

队列（Queue）是一种先进先出（First-In-First-Out，FIFO）的数据结构，即数据从队列的一端进入，从另一端出去，如同排队一样。队列的插入操作叫做入队（enqueue），删除操作叫做出队（dequeue）。

栈（Stack）是一种后进先出（Last-In-First-Out，LIFO）的数据结构，即数据的插入和删除都在栈的同一端进行，如同叠盘子一样。栈的插入操作叫做压栈（push），删除操作叫做弹栈（pop）。

因此，队列和栈主要区别在于数据的插入和删除方式。队列的插入和删除都分别在队列的两端进行，而栈的插入和删除都在栈的同一端进行。另外，队列的访问顺序是先进先出，栈的访问顺序是后进先出。

在实际应用中，队列和栈都有广泛的应用。例如，在计算机的操作系统中，队列被用来实现进程的调度和消息传递，而栈则被用来实现函数的调用和系统调用的嵌套。

spring常用注解有什么，举例@Autowired与@bean的区别

Spring 是一个基于 IoC 和 AOP 的框架，使用注解可以方便地进行依赖注入和对象创建。常用的 Spring 注解包括：

@Autowired：自动装配依赖对象，可用于构造方法、属性和方法上。与 @Qualifier 注解一起使用，可以指定具体的依赖对象。
@Bean：声明一个 Spring 管理的 Bean 对象，可用于方法上。默认情况下，方法名即为 Bean 的名称，也可以通过 @Qualifier 注解指定名称。
@Configuration：声明一个配置类，其中包含 Bean 的定义和依赖注入的配置。通常与 @Bean 注解一起使用。
@Component：声明一个组件类，即可被 Spring 管理的 Bean 对象。通常与 @Autowired 注解一起使用。
@Controller、@Service 和 @Repository：分别声明一个控制器、服务和数据访问对象（DAO），是 @Component 注解的特化。可用于 Bean 的分类和区分。
@Scope：指定 Bean 的作用域，包括 singleton、prototype、request、session 和 global session 等。默认为 singleton。
@Value：注入配置文件中的属性值，可用于构造方法、属性和方法上。通常与 @PropertySource 注解一起使用。

举例说明 @Autowired 和 @Bean 的区别：

@Autowired 注解是自动装配依赖对象，可以直接将一个对象注入到另一个对象中，无需显式创建。例如，可以将一个 DAO 对象注入到一个 Service 对象中，然后将 Service 对象注入到一个控制器中，实现依赖注入的功能。

@Bea n 注解是声明一个 Bean 对象，通常用于配置类中的方法上，可以显式创建一个对象并将其加入到 Spring 的容器中。例如，可以声明一个 DataSource 对象并将其加入到 Spring 的容器中，然后在其他对象中引用该对象，实现对象的复用和管理。

因此，@Autowired 注解和 @Bean 注解的主要区别在于，前者是自动装配依赖对象，后者是显式声明并创建一个 Bean 对象。通常情况下，@Autowired 注解适用于依赖注入的场景，@Bean 注解适用于显式声明和管理 Bean 对象的场景。

HashSet与TreeSet和LinkedHashSet的异同

HashSet、TreeSet 和 LinkedHashSet 都是 Java 中常见的集合类，它们的主要区别在于底层数据结构、元素排序方式和性能特点等方面。

HashSet：底层数据结构为哈希表，基于哈希值实现元素的快速查找，元素的存储顺序是无序的。由于哈希冲突的存在，需要通过 equals() 方法比较元素是否相等。HashSet 的添加、删除和查找操作的时间复杂度都为 O(1)，是一种性能较优的集合。

TreeSet：底层数据结构为红黑树，基于元素的自然顺序或者指定的比较器实现元素的排序，元素的存储顺序是有序的。TreeSet 的添加、删除和查找操作的时间复杂度都为 O(log n)，适用于需要对元素进行排序的场景。

LinkedHashSet：底层数据结构为哈希表和链表，基于哈希值实现元素的快速查找，并维护元素的插入顺序，元素的存储顺序是有序的。LinkedHashSet 的添加、删除和查找操作的时间复杂度都为 O(1)，并且支持按照插入顺序或者访问顺序进行遍历，是一种性能较优且具有顺序特性的集合。

总之，HashSet 是一种无序且性能较优的集合，适用于需要快速查找元素的场景；TreeSet 是一种有序且适用于排序的集合，适用于需要按照自然顺序或者指定的比较器对元素进行排序的场景；LinkedHashSet 是一种有序且性能较优的集合，适用于需要保持插入顺序或者访问顺序的场景

后端通信方式有几种，同步请求与异步请求分别是通过什么技术实现的

后端通信方式一般有两种：同步请求和异步请求。

同步请求：客户端发送请求到服务器端，等待服务器端的响应，直到服务器端响应完成后才会返回响应结果。同步请求一般使用阻塞 IO 的方式实现，即客户端向服务器端发送请求后，线程会一直阻塞等待服务器端的响应，直到响应完成后才会解除阻塞。

异步请求：客户端发送请求到服务器端后不会等待服务器端的响应，而是继续执行其他任务。当服务器端响应完成后，再通知客户端响应已经完成，客户端再获取响应结果。异步请求一般使用非阻塞 IO 的方式实现，即客户端向服务器端发送请求后不会阻塞等待服务器端的响应，而是继续执行其他任务，等服务器端响应完成后再通过回调或者轮询等方式获取响应结果。

同步请求和异步请求都有各自的优缺点，适用于不同的场景。同步请求相对简单，但会阻塞线程，对系统性能有一定的影响；异步请求可以提高系统的并发能力和吞吐量，但相对复杂一些，需要使用回调、轮询等技术实现。选择使用哪种通信方式，需要根据实际情况进行综合考虑。

感谢每一个认真阅读我文章的人，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走：