Java大纲包含后端用到的所有知识

Spring Core 负责管理应用程序中的 Bean，提供依赖注入（DI）功能。

依赖注入（DI - Dependency Injection）：依赖注入是 Spring 的核心特性，它可以自动管理对象之间的依赖关系。

AOP（面向切面编程）

数据访问（JDBC、ORM）

事务管理

Spring MVC（Web 层）

Spring Security（安全管理）

IOC（Inversion of Control，控制反转） 是一种设计原则，它将对象的创建和管理交给 Spring 容器，而不是手动在代码中实例化对象。

IOC 解决了什么问题？
在传统 Java 代码中，对象是主动创建的：

public class UserService {
    private UserDao userDao = new UserDao();  // 直接创建对象
}

这种方式的问题：

• 紧耦合（难以替换实现）
• 难以维护（无法轻松管理对象）
• 不易扩展（更换 UserDao 需要修改 UserService 代码）

IOC 让对象变成被动获取：
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 由 Spring 容器管理
}

• 由 Spring 自动注入 UserDao，不需要手动创建对象
• 解耦 了 UserService 和 UserDao
• 提高了 灵活性 和 可维护性

依赖注入（DI, Dependency Injection）是 IOC 的核心机制，Spring 通过 DI 负责注入对象。

DI 的三种方式
（1）基于 XML 配置
<bean id="userDao" class="com.example.UserDao"/>

<bean id="userService" class="com.example.UserService">
    <property name="userDao" ref="userDao"/>
</bean>

（2）基于 Java 配置
@Configuration
public class AppConfig {
    @Bean
    public UserDao userDao() {
        return new UserDao();
    }

    @Bean
    public UserService userService() {
        return new UserService(userDao());
    }
}

（3）基于注解
@Component
public class UserDao {}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
}

（1）BeanFactory 和 ApplicationContext

• BeanFactory（底层 IOC 容器）：懒加载（性能高，但功能少）
• ApplicationContext（高级 IOC 容器）：支持 AOP、事件发布等功能，推荐使用。

（2）IOC 容器的创建
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);

Spring IOC 容器

IOC 容器的初始化过程

Spring IOC 的核心类

依赖注入（DI）的实现

AOP（Aspect-Oriented Programming，面向切面编程）用于在不改变业务代码的情况下，增强某些功能（如日志、事务、安全等）。

假设我们需要在 UserService 的方法执行前后记录日志：

public void saveUser() {
    System.out.println("开始执行 saveUser 方法...");
    // 业务逻辑
    System.out.println("saveUser 方法执行完毕...");
}

• 代码重复（每个方法都需要加日志）
• 侵入式（破坏业务代码的整洁性）

AOP 让日志逻辑与业务逻辑分离：
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeMethod() {
        System.out.println("开始执行方法...");
    }
}

@Aspect（定义切面）

@Pointcut（定义切点）

通知（Advice）

@Around 注解（高级用法）

AOP（Aspect-Oriented Programming，面向切面编程） 允许在不修改源代码的情况下增强方法的行为。

Spring AOP 基于代理模式实现，包括：

• JDK 动态代理（基于接口）
• CGLIB 动态代理（基于子类继承）

JDK 动态代理

CGLIB 动态代理

CGLIB 代理 vs JDK 代理

Spring MVC 的 核心，继承自 HttpServlet，在 web.xml 中配置：

用于 查找请求对应的 Controller，Spring 提供以下实现：

RequestMappingHandlerMapping解析 @RequestMapping 注解
SimpleUrlHandlerMapping解析 XML 配置的 URL 映射

作用：调用 Controller 方法。
默认适配器：

RequestMappingHandlerAdapter 处理 @RequestMapping 方法

Spring MVC 解析 ModelAndView 的视图名称并返回相应页面。常见视图解析器：

InternalResourceViewResolver  解析 JSP
ThymeleafViewResolver  解析 Thymeleaf
FreeMarkerViewResolver  解析 FreeMarker

用于 权限校验、日志记录：

底层流程分析

• 调用 SpringApplication.run()
• 初始化 SpringApplication
• 调用 prepareEnvironment() 加载环境变量
• 创建 ApplicationContext
• 刷新 ApplicationContext
• 启动 Web 服务器
• 调用 ApplicationRunner 和 CommandLineRunner
• 应用启动完成

@SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan

• @Configuration：允许 Java 配置 Bean
• @EnableAutoConfiguration：开启 Spring Boot 自动配置
• @ComponentScan：自动扫描 @Component、@Service、@Repository

该注解的核心逻辑：

1. 读取 META-INF/spring.factories
2. 加载 EnableAutoConfiguration 配置的所有类
3. 通过 @ConditionalOnClass 或 @ConditionalOnMissingBean 进行自动装配

spring-boot-autoconfigure.jar 中的 spring.factories：

• org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
• org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
• org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
  

原理解析

• @ConditionalOnClass(DataSource.class)：只有 DataSource 存在时才生效
• @ConditionalOnMissingBean(DataSource.class)：如果 DataSource 已被用户手动定义，则不启用

Spring Boot 自动装配的实现流程如下：

1. 读取 spring.factories 配置文件，找到 EnableAutoConfiguration 相关的自动配置类。
2. 使用 AutoConfigurationImportSelector 选择合适的自动配置类。
3. 根据 @Conditional 注解 判断是否满足加载条件（如 @ConditionalOnClass、@ConditionalOnMissingBean）。
4. 向 Spring 容器中注册自动配置的 Bean。

它列出了所有可用的自动配置类，例如：

• DataSourceAutoConfiguration（数据库配置）
• WebMvcAutoConfiguration（Spring MVC 配置）
• HibernateJpaAutoConfiguration（JPA 配置）

Spring Boot 在应用启动时自动加载这些类，并判断是否需要激活。

@EnableAutoConfiguration 的核心逻辑在 AutoConfigurationImportSelector 里：

• SpringFactoriesLoader.loadFactoryNames() 方法会读取 spring.factories 配置文件，并加载所有 EnableAutoConfiguration 配置的类。

Eureka（Netflix 提供）

Nacos（阿里巴巴提供）

Ribbon

Feign

Spring Cloud Gateway

Hystrix

Sentinel（推荐）

Spring Cloud Config 允许微服务从集中配置中心获取配置信息。

Spring Cloud Sleuth + Zipkin

Spring Cloud Stream

一级缓存（SqlSession 级别，默认开启）：

二级缓存（Mapper 级别，需要手动开启）：

通常来说，MyBatis 的三级缓存可以理解为：

• 一级缓存：每个 SqlSession 内部使用的缓存，存储在当前 SqlSession 内，作用于本地 JVM。
• 二级缓存：在 SqlSessionFactory 中共享，存储在 Mapper 级别的缓存，作用于同一 SqlSessionFactory 内。
• 三级缓存：使用外部缓存系统（如 Redis、Memcached），跨 SqlSessionFactory 和多个服务实例共享缓存。

ORM 是一种用于将面向对象编程（OOP）中的类和对象与关系型数据库中的表和记录进行映射的技术。Hibernate 实现了 ORM，通过这种映射，开发者可以用 Java 对象操作数据库中的数据，而无需直接编写 SQL。

• 对象：Java 类
• 关系：数据库表
• 属性：Java 类的字段与数据库表的列一一对应

Hibernate 通过映射文件或者注解，管理 Java 类与数据库表之间的关系。通过 Hibernate 的核心接口（如 SessionFactory、Session），它能够执行数据库操作，并将 Java 对象映射到数据库表中的行。

Session 是 Hibernate 的一个核心概念，它代表了与数据库的一次连接或对数据库的一个会话。通过 Session，我们可以执行增、删、改、查等数据库操作，并且 Hibernate 会管理对象的持久化。

字符串是 Redis 中最基本的数据类型。它可以包含任何类型的二进制数据，如 JPEG 图片或序列化的对象。

Redis 中的字符串是二进制安全的，意味着它可以包含任何形式的值（不仅仅是文本）。

哈希是键值对集合，适合存储对象。例如，可以使用哈希存储一个用户的基本信息（如用户名、年龄、地址）。

使用哈希存储小规模的对象信息比使用字符串更高效。

列表是一个简单的字符串列表，按插入顺序排序。你可以在列表的两端进行推入、弹出操作。非常适合实现消息队列等场景。

列表是一个双端队列，支持从两端进行推入和弹出。

集合是一个无序的字符串集合。集合中的元素是唯一的，不允许重复。集合非常适合用来存储一些不重复的数据。

集合支持高效的成员添加、删除和查找操作。

有序集合与集合类似，但每个元素都会关联一个分数（score），Redis 会根据分数对元素进行排序。适合用于排行榜等场景。

有序集合支持按分数排序、范围查询等操作。

位图是一个比特数组，可以用来表示某些状态信息，如用户是否活跃，某个特定日期是否完成任务等。

位图非常适合用来实现计数、状态标记等功能。

HyperLogLog 是一个用于估算基数的概率性数据结构。它可以用来统计唯一元素的数量，例如统计访问量，但误差在可接受范围内。

HyperLogLog 能够以较少的内存估算大型数据集的基数。

RDB 持久化会在指定的时间间隔内生成数据的快照并保存到磁盘。它适用于对性能要求较高，但容忍短时间内数据丢失的场景。

• 可以通过配置 SAVE 或 BGSAVE 指令来生成 RDB 快照。
• 快照文件通常保存在 dump.rdb 文件中。

AOF 持久化会将每个写命令追加到文件末尾，以记录每一次的变更。通过重放 AOF 文件，可以恢复数据库状态。

• AOF 适用于需要较高数据可靠性的场景，但会对性能产生一些影响。
• AOF 文件通常保存在 appendonly.aof 中。

Redis 支持主从复制架构，一个主节点可以有多个从节点，所有从节点会自动复制主节点的数据。这为 Redis 提供了高可用性和数据备份功能。

• 主从复制使得 Redis 可以读取分流、负载均衡。
• 从节点可以在主节点故障时提供数据。

Redis Sentinel 是 Redis 的高可用解决方案，它提供了故障自动检测、自动故障转移和通知机制。当主节点宕机时，Sentinel 会自动将某个从节点升级为新的主节点。

Redis 支持数据分片，即将数据分布到多个 Redis 节点上。这可以通过 Redis 集群（Cluster）实现，提供横向扩展的能力。

• Redis 集群支持自动分片，将键分布到不同的节点上，保证数据的负载均衡。

选择适合业务场景的数据结构，以提高操作效率。例如：

• 用列表实现队列。
• 用集合实现唯一性要求的数据集合。
• 用有序集合实现排行榜等。

• 使用 RDB 时，可以调整快照的保存频率，以平衡性能和数据可靠性。
• 使用 AOF 时，可以调整 AOF 重写的策略（如每次修改后追加、定期重写）。

• 设置合理的内存使用策略，使用 maxmemory 指令限制 Redis 占用的最大内存。
• 配置内存淘汰策略，如 volatile-lru（仅对设置了过期时间的键进行 LRU 淘汰）等。

Redis 为什么快？

Redis 是单线程的吗？

Redis 如何实现持久化？

Redis 支持事务吗？

Redis 如何实现分布式锁？

Redis 如何做缓存雪崩、缓存击穿、缓存穿透？

Redis 过期策略？

Redis 如何实现主从复制？

Redis Sentinel（哨兵模式）工作原理？

Redis Cluster（集群模式）原理？

如何提高 Redis 并发量？

Redis 如何防止内存爆炸？

Memcached 将数据存储在内存中，按照键值对的形式进行管理。应用程序将数据存入 Memcached 时，指定一个唯一的键（key）和相应的值（value）。随后，应用程序通过该键来检索数据。

set <key> <flags> <expiration> <bytes> <data>

• 键（key）：唯一标识缓存数据的字符串，客户端通过这个键来检索缓存。
• 值（value）：缓存的数据内容，可以是字符串、序列化后的对象或其他数据类型。
• 标志（flags）：用于存储附加信息，通常用于应用层的标识，如缓存数据的类型。
• 过期时间（expiration）：缓存数据的过期时间，单位为秒。
• 字节数（bytes）：缓存值的大小。

Memcached 是一个基于内存的缓存系统，因此它会将数据直接存储在内存中，避免了磁盘 I/O 操作，从而提高了性能。当应用程序需要访问缓存数据时，它首先会向 Memcached 查询键是否存在，如果存在则直接返回对应的值；如果不存在，则可能需要从数据库中加载数据并将其存入 Memcached。

Memcached 是一个分布式系统，支持多个 Memcached 节点共同工作。当数据量超过单台服务器的内存容量时，可以将数据分布到多个 Memcached 服务器上。Memcached 会根据客户端的请求自动将数据分配到适当的节点。

• 一致性哈希：Memcached 使用一致性哈希来确定数据存储在哪个节点上。客户端根据键值的哈希值来计算其存储的位置，从而实现数据分布。
• 节点扩展：通过添加新的 Memcached 节点，系统的缓存容量和处理能力可以水平扩展。

SET：存储一个键值对，如果键已存在，则覆盖现有值。

ADD：如果键不存在，则存储该键值对。如果键已存在，则不做任何操作。

REPLACE：如果键已存在，则替换其值。如果键不存在，则不做任何操作。

APPEND：将新的数据附加到已存在键的值后面。如果键不存在，则不做任何操作。

PREPEND：将新的数据插入到已存在键的值前面。

GET：获取一个键的值。

GETS：与 GET 类似，但是 GETS 返回的结果还包含了标志信息。

DEL：删除一个键。

STAT：获取 Memcached 服务器的统计信息。

FLUSHALL：清空所有缓存。

FLUSH：清空当前实例中的缓存。

• 高性能：Memcached 在内存中直接存储数据，避免了磁盘 I/O 操作，因此能够提供非常高的读写性能。
• 简单易用：Memcached 的使用非常简单，通过客户端提供的 API 就可以进行基本的存储、获取、删除操作。
• 分布式：Memcached 原生支持分布式架构，能够根据需要水平扩展缓存容量。
• 开源和广泛支持：Memcached 是一个开源项目，支持多种编程语言，社区活跃，文档丰富。

• 只支持键值对存储：Memcached 只支持简单的键值对存储，缺乏更复杂的数据结构，如 Redis 提供的列表、集合等。
• 不支持持久化：Memcached 默认不支持持久化，即一旦服务重启，缓存的数据将丢失。虽然可以通过一些方法来模拟持久化，但这并不是 Memcached 的设计重点。
• 内存受限：由于 Memcached 是内存存储，缓存数据量受到物理内存大小的限制。在大规模缓存需求下，可能需要更高效的内存管理机制。

• 索引过程：当文档被添加到 Lucene 中时，文档会通过指定的分析器进行分词。分词后，Lucene 将每个词项存储到倒排索引中，并将词项与文档 ID 相关联。
• 
  
• 查询过程：当用户提交查询请求时，Lucene 会将查询字符串解析为词项，并通过倒排索引查找相关的文档。查询结果返回的是匹配的文档 ID 和相应的评分（基于 BM25 或其他算法）。

1. 文档创建：首先，创建一个 Document 对象，表示一个完整的搜索条目。每个文档包含多个 Field，每个字段保存了文档的一个属性或内容。
2. 文本分析：使用 Analyzer 来将字段的文本进行分析，分词并去除停用词。例如，使用标准分析器（StandardAnalyzer）来处理文本。
3. 建立倒排索引：Lucene 使用倒排索引来存储词项与文档之间的关系。倒排索引将每个词项（例如 "Lucene"）映射到所有包含该词项的文档 ID。
4. 写入索引：将所有文档及其字段信息通过 IndexWriter 写入索引存储（可以是内存中的 RAMDirectory 或磁盘中的 FSDirectory）。

1. 查询解析：Lucene 通过 QueryParser 将用户的查询字符串转换为 Lucene 查询对象。例如，用户可能输入 "search engine" 这样的查询词，Lucene 会将其转换为查询对象。
2. 匹配查询：Lucene 通过倒排索引查找包含查询词的文档。它会遍历倒排索引，找到匹配的文档并计算每个文档的相关性得分。
3. 排序与评分：Lucene 使用 BM25 或类似的算法对每个匹配文档进行评分，并根据得分对结果进行排序。高分的文档会被认为与查询更相关。
4. 返回查询结果：查询结果返回时，通常是按照得分排序的文档 ID 列表。开发者可以选择返回更多信息，如字段内容等。

Analyzer 用于将文本字段分解为词项，并将其存储到倒排索引中。Lucene 提供了许多内置的分析器（如 StandardAnalyzer、WhitespaceAnalyzer、KeywordAnalyzer 等），也支持自定义分析器。

• Tokenizer：负责将文本分割成词项（token）。
• Filter：处理分词后的词项，如去除停用词、转换小写、词干提取等。

IndexWriter 是用于写入文档到索引的主要组件。它将分析后的文本存储到索引文件中。IndexWriter 支持文档的增加、更新和删除。

IndexSearcher 是用于从索引中查询文档的主要组件。它提供了高效的查询接口，可以基于各种查询类型（如布尔查询、范围查询等）来查找匹配的文档。

Lucene 提供了多种查询类型，如：

• TermQuery：匹配一个特定的词项。
• PhraseQuery：匹配一系列词项的短语。
• BooleanQuery：支持布尔逻辑运算（AND、OR、NOT）。
• RangeQuery：根据范围条件匹配文档。
• WildcardQuery：支持通配符查询。

ScoreDoc 表示查询结果中的单个文档，并包含文档 ID 和评分。TopDocs 用于存储查询的前 N 个最相关文档。

• Merge：当有大量文档被添加到索引中时，Lucene 会合并多个小索引文件，以减小磁盘的读取开销。
• 字段存储方式：通过选择适当的字段存储策略（如 Field.Store.YES 或 Field.Store.NO），可以控制是否将字段内容存储在索引中，从而优化存储和查询性能。

• Query Caching：Lucene 可以缓存查询结果，提高重复查询的性能。
• 索引分片：在数据量非常大的情况下，Lucene 支持将索引分成多个分片（或分段），并通过合并优化性能。
• BM25 算法：Lucene 使用 BM25 算法来对查询结果进行评分，这使得文档与查询之间的相关性更加精确。

Solr 提供了强大的分布式搜索和索引功能，它通过 SolrCloud 来管理分布式系统的集群。SolrCloud 是基于 Apache ZooKeeper 的，提供了以下几个特性：

• 分片：SolrCloud 支持将索引数据分片，每个分片存储在不同的服务器上，从而实现数据的水平扩展。
• 复制：SolrCloud 还支持副本机制，多个副本可以保证系统的高可用性和容错性。
• 自动负载均衡：SolrCloud 可以自动平衡负载和副本，确保各节点的负载均衡。

Solr 提供了丰富的查询语言和查询功能，支持：

• 标准查询：支持布尔查询、范围查询、短语查询等。
• 全文搜索：可以对文本字段进行全文搜索，支持模糊搜索、拼写纠错等。
• 聚合：Solr 支持通过聚合查询对数据进行汇总统计（如计算最大值、最小值、平均值、计数等）。
• 排序与评分：支持基于字段、相关性和自定义排序规则进行排序。
• 过滤器查询：Solr 提供了过滤查询功能，可以提高查询性能，避免多次扫描索引。

Solr 提供了多种数据导入和导出方式，可以从不同数据源（如数据库、XML 文件、CSV 文件等）导入数据。常见的数据导入方式有：

• DataImportHandler (DIH)：通过 DIH 可以从数据库（如 MySQL、PostgreSQL 等）导入数据到 Solr。
• CSV、JSON 和 XML：Solr 支持通过 CSV、JSON 或 XML 格式上传数据。

Solr 继承了 Lucene 的分词能力，并且可以配置不同的分词器来处理文本字段。常见的分词器有：

• StandardTokenizer：标准分词器，基于空格和标点符号分割文本。
• EdgeNGramTokenizer：根据词首生成 n-gram，用于前缀匹配。
• KeywordTokenizer：将整个字段作为一个词项，适用于存储 URL、ID 等。

Solr 提供了高亮功能，可以高亮查询结果中匹配的词项，便于用户快速定位搜索结果。例如，当用户搜索“Solr”时，查询结果中的“Solr”词项可以高亮显示。

• Schema：Solr 的 schema 定义了文档中字段的类型、索引和存储方式。每个字段可以配置不同的类型，如文本类型、数字类型、日期类型等。
• 
  
• FieldType：Solr 中的 FieldType 定义了如何解析和存储字段数据。例如，TextField 用于存储可分词的文本，StringField 用于存储不可分词的字符串，DateField 用于存储日期。

solrconfig.xml 是 Solr 的配置文件，定义了 Solr 核心的行为。通过该文件，开发者可以配置缓存策略、查询请求的处理方式、索引处理等。

Solr 支持通过查询字符串（query string）来查询索引，常见的查询类型包括：

• 普通查询：直接查找某个字段的词项。
• 布尔查询：通过 AND、OR、NOT 进行复合查询。
• 范围查询：查找某个字段在特定范围内的文档。
• 拼写纠错：Solr 支持拼写纠错和相似词搜索功能。

Solr 支持聚合查询，可以对查询结果进行统计和分组。例如，可以使用 Solr 聚合查询来统计商品的平均价格、按类别统计商品数量等。

Solr 可以通过启动命令行来启动服务：

Solr 服务会在默认端口 8983 上启动，访问 Solr 管理界面：

Solr 中的数据存储和搜索是基于核心的，每个核心可以对应一个独立的索引。可以使用以下命令创建核心：

Solr 提供了 RESTful API 来添加数据。通过 HTTP 请求可以将数据添加到 Solr 中：

Solr 提供了强大的查询功能，可以通过 URL 发起查询请求：

Solr 使用 schema.xml 和 solrconfig.xml 配置文件来管理索引字段、分析器和请求处理等。通过修改这些配置文件，用户可以定制 Solr 的行为和性能。

Elasticsearch 是一个分布式系统，节点是构成 Elasticsearch 集群的基本单位。每个节点可以处理搜索请求、存储数据并参与集群的操作。常见的节点类型包括：

• 主节点（Master Node）：负责集群的管理工作，例如创建和删除索引、管理节点等。
• 数据节点（Data Node）：存储数据并处理与数据相关的操作，如索引、搜索和聚合查询。
• 协调节点（Coordinating Node）：处理客户端请求，并将请求转发给其他节点进行处理。任何节点都可以充当协调节点。

一个 Elasticsearch 集群是由一个或多个节点组成的，它们共同工作来存储数据和处理查询。集群中的每个节点都有一个唯一的名称，而集群也有一个名字，用来标识该集群。集群的所有数据和状态都存储在集群的节点之间。

Elasticsearch 中的索引类似于数据库中的表，它是存储文档的地方。每个索引包含多个文档，并且索引会分为多个分片（shards）。索引有一个名称，用于在集群中唯一标识。

文档是 Elasticsearch 中的基本数据单位，类似于关系型数据库中的一行。每个文档都属于某个索引，并且是由一组字段组成的 JSON 对象。每个文档都有一个唯一的 ID，用于区分不同的文档。

分片是索引的数据分布单元，Elasticsearch 会将索引的数据分散存储在多个分片中。每个分片本身是一个完整的 Lucene 索引，可以独立存储和查询。分片可以提高存储容量，并允许并行处理查询。每个索引可以由多个分片组成。

副本是分片的副本副本，目的是提高数据的可靠性和搜索性能。副本分片与主分片内容相同，但存储在不同的节点上。副本分片可以用于负载均衡，在集群中分布式查询时提高搜索性能。

在早期版本的 Elasticsearch 中，文档类型用于表示索引中的不同数据结构。自 Elasticsearch 7.x 起，已经移除了类型的概念，每个索引只能包含一种类型的文档。

Elasticsearch 的存储和索引机制基于 Lucene，它通过倒排索引实现高效的查询。具体过程如下：

• 文档存储：当用户将文档插入到索引时，Elasticsearch 会将文档进行解析，使用指定的分析器（Analyzer）将文本内容分解为词项（tokens）。
• 倒排索引：这些词项被存储在倒排索引中，倒排索引将每个词项映射到包含该词项的文档 ID，从而实现高效的检索。
• 分片与副本：Elasticsearch 会将索引数据分成多个分片，并为每个分片创建副本，这样既可以提高查询的并发性能，也可以确保数据的高可用性。

Elasticsearch 通过 RESTful API 提供查询接口，查询时用户会发送 HTTP 请求，Elasticsearch 会将查询请求解析为内部的查询表达式，并在倒排索引中查找匹配的文档。查询结果会按相关性排序，相关性由 Elasticsearch 的评分机制（默认使用 TF-IDF 和 BM25 算法）计算得出。

Elasticsearch 是一个分布式系统，所有节点都参与处理查询、存储数据和维护集群状态。查询会被路由到合适的分片，分片会将查询请求发送到实际存储数据的节点上。为了保证高可用性和容错性，Elasticsearch 会维护多个副本，并根据负载平衡进行查询和数据分布。

Elasticsearch 集群通过协调节点来管理查询请求。当一个查询请求到达集群时，协调节点会负责将请求分发到适当的节点（分片）。集群的状态（如节点的加入与离开）由主节点管理。主节点定期检查集群状态，并负责新节点的加入和故障节点的移除。

Elasticsearch 提供了多种查询类型，包括：

• 全文检索：基于倒排索引，支持模糊查询、短语查询等。
• 结构化查询：可以对字段进行精确查询、范围查询等。
• 布尔查询：支持 AND、OR、NOT 等布尔逻辑查询。
• 聚合查询：用于进行数据分析和统计，如按时间范围统计事件数。
• 排序与分页：支持对查询结果进行排序，并可以返回分页数据。

Elasticsearch 提供了多种数据导入方式：

• 批量导入：通过 bulk API 可以一次性批量插入数据。
• Logstash：通过 Logstash 可以从不同数据源（如数据库、日志文件等）导入数据到 Elasticsearch。
• Kibana：Kibana 是 Elasticsearch 的可视化界面，提供了简单的导入和查看数据功能。

Elasticsearch 支持实时搜索，能够非常快速地处理最新插入的数据。每当数据插入时，Elasticsearch 会将其快速地添加到索引，并立即使其可搜索。

Elasticsearch 的聚合功能非常强大，支持分组、统计、排序等操作。常见的聚合类型包括：

• 术语聚合（Terms Aggregation）：按字段的值进行分组。
• 日期直方图聚合（Date Histogram Aggregation）：根据日期字段进行时间分桶。
• 范围聚合（Range Aggregation）：按指定的范围对数据进行聚合。
• 统计聚合（Stats Aggregation）：计算数据的最小值、最大值、平均值、总和等。

Elasticsearch 通过分片和副本机制确保数据的高可用性和容错性。即使某些节点发生故障，副本分片依然能够提供服务，避免系统宕机。

Elasticsearch 运行在 JVM 上，可以通过以下命令启动：

创建索引：

添加文档：

查询数据：

可以通过 /_cat/ API 查看集群状态、节点信息等：

POST /my-index/_search {   "aggs": {     "average_price": {       "avg": {         "field": "price"       }     }   } }

Elasticsearch 提供强大的聚合功能，可以用于分析大规模数据集。聚合允许对数据进行分组、计算统计信息、计算数据的分布等。常见的聚合类型包括：

术语聚合（Terms Aggregation）：按字段的不同值进行分组。适用于对类别、标签、状态等进行分析。

日期直方图聚合（Date Histogram Aggregation）：按时间对数据进行分组，适用于时间序列数据分析。

范围聚合（Range Aggregation）：按指定的数值范围对数据进行分组，适用于定量分析。

统计聚合（Stats Aggregation）：对字段进行统计，计算最小值、最大值、平均值、总和等。

Elasticsearch 支持对多个字段进行搜索和聚合，可以通过布尔查询（bool query）实现对多个条件的组合查询。此外，Elasticsearch 也支持在多个字段上执行全文搜索或精确搜索。

多字段查询（Multi-Match Query）：

布尔查询（Boolean Query）：

模糊查询与拼写纠错

文档相关性评分

安全性与访问控制

• 合理分片：选择合适的分片数量可以有效提高查询性能。在 Elasticsearch 中，索引分片的数量决定了数据的分布，分片过多会导致性能下降，而分片过少会影响查询的并发性能。通常，建议根据数据量和查询需求来设定分片数量。
• 映射优化：合理设计索引的映射（Mapping），特别是字段的类型和索引方式。避免对不需要被搜索的字段进行索引，可以减小索引的大小，提高查询速度。
• 字段数据类型优化：为数值字段选择合适的数据类型，并避免使用多字段（Multi-fields）来增加不必要的索引字段。

• 使用 filter 而不是 query：在布尔查询中，如果某个条件不需要计算相关性评分，可以使用 filter 子句。filter 是免费的，不计算相关性分数，因此比 query 更高效。
• 避免 wildcard 和 regex 查询：通配符查询和正则表达式查询可能会导致性能问题，尽量避免在高频查询中使用。
• 缓存机制：Elasticsearch 内部实现了查询缓存。通过合理的查询设计，利用缓存可以大幅提升查询性能。

• 集群资源管理：合理配置 Elasticsearch 集群的硬件资源，包括内存、CPU 和磁盘空间。特别是对节点内存的管理，应该为每个节点分配合适的 JVM 堆内存大小，避免过大的堆内存导致垃圾回收延迟。
• 
  
• 使用快照与备份：定期对数据进行快照，以防止数据丢失。Elasticsearch 提供了快照 API，可以将数据备份到远程存储中（如 S3、HDFS 等）。

消息队列是 RabbitMQ 中存储消息的地方，消费者从队列中获取消息并进行处理。消息会按照先进先出的顺序（FIFO）在队列中进行存储。

交换机是 RabbitMQ 中的一个重要组件，负责接收生产者发送的消息，并根据路由规则将消息转发到一个或多个队列。交换机类型的不同，决定了它如何路由消息。

交换机有以下几种常见类型：

• Direct Exchange：根据消息的路由键（routing key）将消息发送到匹配的队列。
• Fanout Exchange：将消息广播到所有绑定的队列，不考虑路由键。
• Topic Exchange：根据路由键中的模式（wildcard）将消息发送到匹配的队列，灵活性高。
• Headers Exchange：通过消息的 header 来路由消息，不使用路由键。

队列和交换机之间的关系通过绑定实现。交换机将消息路由到队列中，通常通过路由键来确定消息应路由到哪个队列。绑定是一种动态过程，可以随时修改。

消息是 RabbitMQ 中传输的数据单元，生产者通过交换机将消息发送到队列，消费者从队列中读取消息进行处理。消息可以包含任何类型的数据，比如 JSON、XML 或者二进制数据。

路由键是用于交换机与队列之间消息路由规则的一个字符串。交换机通过该路由键决定将消息路由到哪个队列。例如，direct 类型的交换机会直接根据消息的路由键将消息发送到队列。

消费者是从队列中接收消息并进行处理的应用程序。消费者从队列中获取消息并进行相关业务处理，一旦处理完成，消费者会确认消息的消费。

生产者是发送消息到 RabbitMQ 交换机的应用程序。生产者并不直接和队列进行交互，而是通过交换机将消息发送到队列。

1. 生产者 将消息发送到 交换机。
2. 交换机根据消息的路由键将消息路由到 绑定的队列。
3. 消费者 从队列中获取消息并进行处理。

消息的可靠性传输是 RabbitMQ 的重要特点之一。消息传递可以分为两种确认方式：

• 自动确认：消费者从队列获取消息后自动确认消息已被成功消费。
• 手动确认：消费者处理完消息后手动确认消息已经消费，这样可以保证消息在处理成功后才从队列中删除。

为了保证消息不会在 RabbitMQ 停止或重启后丢失，RabbitMQ 提供了消息持久化机制。可以通过设置队列和消息为持久化，确保消息在服务器重启时不会丢失。

如果消息无法被消费者成功消费，或者消息过期，RabbitMQ 会将这些消息转发到一个指定的死信队列中。这使得开发者可以对这些无法消费的消息进行进一步的处理。

交换机与队列的绑定是通过路由键完成的。具体的路由规则根据交换机类型有所不同。比如：

• Direct Exchange：精确匹配路由键。
• Fanout Exchange：消息会广播到所有绑定的队列，不关心路由键。
• Topic Exchange：支持通配符，可以实现复杂的消息路由。
• Headers Exchange：根据消息的 header 来进行路由。

RabbitMQ 支持为队列中的消息设置优先级，消费者会根据消息的优先级来决定先处理哪个消息。通过设置队列的优先级属性，可以影响消息消费的顺序。

RabbitMQ 提供了限流机制来防止系统过载。可以对生产者、消费者或者队列设置流量控制，确保系统能够平稳运行。例如，可以限制队列的最大长度，当队列满时，生产者发送消息会被拒绝。

RabbitMQ 支持通过集群机制来提升可用性。集群模式下，RabbitMQ 会将多个节点连接在一起，组成一个集群。消息可以在集群中进行分布式存储，并实现高可用性。如果某个节点发生故障，其他节点可以继续工作。

RabbitMQ 支持通过插件扩展功能。RabbitMQ 插件可以添加多种功能，如监控、管理、协议支持等。比如，RabbitMQ 提供了 Management Plugin，可以通过 HTTP API 或者 Web UI 来管理 RabbitMQ 集群。

RabbitMQ 支持消息的生命周期管理，可以为消息设置过期时间（TTL）。消息在队列中超过指定时间未被消费时，会被丢弃，或者转移到死信队列中。这有助于避免长时间未处理的垃圾消息堆积。

消费者预取是指消费者从队列中预取消息的数量。通过设置消费者的预取计数，消费者可以控制每次从队列中获取多少消息。这有助于防止消费者过载。

消息是 ActiveMQ 中传递的数据单元。消息包含消息的有效载荷（通常是文本、二进制数据或对象），以及一些元数据，如消息的目的地（Destination）、消息类型、优先级等。

消息的目标地点，即接收消息的对象。ActiveMQ 中的目的地有两种类型：

• Queue：点对点模式（P2P），每条消息只能被一个消费者消费。
• Topic：发布/订阅模式（Pub/Sub），每条消息会被所有订阅者消费。

生产者是负责将消息发送到 ActiveMQ 目的地（队列或主题）的应用程序。它不需要关心消息的消费端，只需将消息发送到指定的目的地。

消费者是从目的地（队列或主题）中消费消息的应用程序。消费者从消息队列或主题中获取消息并进行处理。

连接工厂是 ActiveMQ 中用于创建连接的对象。通过连接工厂，生产者和消费者可以连接到 ActiveMQ 代理（Broker）。

消息代理是负责存储、转发消息并管理消息传递的组件。ActiveMQ 的 Broker 支持多个协议，并且能够处理大量并发的消息传递。

会话是消费者和生产者与消息代理进行交互的上下文。会话负责创建生产者、消费者和消息的生成。它也负责事务管理和消息确认。

1. 生产者通过 连接工厂 创建连接。
2. 连接工厂创建 连接，然后通过连接创建 会话。
3. 会话创建消息生产者，生产者将消息发送到 目的地（Queue 或 Topic）。
4. ActiveMQ 消息代理将消息存储在对应的目的地。
5. 消费者连接到 ActiveMQ 代理，获取消息并进行处理。

消息确认是 ActiveMQ 中确保消息可靠性的机制。消费者在处理完消息后，需要确认消息已经成功消费，以便 ActiveMQ 删除该消息。消息确认有两种方式：

• 自动确认：消费者从队列中获取消息后自动确认消息。
• 手动确认：消费者手动确认消息，只有在处理完消息后才进行确认。

消息持久化是确保消息在服务器宕机或重启后不会丢失的机制。ActiveMQ 可以将消息持久化到磁盘中，即使发生故障，消息也能被恢复。可以配置队列或主题以启用消息持久化。

消息可以设置过期时间。当消息在队列中存在超过指定时间时，消息会被自动删除，避免积压的过期消息影响系统性能。

ActiveMQ 允许为消息设置优先级。通过设置消息的优先级，系统可以确保高优先级的消息会被优先处理。默认情况下，ActiveMQ 支持 10 个级别的优先级，从 0 到 9。

ActiveMQ 支持事务机制，可以在生产者和消费者中进行事务控制。在事务内发送的消息，如果事务提交，则消息被成功传递；如果事务回滚，则所有消息将被撤回。

ActiveMQ 支持多种消息路由机制：

• Point-to-Point（P2P）：通过队列模型进行点对点消息传递，每条消息只有一个消费者。
• Publish/Subscribe（Pub/Sub）：通过主题模型进行发布订阅模式的消息传递，每条消息可以被多个订阅者消费。

ActiveMQ 支持高可用性和负载均衡。通过配置 Master-Slave 集群模式，消息代理的主节点会向备份节点同步消息数据，确保在主节点宕机时系统能自动切换到备份节点，保证系统的高可用性。

ActiveMQ 可以跨多个数据中心进行消息传递，支持高效的消息复制和负载均衡。通过配置 KahaDB 和 JDBC 连接池，ActiveMQ 可以进行跨数据中心的消息同步。

在订阅者和主题之间，ActiveMQ 提供了强大的消息过滤功能。消费者可以通过定义 消息选择器 来过滤消息，只有符合特定条件的消息才会被消费者接收。

ActiveMQ 支持消息重试机制。如果消费者处理消息失败，可以设置重试次数。超过最大重试次数后，消息将被送入 死信队列（Dead Letter Queue），便于后续处理。

• Producer（生产者）：负责发送消息到 Broker。
• Broker（消息代理）：负责接收、存储和转发消息。
• Consumer（消费者）：负责从 Broker 拉取消息并处理。
• NameServer（注册中心）：提供 Broker 的路由信息，并管理 Broker 的动态变更。

• 生产者（Producer） 通过 NameServer 获取 Broker 的地址信息，并向 Broker 发送消息。
• Broker 收到消息后，将消息存储到本地磁盘（CommitLog）中，同时更新消息的索引（ConsumeQueue）。
• 消费者（Consumer） 从 Broker 订阅并消费消息，消费模式可以是推模式（Push） 或 拉模式（Pull）。
• NameServer 作为轻量级的注册中心，管理 Broker 和 Consumer 之间的映射关系。

RocketMQ 中的消息是数据传递的基本单位，包含：

• Topic（主题）：消息的分类，每条消息必须属于一个 Topic。
• Tag（标签）：用于对 Topic 进行进一步细分。
• Key（消息键）：用于唯一标识消息，方便查询和追踪。
• Body（消息体）：具体的消息内容，可以是 JSON、XML 或二进制数据。

• 每条消息必须有一个 Topic，不同 Consumer Group 可以订阅相同的 Topic。
• Topic 在 RocketMQ 中相当于 逻辑队列，多个 Consumer Group 可以订阅同一个 Topic，但每个 Consumer 只能消费自己的队列（Queue）。

生产者用于发送消息，它支持同步（Sync）、异步（Async）、单向（OneWay） 三种发送模式：

• 同步发送：发送消息后，等待 Broker 确认。
• 异步发送：发送消息后，不等待 Broker 确认，适用于高吞吐业务。
• 单向发送：发送消息后不关心是否发送成功，适用于日志等场景。

消费者用于接收并处理消息，支持两种消费模式：

• Push 模式：Broker 主动推送消息到 Consumer。
• Pull 模式：Consumer 主动从 Broker 拉取消息。

消费者组（Consumer Group）：多个 Consumer 组成一个 Group，用于并行消费 Topic。

RocketMQ 提供两种消费模式：

集群消费（Clustering Mode）：

• 多个消费者组成一个 Consumer Group，消息被 多个消费者分摊 处理。
• 每条消息只会被其中一个消费者消费（负载均衡）。

广播消费（Broadcasting Mode）：

• 所有 Consumer Group 内的消费者都能收到同样的消息（适用于多实例处理相同数据）。

• 消息存储在 CommitLog 中，同时建立 ConsumeQueue（索引文件），加速消息查询。
• 消息存储采用 MappedFile 机制，基于 零拷贝（Zero Copy） 提高 IO 性能。

RocketMQ 支持 全局顺序消息 和 分区顺序消息：

• 全局顺序消息：消息按照严格的顺序存入同一个 Queue，消费时必须按顺序读取。
• 分区顺序消息：同一 Key 的消息会进入相同的队列，保证局部有序。

RocketMQ 支持自动重试机制，如果消费者处理失败，可以自动重试。
重试规则：

• 顺序消息：失败后进入 重试队列，直至消费成功。
• 普通消息：默认重试 16 次，失败后进入 死信队列（DLQ）。

• 超过最大重试次数的消息，会进入 死信队列，以防止消息丢失。
• 开发者可以手动处理死信消息，以保证消息最终处理。

• RocketMQ 支持 定时/延迟消息，消息可在固定时间后投递。
• 最多支持 18 级延迟（从 1s 到 2h）。

RocketMQ 独有的分布式事务消息机制，解决分布式事务问题。
事务消息流程：

• 生产者发送半消息，RocketMQ 先存储但不会投递。
• 生产者执行本地事务（如数据库更新）。
• 本地事务成功，发送确认消息，RocketMQ 投递消息。
• 本地事务失败，RocketMQ 丢弃该消息。

• 多 NameServer 结构，支持动态路由和高可用性。
• 主从 Broker 结构，支持 SYNC 和 ASYNC 双写，提高容灾能力。

Kafka 通过 Topic 进行消息分类，一个 Topic 可以有多个 Partition，每个 Partition 都存储一部分 Topic 的数据。

• Topic 被拆分成多个 Partition，可以并行存储，提高吞吐量。
• 每个 Partition 由一个 Leader 和多个 Follower 组成，Leader 负责读写，Follower 负责备份数据。

生产者将消息写入 Kafka，支持 同步（Sync） 和 异步（Async） 发送：

• 同步发送：等待 Broker 确认，保证数据可靠性。
• 异步发送：不等待 Broker 响应，适用于高吞吐场景。

消费者从 Broker 读取消息，支持两种消费模式：

• 拉取模式（Pull）：消费者主动拉取消息（Kafka 默认）。
• 推送模式（Push）：Kafka 主动推送消息（Kafka 默认不采用）。

• 多个 Consumer 可以组成 Consumer Group，共同消费 Topic 的数据。
• 同一个 Partition 只能被一个 Consumer 消费，避免重复消费。

Kafka 通过 Offset 记录 Consumer 消费的位置，防止消息丢失。
Offset 存储方式：

• 默认存储在 Kafka，高效可靠（推荐）。
• 存储在 Zookeeper，适用于早期版本 Kafka。

• Kafka 集群中的 每台服务器就是一个 Broker。
• 多个 Broker 组成 Kafka 集群，提供高可用和负载均衡。
• Leader-Follower 机制：每个 Partition 有一个 Leader，多个 Follower 进行数据备份。

• Kafka 使用磁盘顺序写入，并结合零拷贝（Zero Copy） 提高吞吐量。
• 支持批量发送和压缩，减少网络开销。

• Kafka 通过 ISR（同步副本集） 确保数据一致性。
• 支持多副本（Replication）机制，保证数据高可用。

• Kafka 采用 Partition 进行数据分片，支持水平扩展。
• 多 Broker 结构，避免单点故障。

Kafka 支持事务，确保消息的精确一次（Exactly Once）投递。

Kafka 只能保证 Partition 内部有序，但不能保证全局有序。
解决方案：

• 使用单 Partition，保证全局有序（影响吞吐）。
• 基于 Key 进行 Hash 分区，保证同一 Key 进入相同 Partition。

• Kafka 消息存储在 Segment 文件 中，每个 Partition 由多个 Segment 组成。
• Kafka 使用 PageCache 进行缓存，减少磁盘 IO 访问，提高性能。

Kafka 提供两种消息删除策略：

• 基于时间删除（log.retention.hours）：默认保留 168 小时（7 天）。
• 基于大小删除（log.retention.bytes）：当 Partition 超过阈值时，删除旧数据。

优点：

• 解耦：系统间通信解耦，提高扩展性。
• 削峰填谷：缓解高并发请求压力，防止数据库崩溃。
• 异步处理：提高系统吞吐量，优化响应时间。

缺点：

• 增加复杂度：涉及消息可靠性、重复消费、幂等性等问题。
• 系统可用性降低：MQ 本身是依赖组件，宕机会影响业务。
• 一致性问题：需要保证分布式事务或最终一致性。

生产者端：

• 开启 事务机制 或 ACK 确认机制，确保消息成功发送到 MQ。

MQ 端：

• 持久化存储（磁盘/数据库），防止数据丢失。
• 主从备份，Kafka 的 ISR 机制保证副本同步。

消费者端：

• 手动 ACK 确认消费，防止消息丢失。

消费者端处理：

• 幂等性设计（如数据库去重、基于 Redis 记录已消费消息）。
• 使用全局唯一 ID（如业务 ID 或 UUID）。

MQ 端：

• RabbitMQ 使用 ACK 机制，确保消息被正确处理后再删除。

• Kafka：通过单 Partition 顺序写入，保证 Partition 内部消息有序。
• RocketMQ：支持全局有序队列，基于单一队列模式实现顺序消费。
• RabbitMQ：默认不保证消息顺序，但可以通过 FIFO 队列和 Message Group 解决。

• Kafka：采用 ISR（同步副本）机制，分区 Leader 宕机时，Follower 自动提升为 Leader。
• RabbitMQ：主从模式（镜像队列），主节点挂掉时，从节点接管。
• RocketMQ：多主多从模式，主从间同步数据，支持自动 Failover。

• 顺序写入磁盘（减少随机 IO）。
• 使用 PageCache 进行文件缓存，减少磁盘访问。
• 支持批量发送和压缩，减少网络开销。

• 数据存储在 Segment 文件中，每个 Partition 由多个 Segment 组成。
• Kafka 采用 PageCache 提高读写效率。

• 生产端：acks=all 确保消息写入所有副本。
• Broker 端：ISR 机制（同步副本），防止数据丢失。
• 消费者端：手动提交 Offset，防止消息丢失。

• 直连（Direct）交换机：点对点投递消息。
• 广播（Fanout）交换机：将消息广播到所有绑定队列。
• 主题（Topic）交换机：支持模糊匹配路由（#、*）。

• 设置 TTL（Time-To-Live）超时机制，自动转移到死信队列。
• 消息被 多次拒绝（rejected），也会进入死信队列。

• JDBC 存储（数据库）。
• KahaDB 存储（默认，性能较好）。
• 内存存储（适用于短期任务）。

使用 XA 事务，支持 2PC（两阶段提交） 确保数据一致性。

支持 Try-Confirm-Cancel 事务机制，生产者提交消息后，RocketMQ 先存储 半消息，消费者确认消费后，才正式提交。

通过 定时队列 + 时间轮，实现延迟级别消费。

在这一阶段，MySQL 会对 SQL 查询进行语法检查，以确认 SQL 语法是否正确。MySQL 会使用 语法分析器（Parser） 来进行此步骤。解析过程包括以下几个步骤：

词法分析（Lexical Analysis）：将查询字符串拆分成一系列的标记（Token），例如关键词、标识符、常量等。
语法分析（Syntax Analysis）：将这些标记组成一个语法树（Parse Tree），并检查 SQL 语句的语法是否符合 MySQL 的 SQL 语法规则。
如果 SQL 语法无误，解析器会将其转换为 内部表示，通常是 抽象语法树（AST） 或 查询树。

接下来，MySQL 会将查询交给 查询优化器（Optimizer）。在这个阶段，优化器的目标是选择一种执行计划，使得 SQL 查询能够高效执行。优化器会考虑以下几个因素：

查询重写（Query Rewrite）：通过重写查询来提升执行效率，例如将子查询转换为连接等。
成本估算：计算不同执行计划的成本，选择一个最优的执行计划。成本估算会根据表的索引、表的大小、数据分布等因素来做出选择。
执行计划生成：生成一个执行计划，通常是 访问路径 的选择，例如全表扫描、索引扫描、联合索引等。
优化器最终会选择一个执行计划，并将其传递给执行引擎。

根据优化器选择的执行计划，MySQL 会调用相应的执行引擎（如 InnoDB、MyISAM）来实际执行查询。这一阶段包括：

获取数据：MySQL 会从磁盘或缓存中获取所需数据。
索引查找：如果查询使用了索引，MySQL 会通过索引查找数据，避免全表扫描。
数据处理：执行查询中所涉及的任何计算、连接、排序、聚合等操作。

MySQL 的 Buffer Pool 是 InnoDB 存储引擎的一个重要组成部分，用于缓存数据页、索引页以及其他内存中的数据结构。其主要目的是减少磁盘 I/O，提高数据库的性能。

在 InnoDB 存储引擎 中，Buffer Pool 是一个内存区域，用来存储和缓存从磁盘读取的数据。当一个查询请求数据时，InnoDB 会先在 Buffer Pool 中查找所需的数据页，如果没有找到（即发生了 缓存未命中），则会从磁盘加载数据到 Buffer Pool 中并进行访问。

Buffer Pool 是通过多个 数据页（data pages） 组织起来的。每个数据页通常为 16KB，MySQL 会根据内存的大小将 Buffer Pool 划分为多个页，每个页可以缓存数据库表中的一部分数据。内存管理的基本单位就是这些数据页。

1、减少磁盘 I/O：通过将频繁访问的数据缓存到内存中，避免每次都从磁盘读取数据，从而提高性能。
2、加速查询响应时间：提高数据读取速度，尤其是当查询涉及到大量数据访问时，能够显著降低查询的延迟。
3、缓存数据页：除了普通的表数据外，Buffer Pool 还缓存索引页、redo log 和其他元数据结构，进一步提高了系统的整体性能。

1、数据页（Data Pages）：存储实际的表数据。
2、索引页（Index Pages）：存储表的索引信息。包括 B+ 树索引、聚集索引等。
3、Insert Buffer：用于加速对索引的写入操作，主要用于二级索引的插入。
4、Adaptive Hash Index：为了加速某些查询，InnoDB 会基于查询的访问模式自动创建哈希索引，并存储在 Buffer Pool 中。
5、双写缓冲（Doublewrite Buffer）：写入数据前，先写入 Buffer Pool，再写入磁盘。这可以避免因崩溃导致的数据损坏。

1、查询缓存：当有查询请求时，InnoDB 会首先检查该查询所需的数据页是否已经存在于 Buffer Pool 中。如果存在（缓存命中），则直接从内存中读取数据。
2、缓存未命中：如果数据页不在 Buffer Pool 中，InnoDB 会从磁盘中读取相应的数据，并将其存入 Buffer Pool。之后，查询将从内存中获取数据。
3、脏页（Dirty Pages）：如果对数据进行了修改，Buffer Pool 中相应的数据页会被标记为脏页，表示该页的数据与磁盘上的数据不一致。脏页会定期刷新（写回）到磁盘中。
4、刷新脏页（Flush）：InnoDB 会定期将脏页写回磁盘，这个过程称为 刷脏（Flush Dirty Pages）。在写回过程中，InnoDB 会遵循一定的策略来保证数据的一致性和高效性。

表空间号+数据页号作为key，缓存页地址作为value

内存管理

Buffer Pool Dumping

lru链表

简单lru链表带来的问题

冷热数据分离lru链表

回滚日志

事务没有提交前，mysql宕机不会丢失数据，因为事务还没有提交

innodb_flush_log_at_trx_commit

innodb特有日志

表空间号+数据页号+偏移量+修改几个字节的值+具体的值

归档日志

sync_binglog

基于binglog和redolog完成事务的提交

变长字段的长度列表、null值列表、数据头、column01的值、column02的值、column0N的值、

B+ 树索引基础

索引页分裂的触发

页分裂的过程

索引页分裂的影响

如何优化和减少页分裂

描述

B+树的基本概念

B+树的基本特点：

B+树的结构

B+树的工作原理

B+树与B树的区别

B+树的优势

B+树在 MySQL 中的应用

总结

回表的基本概念

回表操作的流程

回表的步骤

为什么回表会影响性能

避免回表的优化策略

总结

描述

什么是覆盖索引？

覆盖索引的工作原理

什么时候可以使用覆盖索引

覆盖索引的例子

覆盖索引的优势

如何创建覆盖索引

覆盖索引的注意事项

总结

描述

查询的类型和模式

选择索引列

索引的选择性（Cardinality）

复合索引与单列索引

索引的类型

索引的维护和更新成本

查询优化和执行计划

多列索引与单列索引的权衡

结论

自动生成唯一标识符

提高查询性能

避免人为错误

简化数据迁移和备份

避免“全局唯一”生成的复杂性

数据一致性和顺序性

与外键的兼容性

适合大多数应用场景

避免锁竞争和性能瓶颈

便于与其他系统集成

总结：自增主键的优势

何时避免使用自增主键

总体来说，自增主键 是一种高效、简洁且广泛适用的主键设计方式，适用于大多数场景，尤其是在单机环境或传统关系型数据库设计中。

描述

使用了 OR 条件

函数或表达式中的列

模糊查询（LIKE）开头有通配符

IS NULL 或 IS NOT NULL

多列索引列的顺序不匹配

索引列的类型不匹配

使用 DISTINCT 或 ORDER BY 与索引不匹配

使用了 LIMIT 和不合适的索引

表的 LOCK 或 TRANSACTION 锁定

表的统计信息过期或不准确

总结

描述

IN 操作符与索引

OR 操作符与索引

IN 和 OR 对比

索引优化建议

总结

为了确保索引的有效利用，设计查询时应该尽量避免复杂的 OR 条件和过多的函数或表达式，合理选择合适的索引来优化查询性能。

多个事务同时执行可能出现的问题

读已提交

读未提交

可重复读

串行化

spring事务设置mysql隔离级别

undolog版本链

readview

MySQL 锁是保证数据库事务一致性、并发性和隔离性的关键机制。锁的使用可以防止多个事务对同一数据进行并发访问时发生冲突或导致数据不一致。

锁可以分为 表级锁 和 行级锁，以及 共享锁 和 排他锁 等类型。锁的主要作用是限制并发访问数据的方式，以保证数据一致性、完整性，并且避免出现脏读、不可重复读和幻读等问题。

表级锁是 MySQL 中最简单的一种锁类型，它锁住整个表，避免其他事务对该表的操作。表级锁有以下几种：

共享锁（S 锁，Shared Lock）：

• 用途：允许事务读取数据，但不允许其他事务修改数据。
• 操作：当一个事务持有共享锁时，其他事务也可以对该数据加共享锁，但不能加排他锁，保证了数据的安全读取。

例子：
SELECT * FROM employees WHERE department_id = 1 LOCK IN SHARE MODE;

排他锁（X 锁，Exclusive Lock）：

• 用途：排他锁会锁住数据，阻止其他事务对该数据进行任何操作（包括读取和修改）。
• 操作：当事务持有排他锁时，其他事务不能对该行数据加任何类型的锁，直到当前事务释放该锁。

例子：
SELECT * FROM employees WHERE department_id = 1 FOR UPDATE;
排他锁常用于 UPDATE、DELETE 或 SELECT ... FOR UPDATE 中，它确保在事务执行时，数据不会被其他事务修改。

行级锁是 MySQL 在 InnoDB 存储引擎中使用的锁类型，它只会锁住特定的行，而不是整张表。这种锁的粒度较细，能够实现更高的并发访问。

行级锁优点：

• 提高并发性：行级锁允许多个事务同时对同一表的不同记录进行操作，减少锁竞争，提高并发性能。

行级锁的实现：

• 范围锁：行级锁不仅锁定当前行，还会锁定满足条件的其它行，通常是通过条件范围来锁定。例如，使用 WHERE 子句时，会锁定匹配的行。
• 间隙锁（Gap Lock）：为了避免出现幻读，InnoDB 会在某些情况下锁定记录之间的间隙。

例子：
SELECT * FROM employees WHERE department_id = 1 FOR UPDATE;

意向锁是 InnoDB 存储引擎的一种特殊锁，它并不直接锁定数据，而是表示当前事务对某些数据的锁定意图。意向锁主要用来解决表级锁和行级锁之间的冲突问题。

• 意向共享锁（IS 锁）：事务打算对某些行加共享锁时，会先加意向共享锁。
• 意向排他锁（IX 锁）：事务打算对某些行加排他锁时，会先加意向排他锁。

意向锁可以有效地判断事务是否需要对表进行更高级的锁操作，从而避免了表级锁与行级锁之间的冲突。

死锁发生在两个或多个事务相互持有对方需要的资源锁，并且都在等待对方释放锁。死锁是并发系统中的常见问题，MySQL 通过死锁检测机制自动处理死锁，它会回滚某个事务来打破死锁。

InnoDB 存储引擎支持行级锁、表级锁、意向锁，并且使用多版本并发控制（MVCC）来实现高并发的事务隔离。

• MVCC（多版本并发控制）：每次事务都会创建数据的一个版本，这样读取操作不会被写入操作阻塞，避免了读写冲突。每个事务只会看到它自己的数据版本，直到提交或回滚为止。

InnoDB 锁的类型

InnoDB 锁的兼容性

MySQL 支持四种事务隔离级别，不同的隔离级别会对锁的使用方式产生影响。

读未提交（READ UNCOMMITTED）：

读已提交（READ COMMITTED）：

可重复读（REPEATABLE READ）：

串行化（SERIALIZABLE）：

描述

避免锁冲突的策略

避免死锁

MySQL 提供了一些工具和命令，用于查看当前的锁信息以及调试锁相关问题。

• 查看当前的锁：
  SHOW ENGINE INNODB STATUS;
  这个命令返回 InnoDB 存储引擎的状态信息，包括当前锁的情况、死锁信息等。

• 查看当前事务的锁：
  SHOW OPEN TABLES WHERE In_use > 0;
  这个命令返回当前被锁定的表和索引。

MySQL 中的锁机制非常复杂，它支持多种类型的锁，包括表级锁、行级锁、意向锁等，并且通过不同的隔离级别和 MVCC 来保证事务

1.1 CPU

• 多核 CPU：MySQL 可以在多核 CPU 上并行执行查询任务，因此，增加 CPU 核心数有助于提高并发查询的处理能力。高主频的 CPU 对于单线程性能要求高的查询也有帮助，尤其是在处理复杂查询时。
• CPU 限制：可以通过 max_connections 限制最大连接数，避免过多的并发连接占用 CPU 资源。

1.2 内存

• 内存大小：增加内存可以有效地提高数据库性能，尤其是对缓存（如 InnoDB Buffer Pool）和查询处理的优化有很大帮助。

配置建议：

• InnoDB Buffer Pool：InnoDB 是 MySQL 的默认存储引擎，innodb_buffer_pool_size 配置项控制 InnoDB 缓存池的大小。通常，建议将其设置为系统总内存的 60%-80%，这样可以确保大多数数据和索引都能放入内存中，从而减少磁盘 I/O。
• Query Cache：对于频繁执行的相同查询，MySQL 提供查询缓存功能，配置 query_cache_size 来增加查询缓存。

1.3 磁盘 I/O

• 磁盘性能：磁盘的读写速度直接影响到 MySQL 的性能，尤其是涉及大量数据的操作时，磁盘性能至关重要。使用固态硬盘（SSD）比机械硬盘（HDD）能显著提高磁盘 I/O 性能。

配置建议：

• InnoDB 日志文件大小：innodb_log_file_size 配置项设置每个日志文件的大小，较大的日志文件可以减少磁盘 I/O 操作，但会占用更多的内存和磁盘空间。
• RAID 阵列：使用 RAID 10 而不是 RAID 5，可以提高磁盘 I/O 的吞吐量和可靠性。

2.1 InnoDB 配置

• innodb_buffer_pool_size：

说明：这个参数决定了 InnoDB 存储引擎缓存数据和索引的内存大小。对于高负载的数据库，建议将其设置为系统总内存的 60%-80%。
配置示例：
innodb_buffer_pool_size = 16G

• innodb_log_file_size：

说明：决定了每个 InnoDB 日志文件的大小。较大的日志文件能减少日志刷新频率，提升写入性能。
配置示例：
innodb_log_file_size = 512M

• innodb_flush_log_at_trx_commit：

说明：控制事务提交时日志刷新到磁盘的策略。设置为 1 最安全，保证每次事务提交都会将日志写入磁盘。设置为 2 或 0 可以提高性能，但在断电时可能会丢失事务数据。
配置示例：
innodb_flush_log_at_trx_commit = 2

• innodb_flush_method：

说明：设置 InnoDB 刷新数据的方式。通常可以设置为 O_DIRECT，以避免操作系统缓存带来的性能问题。
配置示例：
innodb_flush_method = O_DIRECT

• innodb_file_per_table：

说明：启用该配置后，每个 InnoDB 表会有一个独立的表空间文件，这样有助于提高 I/O 性能并减少表碎片。
配置示例：
innodb_file_per_table = 1

2.2 查询缓存配置

• query_cache_size：

说明：查询缓存可以缓存 SELECT 查询的结果，对于频繁执行相同查询的场景，查询缓存能显著提高性能。
配置示例：
query_cache_size = 128M

• query_cache_type：

说明：控制查询缓存的启用状态。可以设置为 ON、OFF 或 DEMAND（仅对显式 SQL_CACHE 查询生效）。
配置示例：
query_cache_type = ON

2.3 连接和线程配置

• max_connections：

说明：设置 MySQL 数据库最大连接数。如果系统有大量并发连接需求，可以适当调大此值。
配置示例：
max_connections = 500

• thread_cache_size：

说明：控制线程缓存的大小，增大该值可以减少频繁创建和销毁线程的开销。
配置示例：
thread_cache_size = 50

• wait_timeout 和 interactive_timeout：

说明：控制连接空闲时的等待时间。可以根据实际情况设置适当的超时时间。
配置示例：
wait_timeout = 300
interactive_timeout = 300

索引优化

查询语句优化

EXPLAIN 分析查询

避免锁争用

启用慢查询日志可以帮助识别执行时间过长的查询，进而进行优化。

配置示例：
slow_query_log = 1
slow_query_log_file = /var/log/mysql/mysql-slow.log
long_query_time = 2
这样可以记录执行时间超过 2 秒的查询。

性能模式

查看当前状态

MySQL 调优是一个系统化的过程，需要结合硬件资源、MySQL 配置、查询优化和索引设计等多个方面。要保证数据库的高性能，需要根据具体应用的需求和负载特征来进行细致的配置和优化，同时定期监控数据库状态，发现潜在的瓶颈和问题。

调优的核心目标是：

• 提升查询性能：优化查询执行

1.1 概述
InnoDB 是 MySQL 的默认存储引擎，具有事务支持、行级锁、外键支持等高级功能，适用于大多数需要事务处理的应用场景，尤其是OLTP（在线事务处理）系统。

1.2 特点

• 事务支持（ACID）：InnoDB 支持事务，符合 ACID 原则（原子性、一致性、隔离性、持久性）。
• 行级锁：InnoDB 使用行级锁而非表级锁，能够提高高并发情况下的性能。
• 外键支持：InnoDB 支持外键约束，保证数据的一致性和完整性。
• 支持崩溃恢复：InnoDB 使用了写前日志（WAL，Write-Ahead Log）机制，可以在数据库崩溃后通过日志文件恢复数据。
• MVCC（多版本并发控制）：InnoDB 通过使用多版本并发控制（MVCC）来支持高并发读操作，而不阻塞写操作。
• 支持全文索引：InnoDB 支持全文索引，可以加速文本搜索。

1.3 适用场景

• 高并发写操作
• 需要事务支持的应用
• 数据完整性和一致性要求高的场景
• 需要支持外键约束的场景

1.4 性能和配置

• 缓冲池（InnoDB Buffer Pool）：innodb_buffer_pool_size 是 InnoDB 的关键配置，它决定了内存中能缓存多少数据。通常，建议将其设置为系统内存的 60%-80%，以减少磁盘 I/O。
• 日志配置：innodb_log_file_size 和 innodb_log_buffer_size 控制 InnoDB 的日志文件大小和日志缓冲区大小，合理配置这些参数可以提高写入性能。

2.1 概述
MyISAM 是 MySQL 早期的默认存储引擎，适用于读取密集型应用，提供快速的查询响应，但不支持事务和外键。它对简单查询的性能较好，但不适合高并发写入的应用。

2.2 特点

• 不支持事务：MyISAM 不支持事务处理，不符合 ACID 原则，数据一旦写入无法回滚。
• 表级锁：MyISAM 使用表级锁，这在高并发写操作时可能导致性能瓶颈。
• 较高的查询性能：对于读取密集型的应用，MyISAM 提供了比 InnoDB 更好的查询性能，尤其是在简单的 SELECT 查询上。
• 不支持外键：MyISAM 不支持外键约束，数据完整性和一致性不如 InnoDB。
• 压缩表：MyISAM 支持表压缩，可以节省存储空间，适用于存储大量数据且读取频繁的应用。

2.3 适用场景

• 主要以查询为主，写入较少的应用（如日志分析系统、报表系统）
• 存储大量只读数据的场景
• 需要压缩表以节省存储空间的场景

2.4 性能和配置

• 索引缓存（Key Cache）：key_buffer_size 配置项决定了 MyISAM 使用的内存大小来缓存索引数据。设置合适的 key_buffer_size 能提高查询性能。
• 表压缩：MyISAM 提供表压缩功能，可以显著减少磁盘空间的占用，适用于大数据量但查询为主的场景。

3.1 概述
MEMORY 存储引擎（也叫 HEAP 引擎）是一个将数据存储在内存中的引擎，适用于需要快速访问的临时表或者会话级别的数据存储。它的性能极高，但数据在服务器重启后会丢失。

3.2 特点

• 数据存储在内存中：所有数据存储在内存中，极大地提高了访问速度。
• 无持久化存储：数据不会保存在磁盘上，因此 MySQL 重启后数据会丢失。
• 适用于临时数据：适用于快速存取、临时存储的场景，比如缓存、临时计算结果等。
• 表级锁：类似 MyISAM，MEMORY 使用表级锁，不支持行级锁。

3.3 适用场景

• 临时表存储
• 缓存数据存储
• 需要高速访问的会话数据存储

3.4 性能和配置

• 数据类型限制：MEMORY 引擎只能使用定长数据类型（如 CHAR、INT 等），不支持变长数据类型（如 TEXT、BLOB）。
• 大小限制：max_heap_table_size 控制最大内存表的大小，tmp_table_size 控制临时表的大小。

4.1 概述
CSV 存储引擎将每个表的数据存储为一个 CSV 格式的文件，适用于将数据导出或导入到其他系统的场景。它是一个只支持简单查询的存储引擎，不支持索引。

4.2 特点

• 数据以 CSV 格式存储：表数据以纯文本格式存储，可以轻松导入导出。
• 不支持索引：查询性能较低，不适合大数据量的查询操作。
• 适合数据交换：用于与其他系统之间进行数据交换，导入导出操作方便。

4.3 适用场景

• 数据导入导出
• 简单的文件存储系统
• 小规模数据的读取和写入

4.4 性能和配置

• CSV 文件的处理：查询不支持索引，因此性能通常比其他存储引擎差，适用于小规模数据的存储。

5.1 概述
NDB 存储引擎是 MySQL Cluster 的一部分，专为高可用性、高并发和分布式架构设计。它提供了一个分布式的、高可用的数据库集群架构，适用于需要高可用性和高并发的大型在线应用。

5.2 特点

• 分布式架构：NDB 以分布式方式存储数据，可以跨多台机器进行数据存储。
• 高可用性：提供自动故障转移和数据复制，保证系统的高可用性。
• 事务支持：支持事务和 ACID 原则。
• 内存存储：NDB 将数据存储在内存中，提供非常高的访问速度。

5.3 适用场景

• 分布式数据库系统
• 高可用性、高并发、大规模的数据存储
• 实时应用，如电信行业、在线游戏、在线金融等

5.4 性能和配置

• 分布式数据：配置 ndb_cluster，可以让多个节点协同工作以处理大规模数据。
• 内存优化：大量使用内存以确保快速的数据存取和查询。

• TokuDB：适用于大规模数据写入的场景，特别是在需要高性能插入和更新操作时，TokuDB 使用 Fractal Tree 索引结构提供更好的性能。
• Aria：MySQL 5.5 引入的存储引擎，旨在替代 MyISAM，提供更高的可靠性和性能，支持事务、行级锁等。

在选择存储引擎时，需要考虑以下因素：

• 事务支持：是否需要事务支持，是否需要 ACID 特性。
• 性能需求：是否需要高并发读写，是否需要支持行级锁。
• 数据一致性：是否需要外键支持，是否需要高可用性

多态（Polymorphism）是面向对象编程（OOP）的三大特性之一（封装、继承、多态）。它允许相同的接口以不同的方式执行，主要用于提高代码的可扩展性和维护性。 多态的核心思想是**“一个接口，多种实现”**，即同一方法在不同对象上表现出不同的行为。

Java 中的多态主要分为**编译时多态（静态绑定）和运行时多态（动态绑定）**两种。

1、编译时多态（方法重载 - Overloading）
编译时多态是通过方法重载（Method Overloading）实现的，即相同的方法名，但参数列表不同（参数个数、类型或顺序不同）。

示例：
class MathUtils {
    // 两个参数的加法
    int add(int a, int b) {
        return a + b;
    }

    // 三个参数的加法
    int add(int a, int b, int c) {
        return a + b + c;
    }

    // 浮点数加法
    double add(double a, double b) {
        return a + b;
    }
}

public class TestOverloading {
    public static void main(String[] args) {
        MathUtils mu = new MathUtils();
        System.out.println(mu.add(2, 3));       // 调用 int add(int, int)
        System.out.println(mu.add(2, 3, 4));    // 调用 int add(int, int, int)
        System.out.println(mu.add(2.5, 3.2));   // 调用 double add(double, double)
    }
}
特点：

• 方法名相同，参数列表不同（参数个数、类型或顺序不同）。
• 返回类型可以不同，但不能单独以返回类型区分方法重载。
• 方法调用时，编译器会根据参数匹配合适的方法，所以它在编译时就能确定调用哪个方法（静态绑定）。

2、运行时多态（方法重写 - Overriding）
运行时多态是通过**方法重写（Method Overriding）**实现的，子类重写父类的方法，并且使用父类的引用指向子类对象时，会执行子类的重写方法。

• 方法重写的规则
• 方法名、参数列表必须相同。
• 返回类型：可以是父类方法返回类型的子类型（协变返回类型，JDK 5 之后支持）。
• 访问权限：
  子类方法的访问权限不能比父类更严格（如：父类方法是 public，子类不能降级为 protected 或 private）。
  只能重写非 static 方法（static 方法属于类，不属于实例，不能被重写）。

• @Override 注解（可选但推荐），可以让编译器检查是否正确重写了方法。

示例：
class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("狗叫：汪汪！");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("猫叫：喵喵！");
    }
}

public class TestOverriding {
    public static void main(String[] args) {
        Animal myAnimal1 = new Dog();  // 向上转型（父类引用指向子类对象）
        Animal myAnimal2 = new Cat();  

        myAnimal1.makeSound();  // 输出：狗叫：汪汪！
        myAnimal2.makeSound();  // 输出：猫叫：喵喵！
    }
}
特点：

• 方法调用在运行时决定，属于动态绑定（Dynamic Binding）。
• 通过父类的引用指向子类对象，调用的方法是子类重写后的方法，而不是父类的方法。

在运行时多态中，我们通常会涉及向上转型（Upcasting）和向下转型（Downcasting）。

（1）向上转型（Upcasting）
向上转型是子类对象赋值给父类引用，这样可以屏蔽子类的特有方法，增强代码的通用性。

Animal a = new Dog(); // 向上转型
a.makeSound();  // 调用的是 Dog 的 makeSound() 方法
特点：

只能调用父类中被子类重写的方法，无法调用子类特有的方法。
编译时检查类型安全，确保父类引用可以指向子类。
（2）向下转型（Downcasting）
向下转型是父类引用重新转换为子类引用，通常需要强制类型转换。

Animal a = new Dog(); // 向上转型
Dog d = (Dog) a;  // 向下转型
d.makeSound(); // 调用 Dog 的 makeSound()

注意：
必须确保父类引用指向的是实际的子类对象，否则会抛出 ClassCastException。
使用 instanceof 关键字确保安全转换：

if (a instanceof Dog) {
    Dog d = (Dog) a;
    d.makeSound();
}

多态的核心在于面向接口编程，在 Java 中，抽象类和接口也可以实现多态。

（1）抽象类实现多态
abstract class Animal {
    abstract void makeSound(); // 抽象方法
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("狗叫：汪汪！");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("猫叫：喵喵！");
    }
}

public class TestAbstract {
    public static void main(String[] args) {
        Animal a = new Dog();  // 向上转型
        a.makeSound();  // 狗叫：汪汪！
    }
}
（2）接口实现多态
interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("狗叫：汪汪！");
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("猫叫：喵喵！");
    }
}

public class TestInterface {
    public static void main(String[] args) {
        Animal a = new Dog();  // 接口引用指向子类对象
        a.makeSound();  // 狗叫：汪汪！
    }
}

• 编译时多态（方法重载）：方法名相同，参数不同，编译时绑定。
• 运行时多态（方法重写）：子类重写父类方法，通过父类引用调用子类方法，运行时绑定。
• 向上转型：子类对象赋值给父类引用，可调用父类的方法。
• 向下转型：将父类引用强制转换回子类，需要 instanceof 进行类型检查。
• 抽象类和接口提供了一种更灵活的多态实现方式。

多态的最大优势是提高代码的可扩展性和可维护性，在实际开发中应充分利用。

一、多态 1、定义：可以理解为事物存在的多重体现形态。 2、多态的体现 父类的引用指向了直接的子类对象。 父类的引用可以接收自己的子类对象。 3、多态的好处 多态的出现提高了程序的扩展性。 4、多态的前提 必须是类与类之间必须有关系，要么继承，要么实现。 通常还有一个前提：存在覆盖。 5、多态中成员的特点： a:在多态中成员函数的特点： 1）、在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有编译通过，没有失败； 2）、在运行时期：参阅对象所属的类中是否有调用的方法。 简单总结：成员函数在多态调用时，编译看左边，运行看右边。 b：在多态中，成员变量的特点： 无论编译和运行，都参考左边（引用型变量所属的类）。 c：在多态中，静态成员函数的特点： 无论编译和运行，都参考左边。

Object 是 Java 中所有类的父类，位于 java.lang 包中。Java 中的所有类默认继承 Object 类（如果没有显式继承其他类）。因此，每个 Java 对象都可以使用 Object 类提供的方法。

（1）默认实现
Object 类中的 equals() 方法比较的是对象的引用地址，即是否指向同一个对象。

class A {}

public class TestEquals {
    public static void main(String[] args) {
        A obj1 = new A();
        A obj2 = new A();
        A obj3 = obj1;

        System.out.println(obj1.equals(obj2)); // false，不是同一对象
        System.out.println(obj1.equals(obj3)); // true，引用相同
    }
}
（2）重写 equals()（基于内容比较）
在实际开发中，我们通常需要比较对象的内容，因此需要重写 equals() 方法。

示例：
class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true; // 同一个对象
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
}

public class TestEqualsOverride {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        Person p2 = new Person("Alice", 25);
        Person p3 = new Person("Bob", 30);

        System.out.println(p1.equals(p2)); // true，内容相同
        System.out.println(p1.equals(p3)); // false，内容不同
    }
}
重写 equals() 方法的要点：

• 自反性：x.equals(x) 必须返回 true。
• 对称性：x.equals(y) 返回 true，则 y.equals(x) 也必须返回 true。
• 传递性：x.equals(y) 且 y.equals(z)，则 x.equals(z) 也必须返回 true。
• 一致性：多次调用 equals() 方法，结果应保持一致（除非对象属性改变）。
• 与 null 比较：x.equals(null) 必须返回 false。

hashCode() 方法返回对象的哈希码，通常用于哈希表（HashMap、HashSet 等）。

（1）默认实现
Object 的 hashCode() 方法基于对象的内存地址计算哈希值。

class A {}

public class TestHashCode {
    public static void main(String[] args) {
        A obj1 = new A();
        A obj2 = new A();

        System.out.println(obj1.hashCode()); // 可能是 12345678
        System.out.println(obj2.hashCode()); // 可能是 87654321
    }
}

（2）重写 hashCode()
如果重写 equals() 方法，也必须重写 hashCode() 方法，否则会影响 HashMap、HashSet 等数据结构的正确性。

示例（与 equals() 结合）：
import java.util.Objects;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class TestHashCodeOverride {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        Person p2 = new Person("Alice", 25);

        System.out.println(p1.hashCode()); // 相同哈希值
        System.out.println(p2.hashCode()); // 相同哈希值
    }
}
hashCode() 方法的要求：

• 相等的对象 equals() 返回 true，它们的 hashCode() 必须相同。
• 不同的对象 hashCode() 可以相同，但尽量减少哈希冲突。
• 使用 Objects.hash() 方法简化哈希计算。

（1）默认实现
默认 toString() 方法返回 "类名@十六进制内存地址"。

class A {}

public class TestToString {
    public static void main(String[] args) {
        A obj = new A();
        System.out.println(obj.toString()); // A@1a2b3c4d
    }
}
（2）重写 toString()
toString() 通常用于打印对象信息，应在自定义类中重写。

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class TestToStringOverride {
    public static void main(String[] args) {
        Person p = new Person("Alice", 25);
        System.out.println(p); // 自动调用 toString() 方法
    }
}

getClass() 返回对象的运行时 Class 对象。

class A {}

public class TestGetClass {
    public static void main(String[] args) {
        A obj = new A();
        System.out.println(obj.getClass()); // class A
    }
}

clone() 用于对象克隆，但类必须实现 Cloneable 接口，否则会抛 CloneNotSupportedException。

class Person implements Cloneable {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class TestClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person("Alice");
        Person p2 = (Person) p1.clone();
        System.out.println(p2.name); // Alice
    }
}

• equals() 和 hashCode() 需同时重写。
• toString() 用于输出对象信息，建议重写。
• getClass() 获取对象的运行时类型。
• clone() 需要实现 Cloneable 接口。
• wait() 和 notify() 用于线程同步。

Object 类是 Java 最基础的类，掌握它可以提升 Java 开发能力。

static 修饰的变量属于类而不是实例。所有实例共享这个静态变量，而不是每个实例都有自己的一份。

特点：

• static 变量在内存中只有一份，所有对象共享这份数据。
• 它们在类加载时就已经分配内存，并且在整个程序运行期间都存在，直到程序结束。

static 方法是属于类的，而不是属于类的某个实例。static 方法不能直接访问实例变量和实例方法，只能访问静态变量和静态方法。

特点：

• 静态方法可以在没有创建类的实例时调用。
• 静态方法不能访问非静态（实例）成员（变量和方法）。
• 静态方法可以通过类名直接访问。

static 块是一种特殊的代码块，它用于初始化静态变量。静态块只会在类第一次加载时执行一次，通常用于静态变量的初始化。

特点：

• 静态块在类加载时执行一次，用于执行一些初始化操作。
• 只会执行一次，不会随着对象的创建多次执行。

在 Java 中，我们可以将类声明为静态内部类。静态内部类是属于外部类的一部分，但不依赖于外部类的实例。静态内部类可以直接访问外部类的静态成员。

特点：

• 静态内部类可以访问外部类的静态成员，但不能访问外部类的实例成员。
• 静态内部类可以独立于外部类的实例化而存在。
• 静态内部类的实例可以通过外部类直接创建，无需创建外部类的实例。

2.1 优点

• 内存共享：静态成员（变量和方法）在所有类的实例中共享，节省内存空间。
• 无需创建对象：通过类名直接访问静态方法和静态变量，无需实例化对象。
• 简化代码：静态方法有助于封装不依赖于对象状态的功能，例如工具类中的方法。

2.2 缺点

• 难以测试和扩展：静态方法和静态变量在程序中很难进行替换和扩展，过多使用静态成员会导致程序设计变得不灵活。
• 全局状态：静态变量属于类本身，共享状态，这可能导致全局变量问题，尤其是在多线程环境中。
• 隐藏依赖性：静态方法无法访问实例成员，这限制了其灵活性和扩展性。

当多个线程访问相同的静态变量时，可能会出现线程安全问题。静态变量在所有对象中共享，如果多个线程同时修改静态变量的值，可能会导致数据不一致。为了确保线程安全，可以使用 synchronized 关键字来保护静态方法，或使用 java.util.concurrent 包中的工具类来保证线程安全。

public class Counter {
    static int count = 0;

    public synchronized static void increment() {
        count++;
    }
}
通过 synchronized 关键字，我们可以确保多个线程在执行 increment 方法时不会同时修改静态变量 count，从而避免竞态条件。

• static 关键字使得变量、方法、代码块或内部类属于类本身，而不是某个特定对象。
• 使用 static 时可以节省内存并简化代码，但要注意它带来的限制，尤其是对灵活性和扩展性的影响。
• static 变量和方法在整个程序生命周期内共享，适用于无需依赖实例状态的功能。

一、static（静态）关键字 1、用法： 是一个修饰符，用于修饰成员（成员变量，局部变量） 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用，类名.静态成员。 2、特点 a、随着类的加载而加载。    也就是说：静态会随着类的消失而消失。说明它的生命周期最长。 b、优先于对象存在。    明确一点：静态是先存在的，对象是后存在的。 c、被所有对象所共享。 d、可以直接被类名所调用。 3、实例变量（成员变量）和类变量（静态变量）的区别 a、存放位置：    类变量随着类的加载而存在于方法区中。    实例变量随着对象的建立而存在于堆内存中。 b、生命周期：    类变量生命周期最长，随着类的消失而消失。    实例变量生命周期随着对象的消失而消失。 4、静态使用注意事项 a、静态方法只能访问静态成员。    非静态方法既可以访问静态也可以访问非静态。 b、静态方法中不可以定义this， super关键字。    因为静态优先于对象存在，所以静态方法中不可以出现this。 c、主函数是静态的。 5、静态有利有弊 利处： 对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份。 可以直接被类名调用。 弊端： 生命周期过长。 访问出现局限性。（静态虽好，只能访问静态） 二、main函数 public static void main(String[] args) 主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。 定义： public：代表着该函数访问权限最大的。 static：代表着主函数随着类的加载就已经存在了。 void：主函数没有具体的返回值。 main：不是关键字，但是是一个特殊的单词，可以被jvm识别。 (String[] args)：主函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型元素的数组。 主函数是固定格式的：jvm识别。 jvm在调用主函数时，传入的是new String[0]; 三、什么时候使用静态 要从两方面下手：因为静态修饰的内容有成员变量和函数。 1、什么时候定义静态变量（类变量）呢？ 当对象中出现共享数据时，该数据被静态所修饰。 对象中的特有数据要定义成非静态存在于堆内存中。 2、什么时候定义静态函数呢？ 当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。 四、静态的应用 每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。 五、java帮助文档 javadoc -d 目录  -author(作者) -version(版本) 文件名 六、静态代码块 1、格式： static{  静态代码块中的执行语句 } 2、特点： 随着类的加载而执行，只执行一次，并优先于主函数。 用于给类进行初始化的。 3、 static{  静态代码块给类进行初始化 } {  构造代码块给对象进行初始化 } 类名（int x）{  构造函数给对象进行初始化 } 4、初始化顺序 静态代码块  >  构造代码块   >构造函数 七、对象的初始化过程 1、Person p = new Person("zhangsan",20); a、因为new 用到了person.class，所以会先找到Person.class文件加载到内存中。 b、执行该类中的static代码块，如果有的话，给Person.class类进行初始化。 c、在堆内存中开辟空间，分配内存地址。 d、在堆内存中建立对象的特有属性，并进行默认初始化。 e、对属性进行显示初始化。 f、对对象进行构造代码块初始化。 g、对对象进行对应的构造函数初始化。 h、将内存地址赋给栈内村中的p变量。 八、设计模式 1、定义：解决某一类问题最行之有效的方法。 2、单例设计模式：解决一个类在内存中只存在一个对象。 想要保证对象唯一： a、为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。 b、为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。 c、为了方便其他程序对自定义对象对的访问，可以对外提供一些访问方式。 这三步代码体现： a、将构造函数私有化。 b、在类中创建一个本类对象。 c、提供一个方法可以获取到该对象。 对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将这三步加上即可。 这个是先初始化对象。称为：饿汉式。 Single类一进内存，就已经创建好了对象。 class Singel{  privae static Single s = new Single();  private Singe(){};  public static Single getInstance(){   return s;  } } 这个是方法被调用时，才初始化，也叫作对象的延时加载。称为：懒汉式。 Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。 懒汉式和饿汉式有什么不同？ 懒汉式的特点是延迟加载，多线程访问延迟加载会出现安全问题，可以用同步函数和同步代码块，缺点是有点低效。可以用双重判断解决效率问题。加同步的时候使用的锁是该类所属的文件字节码对象。 class Single{  private static Single s = null;  private Single(){};  public static Single getInstance(){   if(s == null){    synchronized(Single.class){     if(s == null){      s = new Single();     }    }   }   return s;  } } 定义单例，建议使用饿汉式。

在 Java 中，**内部类（Inner Class）**是定义在另一个类内部的类。它与外部类紧密关联，通常用于表示一个依赖于外部类或封装外部类功能的类。内部类可以访问外部类的成员（包括私有成员），从而提高了封装性和可维护性。

Java 中的内部类有多种类型，每种类型的内部类在语法和使用场景上有所不同。下面将详细介绍不同类型的内部类及其特点。

成员内部类是定义在外部类内部，作为外部类的一个成员存在。它与外部类的实例关联，可以访问外部类的所有成员（包括私有成员）。

1.1 成员内部类的特点

• 成员内部类可以访问外部类的实例成员（字段和方法）。
• 成员内部类需要通过外部类的实例来创建，不能直接通过外部类的类名来创建。
• 成员内部类不能定义静态成员（字段、方法等），因为它依赖于外部类的实例。

1.2 示例
public class OuterClass {
    private String outerField = "Outer Field";

    // 成员内部类
    class InnerClass {
        void display() {
            System.out.println("Accessing outer field: " + outerField);
        }
    }

    public static void main(String[] args) {
        // 创建外部类对象
        OuterClass outer = new OuterClass();
        
        // 创建成员内部类对象
        OuterClass.InnerClass inner = outer.new InnerClass();
        
        inner.display();  // Output: Accessing outer field: Outer Field
    }
}
在上面的代码中，InnerClass 是一个成员内部类。它可以访问外部类 OuterClass 的私有成员 outerField。

静态内部类是定义为静态的内部类，它与外部类的实例无关，属于外部类的类本身。静态内部类只能访问外部类的静态成员。

2.1 静态内部类的特点

• 静态内部类不需要外部类的实例即可创建。
• 静态内部类只能访问外部类的静态成员（静态字段和静态方法）。
• 静态内部类可以定义静态成员（字段、方法等），这是成员内部类不能做到的。

2.2 示例
public class OuterClass {
    private static String staticOuterField = "Static Outer Field";

    // 静态内部类
    static class StaticInnerClass {
        void display() {
            System.out.println("Accessing static outer field: " + staticOuterField);
        }
    }

    public static void main(String[] args) {
        // 直接通过外部类类名创建静态内部类的实例
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        
        inner.display();  // Output: Accessing static outer field: Static Outer Field
    }
}
在这个例子中，StaticInnerClass 是一个静态内部类，它不需要外部类的实例就可以创建，并且它只能访问外部类的静态成员。

局部内部类是在方法或代码块内部定义的类。它的作用域仅限于方法或代码块中，类似于局部变量。局部内部类不能被外部访问，只能在定义它的方法或代码块内部使用。

3.1 局部内部类的特点
不能在方法外部创建局部内部类的实例。
局部内部类可以访问方法中的局部变量和参数，但局部变量必须是 final 或等效于 final，即值不可改变。
局部内部类的生命周期与方法或代码块的执行周期一致。

3.2 示例
public class OuterClass {
    void method() {
        // 局部内部类
        class LocalInnerClass {
            void display() {
                System.out.println("This is a local inner class");
            }
        }

        // 创建局部内部类的对象
        LocalInnerClass inner = new LocalInnerClass();
        inner.display();  // Output: This is a local inner class
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.method();  // 调用方法，创建局部内部类的对象
    }
}
在这个例子中，LocalInnerClass 是一个局部内部类，它只在 method() 方法中有效，并且不能在外部直接创建。

匿名内部类是没有名字的内部类，通常用于实现接口或继承类。匿名内部类通常在需要临时创建一个类并且不打算重用时使用。

4.1 匿名内部类的特点
匿名内部类没有类名，通常用于快速实现一个接口或继承一个类。
它是直接在创建时实例化的，通常用来实现接口或继承抽象类。
匿名内部类只能有一个实例，且不能定义构造方法。

4.2 示例
public class OuterClass {
    void method() {
        // 匿名内部类实现接口
        Runnable r = new Runnable() {
            public void run() {
                System.out.println("This is an anonymous inner class");
            }
        };

        r.run();  // Output: This is an anonymous inner class
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.method();  // 调用方法，执行匿名内部类
    }
}
在这个例子中，匿名内部类实现了 Runnable 接口，直接在方法中创建并使用。它没有名字，通常用于临时实现接口或抽象类。

• 成员内部类：可以访问外部类的所有成员（包括私有成员），但外部类不能直接访问内部类的成员。
• 静态内部类：可以访问外部类的静态成员，但不能访问外部类的实例成员。
• 局部内部类和匿名内部类：可以访问方法中的局部变量，但这些局部变量必须是 final 或等效于 final。

• 封装性：内部类有助于提高类的封装性。通过将类作为内部类，可以确保它只在外部类的上下文中使用，不被外部类以外的代码访问。
• 逻辑组织：内部类适用于一些与外部类紧密关联的功能。通过内部类，外部类可以将它的实现细节隐藏起来，只暴露必要的接口。
• 事件监听：匿名内部类在事件处理（例如 GUI 编程）中非常常见。它允许我们在一个地方同时实现事件监听器并进行事件处理。

• 成员内部类：类定义在外部类内部，可以访问外部类的成员。必须通过外部类的实例来创建。
• 静态内部类：与外部类实例无关，可以独立创建。只能访问外部类的静态成员。
• 局部内部类：定义在方法或代码块内部，生命周期限定在该方法或代码块内。
• 匿名内部类：没有名字的内部类，通常用来快速实现接口或继承类。

内部类提高了代码的封装性和可维护性，适用于很多场景，尤其是需要将某些功能限定在某个类内部时。

在 Core Java 中，异常（Exception）是程序在运行过程中出现的错误。异常处理机制允许开发者在程序发生错误时采取适当的行动，而不是直接终止程序。异常处理主要通过 try, catch, finally, throw, 和 throws 关键字来实现。

Java 中的异常分为两大类：

1. 检查型异常（Checked Exception）
2. 非检查型异常（Unchecked Exception）

Java 的异常类继承自 Throwable 类，Throwable 类有两个主要的子类：

• Error：通常用于表示 Java 虚拟机运行时的严重问题，如内存溢出（OutOfMemoryError）。这些问题通常是不可恢复的。
• Exception：用于表示程序中的异常情况。异常分为检查型和非检查型。

Throwable 类的层次结构如下：
Throwable
│
├── Error
│   ├── OutOfMemoryError
│   └── StackOverflowError
│
└── Exception
    ├── IOException
    ├── SQLException
    ├── RuntimeException
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   └── ArithmeticException
    └── ClassNotFoundException

Java 通过 try, catch, finally 关键字提供异常处理机制，以便开发者能够捕获和处理异常，防止程序崩溃。

Java 允许开发者创建自己的异常类，通常用于业务逻辑中特定的异常情况。自定义异常类需要继承 Exception 或 RuntimeException 类。

语法：
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

例子：
public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            validateAge(15);  // 年龄小于 18
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void validateAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be 18 or older");
        }
        System.out.println("Valid age");
    }
}

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}
在这个例子中，我们创建了一个自定义异常 InvalidAgeException，用于验证年龄是否合法。

• 异常分类：Java 异常分为检查型异常（Checked Exception）和非检查型异常（Unchecked Exception）。
• 异常处理：通过 try-catch、finally、throw 和 throws 来捕获、处理、抛出和声明异常。
• 自定义异常：开发者可以创建自定义异常类来表示特定的异常情况。
• 异常的最佳实践：
  
• 捕获并处理必要的异常，不要盲目捕获所有异常。
• 使用特定的异常类型（例如 IOException、SQLException）进行精确处理。
• 异常信息应尽量清晰，方便后期排查问题。

1、声明数组
数据类型[] 数组名;  // 推荐写法
数据类型 数组名[];  // 兼容 C 风格，但不推荐
示例：
int[] arr;  // 推荐
int arr[];  // 也可以，但不推荐

2、分配内存
数组名 = new 数据类型[数组长度];
示例：
arr = new int[5];  // 创建一个长度为 5 的 int 数组，默认值为 0

3、声明并初始化
int[] arr = new int[5];  // 默认所有元素为 0
int[] arr2 = {1, 2, 3, 4, 5};  // 直接初始化
int[] arr3 = new int[]{10, 20, 30};  // 另一种初始化方式

4、访问数组元素
System.out.println(arr2[0]);  // 访问索引 0 的元素（1）
arr2[2] = 100;  // 修改索引 2 的值

5、遍历数组
for (int i = 0; i < arr2.length; i++) {
    System.out.println(arr2[i]);
}
增强 for 循环（推荐）
for (int num : arr2) {
    System.out.println(num);
}

1、声明
int[][] matrix;  // 推荐
int matrix[][];  // 兼容 C 语言风格

2、初始化
matrix = new int[3][4];  // 创建 3 行 4 列的二维数组，默认值为 0
或直接初始化：
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

3、访问元素
System.out.println(matrix[1][2]);  // 访问第 2 行第 3 列的元素

4、遍历二维数组
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}
增强 for 循环
for (int[] row : matrix) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

Java 允许创建行数固定，但列数不同的不规则数组。

int[][] jaggedArray = new int[3][];  // 3 行但列数未指定
jaggedArray[0] = new int[2];  // 第一行 2 列
jaggedArray[1] = new int[3];  // 第二行 3 列
jaggedArray[2] = new int[4];  // 第三行 4 列

遍历不规则数组：
for (int i = 0; i < jaggedArray.length; i++) {
    for (int j = 0; j < jaggedArray[i].length; j++) {
        System.out.print(jaggedArray[i][j] + " ");
    }
    System.out.println();
}

1、手动复制
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = new int[arr1.length];

for (int i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i];
}

2、使用 System.arraycopy()
System.arraycopy(arr1, 0, arr2, 0, arr1.length);
参数：

• arr1：源数组
• 0：源数组起始索引
• arr2：目标数组
• 0：目标数组起始索引
• arr1.length：复制的元素个数

3、使用 Arrays.copyOf()
import java.util.Arrays;

int[] arr3 = Arrays.copyOf(arr1, arr1.length);

4、使用 clone()
int[] arr4 = arr1.clone();

1、使用 Arrays.sort()（默认升序）
import java.util.Arrays;

int[] arr = {5, 2, 9, 1, 6};
Arrays.sort(arr);  // 排序后：{1, 2, 5, 6, 9}

2、使用 Arrays.sort(arr, Comparator.reverseOrder())（降序）
import java.util.Arrays;
import java.util.Collections;

Integer[] arr = {5, 2, 9, 1, 6}; // 必须使用 Integer[] 而非 int[]
Arrays.sort(arr, Collections.reverseOrder());

1、遍历查找
int[] arr = {1, 2, 3, 4, 5};
int target = 3;
boolean found = false;

for (int num : arr) {
    if (num == target) {
        found = true;
        break;
    }
}
System.out.println("找到目标元素：" + found);

2、使用 Arrays.binarySearch()（前提是数组必须已排序）
import java.util.Arrays;

int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);
System.out.println("索引：" + index);  // 输出：2

int[] arr = {5, 2, 9, 1, 6}; int max = arr[0]; int min = arr[0]; for (int num : arr) {     if (num > max) max = num;     if (num < min) min = num; } System.out.println("最大值：" + max); System.out.println("最小值：" + min);

import java.util.ArrayList; public class TestArrayList {     public static void main(String[] args) {         ArrayList<String> list = new ArrayList<>();         list.add("Java");         list.add("Python");         list.add("C++");         System.out.println(list.get(1));  // Python         list.remove("C++");         System.out.println(list);  // [Java, Python]     } }

底层实现

特点

适合场景

import java.util.LinkedList; public class TestLinkedList {     public static void main(String[] args) {         LinkedList<Integer> list = new LinkedList<>();         list.add(10);         list.add(20);         list.addFirst(5);         list.addLast(30);         System.out.println(list);  // [5, 10, 20, 30]         list.removeFirst();         System.out.println(list);  // [10, 20, 30]     } }

底层实现

特点

适用场景

底层实现

特点

适用场景

底层实现

特点

适用场景

• 如果你需要频繁的查询操作，并且不关心插入删除的性能，ArrayList 是一个不错的选择。
• 如果你需要频繁在列表的头尾进行插入和删除操作，LinkedList 是更优的选择。
• 如果你需要一个线程安全的 List，并且性能要求不是特别高，可以使用 Vector（不过 CopyOnWriteArrayList 更适合读取操作为主的场景）。
• CopyOnWriteArrayList 是一个很适合读多写少的场景，它的线程安全机制保证了多线程的安全性，但写操作性能相对较差。

根据具体的业务需求，选择合适的实现类可以提高程序的性能。

ArrayList 和 LinkedList 有什么区别？

Vector 和 ArrayList 的区别是什么？

什么是 CopyOnWriteArrayList？它为什么适用于读多写少的场景？

ArrayList 的底层实现原理是什么？

LinkedList 的底层实现原理是什么？

Vector 的底层实现原理是什么？

CopyOnWriteArrayList 的底层实现原理是什么？

ArrayList 和 LinkedList 的扩容机制有什么不同？

ArrayList 和 LinkedList 的性能差异？

import java.util.HashMap; import java.util.Map; public class TestHashMap {     public static void main(String[] args) {         Map<String, Integer> map = new HashMap<>();         map.put("Alice", 25);         map.put("Bob", 30);         map.put("Alice", 28);  // 覆盖旧值         System.out.println(map.get("Alice"));  // 28         System.out.println(map.containsKey("Bob"));  // true         map.remove("Bob");     } }

底层实现原理

特点

import java.util.TreeMap; public class TestTreeMap {     public static void main(String[] args) {         TreeMap<Integer, String> map = new TreeMap<>();         map.put(3, "C");         map.put(1, "A");         map.put(2, "B");         System.out.println(map);  // {1=A, 2=B, 3=C}（按 key 升序）     } }

底层实现原理

特点

底层实现原理

特点

底层实现原理

特点

底层实现原理

特点

底层实现原理

特点

底层实现原理

特点

• HashMap：最常用的 Map 实现类，适用于一般的无序、非线程安全的场景。
• TreeMap：适用于需要按键排序的场景，保证键的有序性。
• LinkedHashMap：保留插入顺序或访问顺序，适用于需要维持元素顺序的场景。
• Hashtable：已经较为过时，使用较少，通常推荐使用 ConcurrentHashMap 替代。
• ConcurrentHashMap：适用于多线程环境，具有较高的

ConcurrentHashMap 和 Hashtable 的底层实现原理有什么区别？

TreeMap 和 HashMap 的底层实现有何不同？

HashMap 的底层实现原理是什么？

TreeMap 的底层实现原理是什么？

LinkedHashMap 的底层实现原理是什么？

Hashtable 的底层实现原理是什么？

ConcurrentHashMap 的底层实现原理是什么？

IdentityHashMap 的底层实现原理是什么？

WeakHashMap 的底层实现原理是什么？

HashMap 如何处理哈希冲突？

TreeMap 和 HashMap 的区别是什么？

Hashtable 和 ConcurrentHashMap 的区别是什么？

HashMap 中为什么要重写 hashCode() 和 equals() 方法？

import java.util.HashSet;

public class TestHashSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Apple");  // 重复元素不会添加

        System.out.println(set);  // 可能输出 [Banana, Apple]（无序）
    }
}

底层实现

特点

扩容机制

import java.util.TreeSet; public class TestTreeSet {     public static void main(String[] args) {         TreeSet<Integer> set = new TreeSet<>();         set.add(5);         set.add(2);         set.add(8);         System.out.println(set);  // [2, 5, 8]（升序排列）     } }

底层实现

特点

底层实现

特点

底层实现

特点

底层实现

特点

HashSet 的底层实现原理是什么？

TreeSet 的底层实现原理是什么？

LinkedHashSet 的底层实现原理是什么？

EnumSet 的底层实现原理是什么？

CopyOnWriteArraySet 的底层实现原理是什么？

import java.util.LinkedList; import java.util.Queue; public class TestQueue {     public static void main(String[] args) {         Queue<String> queue = new LinkedList<>();         queue.add("A");         queue.add("B");         queue.add("C");         System.out.println(queue.poll());  // A（FIFO）         System.out.println(queue.peek());  // B（查看队首）     } }

import java.util.PriorityQueue; public class TestPriorityQueue {     public static void main(String[] args) {         PriorityQueue<Integer> pq = new PriorityQueue<>();         pq.add(10);         pq.add(5);         pq.add(20);         System.out.println(pq.poll());  // 5（最小优先）     } }

• 线程（Thread） 是 CPU 任务调度的最小单位，一个 Java 进程可以有多个线程并发执行。
• 多线程（Multithreading） 允许多个线程在同一进程中并发执行，共享进程资源（如内存、变量等）。
• 多线程的目标 是提高 CPU 利用率，但需要注意线程同步，避免数据竞争和死锁问题。

继承 Thread 类

实现 Runnable 接口（推荐方式）

• Thread.sleep(ms)：让当前线程暂停执行 ms 毫秒。
• 线程休眠后，CPU 会去执行其他线程。
  

class SleepExample extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + " -> " + i);
            try {
                Thread.sleep(1000);  // 休眠 1 秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TestSleep {
    public static void main(String[] args) {
        Thread t1 = new SleepExample();
        t1.start();
    }
}

• join() 让当前线程等待指定线程执行完毕后再继续执行。

class JoinExample extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + " -> " + i);
        }
    }
}

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new JoinExample();
        t1.start();
        t1.join();  // 主线程等待 t1 执行完毕
        System.out.println("Main 线程继续执行");
    }
}

多个线程同时访问共享资源时，可能会导致数据不一致的问题（如线程安全问题）。

示例（无同步，可能出现问题）：
class BankAccount {
    private int balance = 100;

    public void withdraw(int amount) {
        if (balance >= amount) {
            System.out.println(Thread.currentThread().getName() + " 正在取款 " + amount);
            balance -= amount;
            System.out.println("余额：" + balance);
        }
    }
}

public class TestSync {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        new Thread(() -> account.withdraw(80)).start();
        new Thread(() -> account.withdraw(80)).start();
    }
}
可能的错误结果（余额变负）：
Thread-0 正在取款 80
余额：20
Thread-1 正在取款 80
余额：-60   <-- 线程安全问题！

class BankAccount {     private int balance = 100;     public synchronized void withdraw(int amount) {  // 线程同步         if (balance >= amount) {             System.out.println(Thread.currentThread().getName() + " 正在取款 " + amount);             balance -= amount;             System.out.println("余额：" + balance);         }     } }

字节流可以处理任何类型的数据（如文件、图片、音频），常见的实现类包括：

• 文件流：FileInputStream、FileOutputStream
• 缓冲流：BufferedInputStream、BufferedOutputStream
• 数据流：DataInputStream、DataOutputStream
• 对象流：ObjectInputStream、ObjectOutputStream

读取文件（FileInputStream）

写入文件（FileOutputStream）

字符流主要用于处理文本文件，常见的实现类：

• 文件流：FileReader、FileWriter
• 缓冲流：BufferedReader、BufferedWriter
• 字符数组流：CharArrayReader、CharArrayWriter

读取文本文件（FileReader）

写入文本文件（FileWriter）

缓冲流可以提高 IO 读取速度，减少磁盘 IO 访问次数。

• BufferedInputStream / BufferedOutputStream（字节缓冲）
• BufferedReader / BufferedWriter（字符缓冲）

使用 BufferedReader 读取文本

ObjectOutputStream 和 ObjectInputStream 用于序列化和反序列化 Java 对象，适用于存储对象到文件。

对象写入文件

读取对象

Java 1.4 引入了 java.nio（非阻塞 IO），相比传统 IO 速度更快，适用于高并发网络通信。

NIO 核心组件

• Buffer：数据缓冲区（ByteBuffer、CharBuffer）
• Channel：数据通道（FileChannel、SocketChannel）
• Selector：多路复用器（用于管理多个通道）

示例：
import java.nio.file.*;

public class TestNIO {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("test.txt");
        byte[] data = Files.readAllBytes(path);
        System.out.println(new String(data));
    }
}

I0流：用来处理设备之间的数据传输。 Java对数据的操作是通过流的方式，Java用于操作流的对象都在IO包中。 流按操作数据分为两种:字节流与字符流。 流按流向分为：输入流，输出流。 字节流的抽象基类: ● InputStream，OutputStream. 字符流的抽象基类: ● Reader   Writer。 注：由这四个类派生出来的子类名称都是 以其父类名作为子类名的后缀。 ●如:   InputStream的子类FilelnputStream. ●如:   Reader的子类FileReader 一、字符流 1、写入缓冲区： BufferredWriter 缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。 该缓冲区提供了一个跨平台的换行符。 newLine(); 1）、创建一个字符写入流对象。 2）、为了提高字符写入流效率，加入缓冲技术。只要将需要被提高效率的流对象座位参数传递给缓冲区的构造函数即可。 2、读取缓存流：BufferredReader 该缓冲区提供了一个一次读一行的方法readLine(); 方便于对文本数据的获取。 当返回null时，表示读到文件末尾 1）、创建一个读取流对象new FileReader()和文件相关联。 2）、为了提高效率，加入缓冲技术，将字符读取流对象座位参数传递给缓冲对象的构造函数。 readLine方法的原理（装饰设计模式） 无论是读一行，获取读取多个字符。其实最终 都是在在硬盘上一个一个读取。所以最终使用 的还是read方法- -次读-一个的方法。 装饰设计模式： 当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么定义的该类称为装饰类。 装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。 装饰模式和继承的区别： 装饰模式比继承要灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。 装饰类因为增强已有对象所具备的功能和已有的是相同的，只不过提供了更强的功能。所以装饰类和被装饰类通常是都属于一个体系中的。 二、字节流 FileInputStrem(); FileOutputStrem(); 缓存区： BufferedInputStream(); BufferedOutputStream(); 三、读取键盘录入 System.out：对应的是标准输出设备，控制台。 System.in：对应的标准输入设备，键盘。 四、流操作基本规律 最痛苦的就是流对象很多，不知道该用哪一个。 通过两个明确来完成： 1、明确源和目的。          源：输入流。InputStream  Reader。          目的：输出流。OutPutStream   Writer。 2、操作的数据是否是纯文本。           是：字符流。           不是：字节流。 3、当体系明确后，在明确要使用哪个具体的对象。           通过设备来区分：           源设备：内存、硬盘、键盘。           目的设备：内存、硬盘（文件）、控制台。 示例1： 将一个文本文件中数据存储到另一个文件中。复制文件。 源：因为是源，所以使用读取流。Inputstream Reader 是不是操作文本文件。 是！这时就可以选择Reader，这样体系就明确了。 接下来明确要使用该体系中的哪个对象。 明确设备：硬盘。上一个文件。 Reader体系中可以操作文件的对象是FileReader 是否需要提高效率： 是！加入Reader体系中缓冲区BufferedReader 。 FileReader fr . new FileReader ("a. txt") ; Buf feredReader bufr = new Buf feredReader (fr) ; 目的: Outputstream writer 是否是纯文本：是！ writer。 设备：硬盘，一个文件。 writer体系中可以操作文件的对象FileWriter。 是否需要提高效率：是！加入writer体系中缓冲区Bufferedwriter FileWriter fw = new FileWriter ("b. txt") ; Bufferedwriter bufw = new BufferedWriter (fw) ; 示例2： 需求：将键盘录入的数据保存到一个文件中。 这个需求中有源和日的都存在。 那么分别分析 源：InputStream     Reader 是不是纯文本？是！ Reader 设备：键盘。对应的对象是system. in。 不是选择Reader吗? System. in对应的不是字节流吗? 为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。 所以既然明确了Reader，那么就将system。in转换成Reader。 用了Reader体系中转换流, InputStreamReader InputStreamReader isr  = new InputStreamReader (System.in) ;  需要提高效率吗？需要！ BufferedReader BufferedReader bufr = new BufferedReader (isr) ; 目的:：OutputStream     writer 是否是存文本？是！ writer. 设备：硬盘。一个文件。使用Filewriter. FileWriter fw . new FileWriter ("c.txt") ; 需要提高效率吗？需要。 Bufferedwriter bufw = new Bufferedwriter (fw) ;  *************************************************************** 扩展一下：想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。 目的：OutputStream     writer 是否是存文本？是！ writer. 设备：硬盘。一个文件。 使用Filewriter，但是存储时，需要加入指定编码表，而指定的编码表只有转换流可以指定。所以要使用的对象是OutputStreamWriter。而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutSrream。 OutputStreamWriter  osw = new OutputStreamWriter(new FileOutputStream("d.txt"，"UTF-8")) ; 需要提高效率吗？需要。 Bufferedwriter bufw = new Bufferedwriter (osw ) ;  所以，转换流什么时候使用，字符和字节至今的桥梁，通常涉及到字符编码转换时，需要用到转换流。 *************************************************************** 五、File类 用来讲文件或者文件夹封装成对象。 方便对文件与文件夹的属性进行操作。 Fi1e类常见方法: 1， 创建。 boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false. 和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。 mkdir：创建文件夹。 mkdirs：创建多级文件夹。 2，删除。 boolean delete()：删除失败返回f se. void deleteOnExit()：在程字遇出时别除指定文件。 3、判断 exists()：文件是否存在。 isFile：是否是文件。 isDirectory：是否是文件夹。 isHidden：是否是隐藏。 isAbsolute：是否是绝对路径。 记住在判断文件对象是否是文件或者目录时，必须要先判断该文件对象是否存在。 4、获取信息 getName()：获取名称。 getPath()：获取路径。 getParent()：获取绝对路径中的文件父目录。如果获取的是相对路径返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。 getAbsolute()：获取绝对路径。 lastModified()：最后一次修改时间。 length()：文件大小。 六、properties Properties是hashtable的子类。也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器。 特点： 可以用于键值对形式的配置文件。 那么在加载数据时，需要数据有固定格式：键=值。 合并流：SequenceInputStream。Enumeration   en = vector.elements(); 切割流：SplitFile 七、RandomAccessFile 该类不是算是Io体系中子类。 而是直接继承自object. 但是它是I0包中成员。因为它具备读和写功能. 内部封装了一个数组，而且通过指针对数组的元素进行操作。 可以通过getFilePointer获取指针位置， 同时可以通过seek改变指针的位置。 其实完成读写的原理就是内部封装了字节输入流和输出流。 通过构造函效可以看出，该类只能操作文件。 而且操作文件还有模式： 如果模式为只读r.不会创建文件。会去读取一一个已存在文件，如果该文件不存在，则会出现异常。 如果模式rw，操作的文件不存在，会自动创建。如果存在会覆盖. 八、PipedInputStream、PipedOutStream（管道流） 多用于多线程中，单线程容易造成死锁。 九、ByteArrayInputStream 用于操作字节数组的流对象。 ByteArrayInputstream ：在构造的时候，斋要接收数据源，: 而且效据源是一一个字节效组。 ByteAr rayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组. 这就是数据目的地。 因为这两个流对象都操作的数組，并没有使用系统资源。 所以，不用进行close关闭。 常见的编码表 ●ASCII：美国标准信息交换码。，用一个字节的7位可以表示。 ●IS08859-1：拉丁码表。欧洲码表，用一个字节的8位表示。 ●GB2312: 中国的中文编码表。 ●GBK：中国的中文编码表升级，融合了更多的中文文字符 号。 ●Unicode：国际标准码，融合了多种文字。 ●所有文字都用两个字节来表示Java语言使用的就是unicode ●UTF-8：最多用三个字节来表示一个字符。 string-->byte[]; str .getBytes (charsetName) ; byte[] -->String; new String (byte []，charsetName) ;

Java 提供 Integer.toBinaryString()、Integer.toOctalString() 和 Integer.toHexString() 方法进行转换。

public class DecimalToOthers {
    public static void main(String[] args) {
        int num = 42;
        System.out.println("十进制: " + num);
        System.out.println("二进制: " + Integer.toBinaryString(num));
        System.out.println("八进制: " + Integer.toOctalString(num));
        System.out.println("十六进制: " + Integer.toHexString(num));
    }
}
输出：
十进制: 42
二进制: 101010
八进制: 52
十六进制: 2a

Java 提供 Integer.parseInt(String s, int radix) 方法，将不同进制的字符串转换为十进制数。

public class OthersToDecimal {
    public static void main(String[] args) {
        System.out.println("二进制转十进制: " + Integer.parseInt("101010", 2));
        System.out.println("八进制转十进制: " + Integer.parseInt("52", 8));
        System.out.println("十六进制转十进制: " + Integer.parseInt("2A", 16));
    }
}
输出：
二进制转十进制: 42
八进制转十进制: 42
十六进制转十进制: 42

可以使用 Integer.toString(int num, int radix) 进行任意进制转换（2 到 36）。

public class CustomBaseConversion {
    public static void main(String[] args) {
        int num = 255;
        System.out.println("十进制转二进制: " + Integer.toString(num, 2));
        System.out.println("十进制转八进制: " + Integer.toString(num, 8));
        System.out.println("十进制转十六进制: " + Integer.toString(num, 16));
    }
}

Java 8 提供了 toUnsignedString() 方法，可以处理无符号整数进制转换。

public class UnsignedConversion {
    public static void main(String[] args) {
        int num = -5;
        System.out.println("无符号二进制: " + Integer.toUnsignedString(num, 2));
    }
}

输出：
无符号二进制: 4294967291
（-5 在无符号整数中被解释为 4294967291）

int red = 0xFF0000; // 纯红色 System.out.println("红色值: " + red);

int permission = 0755; // Linux 文件权限 System.out.println("权限: " + permission);

int read = 0b0001;  // 读权限 int write = 0b0010; // 写权限 int execute = 0b0100; // 执行权限 int permission = read | write; // 赋予读写权限 System.out.println("权限: " + Integer.toBinaryString(permission));

流程：

优点：

缺点：

示例图

流程：

优点：

缺点：

示例图

流程：

优点：

缺点：

示例图：

由于对象生命周期不同，JVM 采用 分代 GC，不同区域使用不同算法：

新生代（Young Generation）：大部分对象生命周期短，使用 复制算法。 老年代（Old Generation）：对象存活时间长，使用 标记-整理算法。 永久代/元空间（Metaspace）：存放类元数据，GC 较少触发。

示例：

java -XX:+PrintCommandLineFlags -version

• 单线程执行 GC，适用于单核 CPU。
• Stop-the-World 时间较长。
• 适用于 小型应用（如嵌入式设备）。

参数

• 多线程 GC，适用于 高吞吐量应用。
• 适用于 大内存场景（默认用于 JDK 8）。

参数

• 低延迟（低停顿），适用于 需要快速响应的应用（如 Web 服务器）。
• 并发执行 GC 任务，减少 Stop-the-World 时间。

缺点：

• 容易产生碎片化。
• 需要更多 CPU 资源。

参数：

• JDK 9+ 默认 GC，适用于 大堆内存应用（如 4GB 以上）。
• 区域化管理内存（Heap 被划分为多个小块）。
• 避免碎片化，优先回收垃圾最多的区域。
• 适用于 低延迟、高吞吐应用。

参数

• 适用于超大内存（100GB+）应用。
• GC 停顿时间低于 10ms。
• 不移动对象，避免长时间 STW。

参数：

• 当堆内存不足时（如 OutOfMemoryError 之前）。
• 当对象不可达（无法通过任何引用访问）。
• 由 GC 触发策略决定（不同 GC 采用不同策略）。

JVM 采用 两种主要的对象存活判断方法：

引用计数法（Reference Counting）

• 每个对象维护一个引用计数器，每次被引用时 +1，引用失效时 -1。
• 缺点：无法处理循环引用（即对象相互引用但不被外部对象引用）。
  

可达性分析（Reachability Analysis）（JVM 采用）
通过 GC Roots 作为起点，遍历可达对象。
GC Roots 包括：

• 栈帧中的本地变量表（线程活动区域）
• 方法区中的静态变量、常量池
• JNI（Native 方法）引用的对象

不可达对象会被 GC 处理。

vector

ArrayList

LinkedList

HashSet

TreeSet

LinkedHashSet

TreeMap

HashMap

LinkedHashMap