Java面试题（持续更新）

io无心

已于 2024-02-29 23:11:39 修改

阅读量418

点赞数 1

文章标签： java 开发语言

于 2023-10-17 14:39:15 首次发布

需转载请联系QQ:846581636

本文链接：https://blog.csdn.net/LYXlyxll/article/details/133210319

版权

Java基础篇

修饰权限符

public: 可以被任何其他类访问。如果一个类是public的，那么你可以从任何其他类中访问它。
protected: 可以被同一包内的任何类访问。可以被不同包中的子类访问。但是，它不能被其他不同包中的非子类访问。
(default) package-private (没有修饰符):：可以被同一包内的任何类访问。不能被其他包中的类访问，无论它们是否是子类。
private：只能被其所在的类访问。类的成员（如字段、方法、内部类等）可以声明为private，但最外层的类不能声明为private。

equals()和hashCode的关系

HashSet，HastMap都不允许重复，在存放数据时会先调用HoahCode来判断和之前的数据是否重复，如果和其他对象的hashCode值一样就会再调用equals来判断是否是一个对应，equals如果也一样的话就断定是一个值。

可以使用 int Objects.hash(args...)函数来实现hashCode，参数一般填为自己的所有字段。

垃圾回收

System.gc()，建议vm进行垃圾回收的函数。

垃圾回收时，会从所有的GC Root作为是起始点，从这些点开始，垃圾回收器会尝试查找和访问堆上的对象。换句话说，从GC Root可以直接或间接地引用到的对象都被认为是"活动的"，也就是还在使用中。而那些从GC Root无法访问到的对象则可能是垃圾，它们可能会在下一次垃圾回收时被清除。

以下是常见的GC Root：

虚拟机栈引用的对象：当前线程中的局部变量、参数、返回值等都属于这一类。
方法区中静态属性引用的对象：也就是所有的类级别的静态变量。
方法区中常量引用的对象：例如字符串常量池中的引用。
本地方法栈中JNI（即通常所说的Native方法）引用的对象。
活跃的线程本身。
所有被同步锁synchronized持有的对象。

硬引用、软引用、弱引用（虚引用）

各种引用的区别就是垃圾回收的时候，处理的方式不一样。

硬引用

普通创建的对象就是硬引用，除非引用变量在栈中被销毁，否则不会被回收。

软引用

一般作为缓存使用。

当系统内存充足时，持有软引用的对象不会被垃圾收集器回收。

当系统内存不足或即将耗尽时，持有软引用的对象会被垃圾收集器考虑回收，即使这个对象还有软引用指向它。

举例：

想要创建一个图像的缓存。你不希望一直持有这些图像，以防止占用太多内存，但当内存充足时，你也不希望它们被频繁地回收和重新加载。这时，软引用是一个很好的选择：

import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;

public class ImageCache {

    private Map<String, SoftReference<Image>> cache = new HashMap<>();

    public Image getImage(String path) {
        SoftReference<Image> softRef = cache.get(path);
        if (softRef != null) {
            Image image = softRef.get();
            if (image != null) {
                return image; // 使用缓存中的图像
            }
        }

        // 缓存中没有图像或图像已被回收，重新加载它
        Image image = loadImageFromDisk(path);
        cache.put(path, new SoftReference<>(image));
        return image;
    }

    private Image loadImageFromDisk(String path) {
        // 从磁盘加载图像的代码
        // ...
        return new Image();
    }

    // Image类的定义，为简洁起见，此处省略实际实现
    private static class Image {}
}

多线程篇

现成的五种状态

新建 (New): 线程刚被创建，但还未开始执行。在这个状态下，线程已经被分配了必要的资源和内存。
就绪 (Runnable): 线程已经准备好运行并等待CPU调度。在这个状态下，线程已经准备好执行，只是在等待操作系统的线程调度器分配给它执行时间。
运行 (Running): 线程正在执行。当线程获得CPU时间片（时间段）时，它的状态变为运行状态。在这个状态下，线程开始执行其run()方法或传递给它的任务。
阻塞/等待 (Blocked/Waiting): 线程因为某些操作而暂停执行。这个状态通常发生在线程等待某些外部资源（如I/O操作）或者等待其他线程的操作（如通过synchronized关键字获取对象锁）。阻塞状态可以分为几种具体情况，包括等待阻塞、同步阻塞（等待获取监视器锁），以及其他形式的阻塞。
终止 (Terminated): 线程的执行已经完成。一旦线程完成了它的执行任务或者由于某种原因被终止，它就会进入终止状态。在这个状态下，线程的所有资源都会被释放，它不能再被启动或复用。

Java中有几种创建线程的方式

四种：继承Thread类，实现Runnable接口，

ThreadLocal

ThreadLocal只能放入一个对象和取出一个对象，但是很神奇的是，同一个线程中get出的对象是相同的。

static ThreadLocal<String> xin = new ThreadLocal<>(); 一般把这个变量作为静态变量写在工具类中，属于同一个线程的方法使用了，存入与取出的对象是一样的。

Java常用集合

ArrayList：支持快速随机访问。内部以数组形式实现，适合频繁的查询操作。

LinkedList:：在任何位置添加或删除元素效率高，因为它是以链表形式实现的。

Vector：类似于ArrayList，但是所有方法都是同步的，是线程安全的。

MySQL（重中之重）

mysql多对多查询重中之重！！！

多对多查询

-- 创建学生表
CREATE TABLE 学生 (
    id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL
);

-- 创建课程表
CREATE TABLE 课程 (
    id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL
);

-- 创建成绩表
CREATE TABLE 成绩 (
    学生id INT,
    课程id INT,
    分数 INT,
    PRIMARY KEY (学生id, 课程id),
    FOREIGN KEY (学生id) REFERENCES 学生(id),
    FOREIGN KEY (课程id) REFERENCES 课程(id)
);

# 查询每个学生每门课的成绩
select 学生.id,学生.name,课程.name,成绩.分数
from 学生
JOIN 成绩 on 成绩.学生id = 学生.id
JOIN 课程 on 成绩.课程id = 课程.id
order by 学生.id desc


# 查询每科最高成绩的学生信息
SELECT
    课程.name, 学生.name, 成绩.分数
FROM
    成绩
JOIN 学生 ON 学生.id = 成绩.学生id
JOIN 课程 ON 课程.id = 成绩.课程id
WHERE
    (成绩.课程id, 成绩.分数) IN (
        SELECT 成绩.课程id, MAX(成绩.分数)
        FROM 成绩
        GROUP BY 成绩.课程id
    );

MySQL术语概念

mysql中什么是：索引，视图，存储过程，触发器请简述。

索引：排好序可以快速查找的数据结构，同主键索引，单一索引，符合索引
视图：视图是一个虚拟表，其内容由查询定义。视图不包含数据本身，而是在使用时动态生成数据。它们是基于底层表的数据查询的结果集。视图可以包含一个表的所有列或选定的列，也可以包含多个表的连接结果。
1. 比如有一个很复杂的SQL查询结果，你只想对这个结果进行查找，你就可以定义视图把复杂的SQL封装进去。
2. 视图可以用作安全机制，限制对底层数据的直接访问
触发器：它会在满足特定条件时自动执行定义好的SQL语句或代码块。触发器可以在以下几种情况下触发执行，比如增加用户时在日志文件增加日志。
存储过程：一种在数据库中保存的SQL语句集合，可以像调用函数一样执行。存储过程可以简化复杂的操作，实现代码重用，提高开发效率，并有助于减少网络通信量。

Spring篇

Bean的作用域

Spring中Bean默认作用域是单利的，spring中的一个类加上@Component时，这个类有一个属性为a，a默认为0，第一个通过@AutoWrite获取时设置a为1，第二次通过@AutoWrite获取这个类的示例时时a的值是1。

可以用过@Bean与@Scope("prototype")来设置作用域。

Spring 的常用作用域：

Singleton: 默认。每个Spring容器只有一个实例。
Prototype: 每次请求都新建实例。
Request: 一个HTTP请求内共享同一个实例。
Session: 一个HTTP Session内共享同一个实例。

MVC架构

MVC 是 Model-View-Controller 的缩写，它是一种设计模式。MVC 将应用程序逻辑分为三个互相关联的组件，以实现模块化和更容易的管理。以下是这三个组件的解释：

Model（模型）：这是应用程序的数据部分。它包含所有的业务逻辑、数据和规则。模型是独立于视图和控制器的，这意味着模型不知道用户界面如何显示数据。
View（视图）：这是用户看到和与之互动的部分。它负责展示模型的数据。当模型中的数据发生变化时，视图会相应地更新。
Controller（控制器）：控制器是模型和视图之间的接口。它接收用户的输入并决定如何处理。基于用户的行为，控制器可以请求模型进行更改或更新，或者更改视图的表示。

前后端分离的现在，后端已经没有View层了。

Server、Mapper，domain等层属于Model类，Controller层属于controller类。

Spring如何解决循环依赖

注意：如果A变量的构造函数需要B，B的构造函数需要A，这种是误解的。

能解决什么类型的循环依赖问题

如果两个Java类在它们的构造函数中相互依赖，那么这会导致问题，因为无法在初始化一个类的同时初始化另一个类。

但是，Spring框架确实提供了处理循环依赖的机制。以下是Spring如何解决这个问题的：

字段注入：如你所说，如果A类有一个B类型的字段，并且这个字段是通过Spring注入的，同时B类也有一个A类型的字段并且这个字段是通过Spring注入的，那么Spring可以解决这种依赖关系。这是因为Spring首先创建了A和B的实例，然后再为它们的字段注入依赖。
Setter方法注入：与字段注入类似，使用setter方法注入也可以解决循环依赖。Spring首先创建对象实例，然后使用setter方法为对象注入依赖。

Spring解决循环依赖的原理

这里举例A依赖B。B依赖A：

初始化A时，会先创建A类原始的Bean（未填充属性的），然后把这个Bean放入二级缓存，并在三级缓存中创建A的工厂对象。

填充A的属性时，发现需要B，于是就创建B。

创建B时发现需要A，Spring会从一级缓存中查找A，找不到就去二级缓存中查找A，发现二级有A的早期实例，就会拿这个填充。

这时B创建完了，就用B填充A。

三级缓存的问题

三级缓存中的工厂是什么时候放进去的

三级缓存中的工厂对象是在bean实例化但还未完全初始化（如属性填充）时放进去的。

三级缓冲中的工厂有什么用

三级工厂就是为了返回未初始化完成的Bean而创建。三级工厂返回的Bean会放入二级缓存。

这么做是为了不影响二级中的Bean初始化，二级中的Bean初始化完成之后要直接放入一级缓存。

工厂返回的Bean与二级缓存中的Bean是一样的，同一个引用。

对象没有循环依赖的情况

当Spring容器开始初始化一个bean（例如A）时，它会首先调用A的构造方法来实例化它。

然后Spring会进行属性注入、执行初始化方法等其他初始化步骤。

一旦bean完全初始化，它会直接放入一级缓存，这时它已经是一个完全初始化的单例bean，可以被其他bean或应用代码引用。

常用注解

@Autowired与@Resource区别

这两个都是做Bean注入用的，@Resource并不是Spring的注解，他的包是javax.annotation.Resource需要导入，但是Spring支持改注解的注入。

共同点：都可以写在字段和setter方法上，两者如果都写在字段上。

@Autowired默认按照类型（byType）装配依赖对象。

默认情况下他要求依赖的对象必须存在，如果允许为null，可以设置他的required属性为false。

如果我们想按名称（byName）来装配，可以结合@Qualifier注解一起使用，@Qualifier注解来指定名称。

@Resource默认按照名称（ByName）装配依赖对象，由j2ee提供。

@Resource有两个重要的属性，name和type。

Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。

@Indexed

需要额外添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-context-indexer</artifactId>
</dependency>

这是@Indexed的依赖，添加这个依赖之后可以提高Springboot的启动速度。

添加这个依赖编译项目（使用Maven的install）后会自动把：@Component，@Indexed，@Controller，@Service，@Repository这些相关的额注解标注的类的路径自动包含在“target/META-INF/spring-components”文件中，启动时提高速度。

@Import

@Import注解的作用：让Spring容器从其他指定的配置类中加载被@Bean修饰过的方法。

public class Person {
    ...
}

public class Address {
    ...
}

@Configuration
public class MainConfig {

    @Bean
    public Person john() {
        return new Person("John");
    }
}

@Configuration
public class AdditionalConfig {

    @Bean
    public Address newYorkAddress() {
        return new Address("New York");
    }
}

@Configuration
@Import({MainConfig.class, AdditionalConfig.class})
public class CombinedConfig {

    @Autowired
    private Person john;

    @Autowired
    private Address newYorkAddress;

    @Bean
    public String johnsAddressInfo() {
        return john.getName() + " lives in " + newYorkAddress.getCity();
    }
}

上面代码中：

CombinedConfig类上的@Import注解使MainConfig和AdditionalConfig中所有用@Bean标注的方法的返回值被注册到Spring容器中。

当Spring启动并处理CombinedConfig时，它不仅会注册CombinedConfig中定义的beans，还会注册MainConfig和AdditionalConfig中定义的beans。这正是@Import注解的主要目的。

@Controller与RestController的区别

@RestController
public class HelloController {
    @GetMapping("/restController")
    public User test() {
        return new User();
    }
}

@Controller
public class HelloController {
    @GetMapping("/controller")
    public User test() {
        return new User();
    }
}

@RestController:

它是一个组合注解，等同于 @Controller 和 @ResponseBody 的组合。
它意味着这个控制器的所有方法的返回值都将自动序列化为 JSON 或其他媒体类型，并作为 HTTP 响应的体返回。因此，当你访问 http://localhost/restController时，在浏览器中直接看到的是 xxx 对象的 JSON 表示。

问：@RequestMapping("/hello") public String Hello(){ return "hello"; } }:返回字符串时：RestController不是返回的json格式吗，为什么,为什么浏览器的网络相应中返回的是hello，而不是“hello”，为什么hello会直接输出到页面上，RestController什么时候返回json什么时候返回xml

答：

为什么返回的是 "hello" 而不是 “"hello"”？

当你返回一个简单的字符串时，Spring MVC 会直接将这个字符串作为响应体返回，而不会将它视为一个 JSON 字符串值。所以，返回的就是 hello 而不是 JSON 格式的 "hello"。

为什么 "hello" 会直接输出到页面上？

这是因为默认的 Content-Type 是 text/plain。所以浏览器会把它当作纯文本来处理，并直接显示。

@RestController 何时返回 JSON 和何时返回 XML？

@RestController 会基于请求的 Accept 头和项目的依赖来确定返回什么格式的数据。

如果请求头包含 Accept: application/json 并且你的项目中有合适的 JSON 库（如 Jackson），那么默认返回的是 JSON 格式。
如果请求头包含 Accept: application/xml 并且你的项目中有 XML 绑定库，那么会返回 XML 格式。
如果方法返回一个对象或集合，并且接受的请求头是 Accept: application/json，则 @RestController 通常会返回 JSON 格式的数据。如果没有特定的 Accept 头或者接受多种内容类型，那么通常默认返回的是 JSON，前提是你的项目中有相关的 JSON 库。

@Controller:

当你在方法上没有使用 @ResponseBody 注解时，@Controller 注解的方法默认返回的是一个视图（view）的名字（通常用于模板引擎，例如 Thymeleaf, JSP 等）。
http://localhost:86/controller 时方法返回的是一个 User 对象。但因为你没有指定视图名，也没有使用 @ResponseBody，Spring 将尝试查找一个与 User 对象名匹配的视图，这通常不是你想要的。
这里的视图，指的是JSP那种。

普通方法与REST风格方法的对比

REST风格：

在REST风格中，HTTP动词（方法）如 GET, POST, PUT, DELETE 通常有以下的含义和约定：

GET:
- 用于检索资源。
- 它应该只是读操作，不会更改资源的状态或执行任何副作用。
- 例如：GET /api/users/123 可以用来检索ID为123的用户的详细信息。
POST:
- 用于创建新资源。
- 通常在创建新资源时使用，响应中经常会返回一个 Location 头，指示新创建资源的URI。
- 例如：POST /api/users 可以用来创建一个新用户，请求体中包含用户的详细信息。
PUT:
- 用于更新现有资源或创建新资源（如果它不存在的话）。
- 与POST不同，PUT是幂等的，这意味着多次执行同一个PUT请求应该总是产生相同的结果。
- 例如：PUT /api/users/123 可以用来更新ID为123的用户的详细信息或创建一个新用户（如果它之前不存在）。
DELETE:
- 用于删除资源。
- 例如：ELETE /api/users/123 会删除ID为123的用户。