Java 面试题库-A（含答案）

最近更新：2025-06-20 | 字数总计：12.4k

01.云计算的服务模式不包括以下哪个？

云计算的服务模式主要包括以下三种：

IaaS（基础设施即服务）：提供虚拟化的计算资源，如虚拟机、存储和网络。
PaaS（平台即服务）：提供开发和部署应用的平台，包括操作系统、数据库和开发工具。
SaaS（软件即服务）：提供通过互联网访问的应用程序，用户无需管理底层基础设施。

以下选项通常不属于云计算的服务模式：

DaaS（数据即服务）：虽然DaaS是一种云服务，但它通常被视为SaaS或PaaS的一部分，而不是独立的云计算服务模式。
On-premises（本地部署）：这是传统的本地部署模式，不属于云计算的范畴。

因此，On-premises（本地部署） 不属于云计算的服务模式。

02.group 和having 用法？

在SQL中，GROUP BY 和 HAVING 是用于对查询结果进行分组和过滤的关键字。它们通常与聚合函数（如 COUNT、SUM、AVG、MAX、MIN 等）一起使用。

1. GROUP BY

GROUP BY 用于将结果集按一个或多个列进行分组，通常与聚合函数一起使用，以便对每个组进行计算。

语法：

1
2
3

SELECT column1, aggregate_function(column2)
FROM table
GROUP BY column1;

示例：

假设有一个 orders 表，包含以下数据：

order_id	customer_id	amount
1	101	100
2	102	200
3	101	150
4	103	300

如果我们想计算每个客户的订单总金额，可以使用 GROUP BY：

1
2
3

SELECT customer_id, SUM(amount) AS total_amount
FROM orders
GROUP BY customer_id;

结果

customer_id	total_amount
101	250
102	200
103	300

2. HAVING

HAVING 用于过滤分组后的结果集。它与 WHERE 类似，但 WHERE 是在分组前过滤行，而 HAVING 是在分组后过滤组。

语法

SELECT column1, aggregate_function(column2)
FROM table
GROUP BY column1
HAVING condition;

示例

继续使用上面的 orders 表，如果我们只想查询订单总金额大于 200 的客户，可以使用 HAVING：

SELECT customer_id, SUM(amount) AS total_amount
FROM orders
GROUP BY customer_id
HAVING SUM(amount) > 200;

结果

customer_id	total_amount
101	250
103	300

3. GROUP BY 和 HAVING 的结合使用

GROUP BY 和 HAVING 通常一起使用，以便对分组后的结果进行过滤。

示例：

假设我们想查询订单数量大于 1 的客户：

SELECT customer_id, COUNT(order_id) AS order_count
FROM orders
GROUP BY customer_id
HAVING COUNT(order_id) > 1;

结果

customer_id	order_count
101	2

总结

GROUP BY：用于按列分组，通常与聚合函数一起使用。
HAVING：用于过滤分组后的结果集，条件中通常包含聚合函数。
WHERE 和 HAVING 的区别：
- WHERE 在分组前过滤行。
- HAVING 在分组后过滤组。

通过合理使用 GROUP BY 和 HAVING，可以对数据进行更复杂的分析和查询。

03.分布式数据库的可扩展性不包括哪个？

分布式数据库的可扩展性通常包括以下几个方面：

水平扩展（Horizontal Scaling）：
- 通过增加更多的节点来扩展系统的处理能力和存储容量。
- 例如，添加更多的服务器来分担负载。
垂直扩展（Vertical Scaling）：
- 通过增加单个节点的资源（如CPU、内存、存储）来提升性能。
- 例如，升级服务器的硬件配置。
数据分片（Sharding）：
- 将数据分散存储在多个节点上，以提高查询性能和处理能力。
- 例如，按用户ID将数据分布到不同的数据库实例。
负载均衡（Load Balancing）：
- 将请求均匀分布到多个节点上，以避免单个节点过载。
- 例如，使用负载均衡器来分配查询请求。
高可用性（High Availability）：
- 通过复制和故障转移机制确保系统在部分节点失效时仍能正常运行。
- 例如，使用主从复制和自动故障切换。
弹性扩展（Elastic Scaling）：
- 根据负载动态调整资源，以应对流量波动。
- 例如，云数据库服务可以根据需求自动扩展或缩减资源。

不包括的方面

分布式数据库的可扩展性不包括以下方面：

单点性能优化（Single-node Performance Optimization）：
- 虽然单点性能优化可以提升单个节点的性能，但它并不直接涉及系统的扩展性。
- 例如，优化单个数据库的查询性能或索引设计。
数据一致性（Data Consistency）：
- 数据一致性是分布式数据库的重要特性，但它与可扩展性无直接关系。
- 例如，强一致性或最终一致性的实现。
安全性（Security）：
- 安全性是数据库的重要特性，但它与可扩展性无直接关系。
- 例如，数据加密、访问控制等。
事务管理（Transaction Management）：
- 事务管理是数据库的核心功能，但它与可扩展性无直接关系。
- 例如，分布式事务的实现。

总结

分布式数据库的可扩展性主要关注系统的扩展能力，包括水平扩展、垂直扩展、数据分片、负载均衡、高可用性和弹性扩展。而单点性能优化、数据一致性、安全性和事务管理虽然重要，但不属于可扩展性的范畴。

04.主键满足数据库三范式的第几范式？

主键（Primary Key）是数据库设计中的一个重要概念，它与数据库范式（Normalization）密切相关。主键本身并不直接对应某个范式，但它是实现数据库范式的基础，尤其是在满足第一范式（1NF）和第二范式（2NF）时起到关键作用。

1. 主键的作用

唯一标识：主键用于唯一标识表中的每一行数据。
非空：主键列的值不能为 NULL。
不可重复：主键列的值必须唯一。

2. 主键与数据库范式的关系

第一范式（1NF）

要求：表中的每一列都是不可再分的原子值，且每一行都是唯一的。
主键的作用：主键是实现第一范式的关键，因为它确保了每一行的唯一性。
示例：
- 不符合 1NF 的表：
  
  学生ID 学生姓名课程
  
  1 张三数学, 英语
  
  2 李四物理
- 符合 1NF 的表（通过主键确保唯一性）：
  
  学生ID 学生姓名课程
  
  1 张三数学
  
  1 张三英语
  
  2 李四物理

学生ID	学生姓名	课程
1	张三	数学, 英语
2	李四	物理

学生ID	学生姓名	课程
1	张三	数学
1	张三	英语
2	李四	物理

第二范式（2NF）

要求：在满足 1NF 的基础上，所有非主键列必须完全依赖于主键，而不是部分依赖。
主键的作用：如果表中有复合主键（由多个列组成），则需要确保非主键列完全依赖于整个主键，而不是部分主键。
示例：
- 不符合 2NF 的表：
  
  学生ID 课程ID 学生姓名课程名称
  
  1 101 张三数学
  
  1 102 张三英语
  
  2 101 李四数学
  - 问题：学生姓名 只依赖于 学生ID，而 课程名称 只依赖于 课程ID，存在部分依赖。
- 符合 2NF 的表（拆分表）：
  - 学生表：
    
    学生ID 学生姓名
    
    1 张三
    
    2 李四
  - 课程表：
    
    课程ID 课程名称
    
    101 数学
    
    102 英语
  - 选课表：
    
    学生ID 课程ID
    
    1 101
    
    1 102
    
    2 101

学生ID	课程ID	学生姓名	课程名称
1	101	张三	数学
1	102	张三	英语
2	101	李四	数学

学生ID	学生姓名
1	张三
2	李四

课程ID	课程名称
101	数学
102	英语

学生ID	课程ID
1	101
1	102
2	101

第三范式（3NF）

要求：在满足 2NF 的基础上，所有非主键列之间不能有传递依赖。
主键的作用：主键仍然是确保数据唯一性和依赖关系的基础。
示例：
- 不符合 3NF 的表：
  
  学生ID 学生姓名学院ID 学院名称
  
  1 张三 101 理学院
  
  2 李四 102 文学院
  - 问题：学院名称 依赖于 学院ID，而 学院ID 依赖于 学生ID，存在传递依赖。
- 符合 3NF 的表（拆分表）：
  - 学生表：
    
    学生ID 学生姓名学院ID
    
    1 张三 101
    
    2 李四 102
  - 学院表：
    
    学院ID 学院名称
    
    101 理学院
    
    102 文学院

学生ID	学生姓名	学院ID	学院名称
1	张三	101	理学院
2	李四	102	文学院

学生ID	学生姓名	学院ID
1	张三	101
2	李四	102

学院ID	学院名称
101	理学院
102	文学院

3. 总结

主键本身并不直接对应某个范式，但它是实现数据库范式的基础。
第一范式（1NF）：主键确保每一行的唯一性。
第二范式（2NF）：主键（尤其是复合主键）确保非主键列完全依赖于整个主键。
第三范式（3NF）：主键确保非主键列之间没有传递依赖。

因此，主键是数据库设计中的核心概念，贯穿于数据库范式的各个阶段。

05.数据库默认的事物传播类型是哪个？

在 MySQL 和 Oracle 数据库中，事务传播行为并不是数据库本身的特性，而是由应用程序框架（如 Spring）或应用程序逻辑控制的。数据库本身只提供事务的基本支持（如 BEGIN、COMMIT、ROLLBACK），而事务的传播行为是由应用程序框架定义的。

1. MySQL 和 Oracle 数据库的事务支持

MySQL：
- 默认情况下，MySQL 使用自动提交模式（autocommit），即每条 SQL 语句都会自动作为一个事务提交。
- 可以通过 BEGIN 或 START TRANSACTION 显式开启事务，然后通过 COMMIT 或 ROLLBACK 结束事务。
Oracle：
- Oracle 数据库默认也是自动提交模式，但可以通过设置 AUTOCOMMIT 为 OFF 来禁用自动提交。
- 使用 BEGIN 或 START TRANSACTION 开启事务，通过 COMMIT 或 ROLLBACK 结束事务。

2. 事务传播行为的定义

事务传播行为是由应用程序框架（如 Spring）定义的，常见的传播行为包括：

REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新事务。
REQUIRES_NEW：总是创建一个新事务，如果当前存在事务，则挂起当前事务。
SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。
其他传播行为（如 MANDATORY、NOT_SUPPORTED、NEVER、NESTED）。

3. 默认传播行为

Spring 框架：

在 Spring 中，默认的事务传播行为是 REQUIRED。

示例：

@Transactional // 默认传播行为是 REQUIRED
public void method() {
    // 业务逻辑
}

MySQL 和 Oracle 数据库：
- 数据库本身没有“传播行为”的概念，传播行为是由应用程序框架控制的。
- 如果直接使用 JDBC 或原生 SQL，需要手动管理事务的边界（如 BEGIN、COMMIT、ROLLBACK）。

4. 总结

MySQL 和 Oracle 数据库：
- 数据库本身只提供事务的基本支持（如 BEGIN、COMMIT、ROLLBACK）。
- 默认情况下，MySQL 和 Oracle 使用自动提交模式（autocommit）。
事务传播行为：
- 是由应用程序框架（如 Spring）定义的。
- 在 Spring 中，默认的传播行为是 REQUIRED。

如果需要使用特定的事务传播行为，需要在应用程序框架中配置，而不是在数据库中配置。

06.数据库事物读未提交是哪个？（read uncommitted）

在数据库事务的隔离级别中，读未提交（Read Uncommitted） 是最低的事务隔离级别。它允许一个事务读取另一个事务尚未提交的数据，可能会导致脏读（Dirty Read）、不可重复读（Non-Repeatable Read） 和 幻读（Phantom Read） 等问题。

1. 读未提交（Read Uncommitted）的特点

定义：一个事务可以读取另一个事务未提交的数据。
问题：
- 脏读（Dirty Read）：读取到未提交的数据，如果该事务回滚，则读取到的数据是无效的。
- 不可重复读（Non-Repeatable Read）：同一事务中多次读取同一数据，结果不一致。
- 幻读（Phantom Read）：同一事务中多次查询，结果集不一致（新增或删除的数据导致）。

2. 读未提交的示例

假设有两个事务：事务A 和 事务B。

事务A：

1 2	BEGIN; UPDATE users SET balance = 100 WHERE id = 1; -- 修改数据但未提交

事务B：

1 2	BEGIN; SELECT balance FROM users WHERE id = 1; -- 读取到未提交的数据（balance = 100）

如果 事务A 回滚，事务B 读取到的数据（balance = 100）就是无效的，这就是脏读。

3. 设置读未提交隔离级别

在 MySQL 和 Oracle 中，可以通过以下方式设置事务的隔离级别为 读未提交。

MySQL：

1	SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

Oracle：

Oracle 不支持 读未提交 隔离级别，最低的隔离级别是 读已提交（Read Committed）。

4. 读未提交的适用场景

对数据一致性要求不高的场景：
- 例如，某些统计分析的场景，允许读取到未提交的数据。
性能要求较高的场景：
- 读未提交的隔离级别最低，并发性能最好，但数据一致性无法保证。

5. 数据库事务隔离级别对比

隔离级别	脏读（Dirty Read）	不可重复读（Non-Repeatable Read）	幻读（Phantom Read）
读未提交	可能	可能	可能
读已提交	不可能	可能	可能
可重复读	不可能	不可能	可能
串行化	不可能	不可能	不可能

6. 总结

读未提交（Read Uncommitted） 是最低的事务隔离级别，允许读取未提交的数据。
它会导致脏读、不可重复读 和幻读等问题。
适用于对数据一致性要求不高、但对性能要求较高的场景。
在 MySQL 中可以通过 SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED 设置，但 Oracle 不支持该隔离级别。

07.【多选题】fetch 和pull用法？

fetch 和 pull 是 Git 中常用的两个命令，它们的作用和用法有所不同，但都与从远程仓库获取代码有关。以下是它们的详细说明和用法：

1. `git fetch`

git fetch 用于从远程仓库下载最新的提交记录和分支信息，但不会自动合并到本地分支。

作用：

从远程仓库获取最新的提交记录和分支信息。
更新本地仓库的远程跟踪分支（如 origin/main），但不会修改本地分支（如 main）。

用法：

1	git fetch <远程仓库名>

<远程仓库名>：通常是 origin，表示远程仓库的别名。

示例：

获取远程仓库的所有更新：
1
git fetch origin
获取特定分支的更新：
1
git fetch origin main
查看远程分支的更新：
1
git fetch --all

结果：

远程仓库的最新提交会被下载到本地，但不会影响本地分支。
可以使用 git log origin/main 查看远程分支的更新。

2. `git pull`

git pull 用于从远程仓库下载最新的提交记录并自动合并到当前本地分支。

作用：

从远程仓库获取最新的提交记录。
自动将远程分支的更新合并到当前本地分支。

用法：

1	git pull <远程仓库名> <远程分支名>

<远程仓库名>：通常是 origin。
<远程分支名>：要拉取的远程分支名称。

示例：

拉取远程仓库的 main 分支并合并到当前分支：
1
git pull origin main
拉取远程仓库的当前分支（默认）：
1
git pull

结果：

远程仓库的最新提交会被下载并自动合并到当前本地分支。
如果存在冲突，需要手动解决冲突后再提交。

3. `fetch` 和 `pull` 的区别

特性	`git fetch`	`git pull`
作用	下载远程仓库的最新提交记录和分支信息	下载远程仓库的最新提交记录并合并到本地分支
是否修改本地分支	不会修改本地分支	会自动合并到当前本地分支
使用场景	查看远程仓库的更新	获取远程仓库的更新并合并到本地
冲突处理	不会产生冲突	可能会产生冲突，需要手动解决

4. 工作流程示例

使用 `fetch` 的工作流程：

获取远程仓库的更新：
1
git fetch origin
查看远程分支的更新：
1
git log origin/main
手动合并远程分支到本地分支：
1
git merge origin/main

使用 `pull` 的工作流程：

直接拉取并合并远程分支：
1
git pull origin main

如果有冲突，解决冲突后提交：

1 2	git add . git commit -m "Merge remote changes"

5. 总结

git fetch：
- 用于获取远程仓库的最新提交记录和分支信息。
- 不会修改本地分支，适合查看远程仓库的更新。
git pull：
- 用于获取远程仓库的最新提交记录并自动合并到本地分支。
- 适合快速同步远程仓库的更新。

根据具体需求选择合适的命令：

如果需要查看远程仓库的更新而不修改本地分支，使用 git fetch。
如果需要快速同步远程仓库的更新并合并到本地分支，使用 git pull。

08.【编程题】给一个数组，包括正数和负数，要求忽略正负，按大小排序

要实现一个忽略正负、按绝对值大小排序的数组，可以使用编程语言提供的排序函数，并在排序时比较元素的绝对值。以下是使用 Java 的实现示例：

Java 实现

Java 可以使用 Arrays.sort() 方法，并通过自定义比较器来实现按绝对值排序。

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Integer[] arr = {3, -1, -4, 2, 0, -2};
        sortByAbsoluteValue(arr);
        System.out.println(Arrays.toString(arr));  // 输出: [0, -1, 2, -2, 3, -4]
    }

    public static void sortByAbsoluteValue(Integer[] arr) {
        // 使用 Arrays.sort 并传入自定义比较器
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return Integer.compare(Math.abs(a), Math.abs(b));
            }
        });
    }
}

解释

Arrays.sort(arr, new Comparator<Integer>() { ... })：对数组 arr 进行排序，排序规则由自定义的 Comparator 定义。
Integer.compare(Math.abs(a), Math.abs(b))：比较两个整数的绝对值。

总结

核心思想：在排序时比较元素的绝对值。
实现方式：
- Java：使用 Arrays.sort() 和自定义 Comparator。

以上实现均能正确地将数组按绝对值大小排序，同时保留原始元素的正负符号。

09.数据库的四种隔离级别

MySQL 支持不同的事务隔离级别，控制事务间的可见性：

READ UNCOMMITTED：最低级别，允许读取未提交的数据。
READ COMMITTED：只能读取已提交的数据。
REPEATABLE READ（默认）：确保事务内多次读取结果一致。
SERIALIZABLE：最高级别，完全隔离，事务串行执行。

10.truncate的属于什么操作？

TRUNCATE 是 SQL 中的一种数据操作语言（DML，Data Manipulation Language）命令，用于快速删除表中的所有数据。与 DELETE 命令不同，TRUNCATE 不会逐行删除数据，而是直接释放表的数据页，因此效率更高。

1. `TRUNCATE` 的特点

删除所有数据：TRUNCATE 会删除表中的所有数据，但保留表结构（如表定义、索引、约束等）。
不可回滚：TRUNCATE 操作通常不可回滚（取决于数据库的实现，某些数据库支持事务中的 TRUNCATE 回滚）。
不触发触发器：TRUNCATE 不会触发 DELETE 触发器。
重置自增值：对于带有自增列（如 AUTO_INCREMENT 或 IDENTITY）的表，TRUNCATE 会重置自增值。
高效：TRUNCATE 直接释放数据页，比 DELETE 更快。

2. `TRUNCATE` 的语法

1	TRUNCATE TABLE 表名;

示例：

1	TRUNCATE TABLE employees;

删除 employees 表中的所有数据，但保留表结构。

3. `TRUNCATE` 与 `DELETE` 的区别

特性	`TRUNCATE`	`DELETE`
删除方式	直接释放数据页，删除所有数据	逐行删除数据
效率	高效	较低
可回滚	通常不可回滚（取决于数据库实现）	可回滚
触发触发器	不触发	触发
重置自增值	重置	不重置
条件删除	不支持	支持（通过 `WHERE` 子句）

4. `TRUNCATE` 的适用场景

需要快速清空表中的所有数据。
不需要逐行删除数据。
不需要触发 DELETE 触发器。
需要重置自增列的值。

5. 注意事项

权限要求：TRUNCATE 通常需要较高的权限（如 DROP 权限）。
不可恢复：TRUNCATE 操作通常不可恢复，执行前需谨慎。
外键约束：某些数据库（如 MySQL 的 InnoDB）在有外键约束时可能不允许 TRUNCATE。

6. 总结

TRUNCATE 是一种高效的删除操作，用于快速清空表中的所有数据。
它属于 DML（数据操作语言），但与 DELETE 相比，TRUNCATE 更高效且不触发触发器。
适用于需要快速清空表数据的场景，但需注意其不可回滚的特性。

11.数据库聚簇索引和非聚簇索引的问题

聚簇索引（Clustered Index） 和 非聚簇索引（Non-Clustered Index） 是数据库中两种重要的索引类型，它们在存储方式和查询性能上有显著区别。以下是它们的详细对比和常见问题：

1. 聚簇索引（Clustered Index）

定义：

聚簇索引决定了表中数据的物理存储顺序。
一个表只能有一个聚簇索引，因为数据只能按一种方式物理排序。

特点：

数据与索引一起存储：聚簇索引的叶子节点直接存储数据行。
物理排序：表中的数据按聚簇索引的键值顺序存储。
高效查询：对于范围查询和排序操作，聚簇索引非常高效。
主键默认是聚簇索引：在大多数数据库（如 MySQL InnoDB）中，主键默认是聚簇索引。

示例：

CREATE TABLE employees (
    id INT PRIMARY KEY,  -- 聚簇索引
    name VARCHAR(100),
    age INT
);

id 列是聚簇索引，数据按 id 的顺序存储。

2. 非聚簇索引（Non-Clustered Index）

定义：

非聚簇索引是一种独立于数据存储的索引结构。
一个表可以有多个非聚簇索引。

特点：

索引与数据分离：非聚簇索引的叶子节点存储的是指向数据行的指针（如主键值或行地址）。
逻辑排序：索引按键值排序，但数据不按索引顺序存储。
适合查询单条记录：对于精确查找，非聚簇索引效率较高。
需要额外存储空间：非聚簇索引需要额外的存储空间来存储索引结构。

示例：

1	CREATE INDEX idx_name ON employees(name); -- 非聚簇索引

name 列是非聚簇索引，索引按 name 排序，但数据仍按 id 的顺序存储。

3. 聚簇索引 vs 非聚簇索引

特性	聚簇索引	非聚簇索引
数量	一个表只能有一个	一个表可以有多个
数据存储	索引的叶子节点存储数据行	索引的叶子节点存储指向数据行的指针
物理排序	数据按索引键值物理排序	数据不按索引键值物理排序
查询性能	范围查询和排序操作高效	精确查找操作高效
存储空间	不需要额外存储空间	需要额外存储空间
默认索引	主键默认是聚簇索引	需要显式创建

4. 常见问题

问题 1：一个表可以有多个聚簇索引吗？

答案：不可以。一个表只能有一个聚簇索引，因为数据只能按一种方式物理排序。

问题 2：聚簇索引和非聚簇索引哪个更快？

答案：取决于查询类型：
- 聚簇索引：在范围查询和排序操作中更快，因为数据按索引顺序存储。
- 非聚簇索引：在精确查找操作中更快，因为索引结构更小，查找更快。

问题 3：主键一定是聚簇索引吗？

答案：在大多数数据库（如 MySQL InnoDB）中，主键默认是聚簇索引。但某些数据库（如 SQL Server）允许将非主键列设置为聚簇索引。

问题 4：非聚簇索引的叶子节点存储什么？

答案：
- 如果表有聚簇索引，非聚簇索引的叶子节点存储聚簇索引的键值。
- 如果表没有聚簇索引，非聚簇索引的叶子节点存储数据行的物理地址。

问题 5：如何选择聚簇索引的列？

答案：
- 选择唯一性高、更新频率低的列（如主键）。
- 选择常用于范围查询或排序的列。

5. 实际应用场景

聚簇索引的应用场景：

主键列。
常用于范围查询或排序的列（如日期列）。

非聚簇索引的应用场景：

常用于查询条件的列（如 WHERE 子句中的列）。
需要创建多个索引的列。

6. 总结

聚簇索引：
- 决定数据的物理存储顺序。
- 一个表只能有一个聚簇索引。
- 适合范围查询和排序操作。
非聚簇索引：
- 独立于数据存储，存储指向数据行的指针。
- 一个表可以有多个非聚簇索引。
- 适合精确查找操作。

根据实际需求合理选择聚簇索引和非聚簇索引，可以显著提高数据库的查询性能。

12.springboot启动读取的配置顺序

13.spring AOP关于通知的选择题。

14.@Autowired与@Resource注解的区别(默认按什么装配)

15.Linux中 765权限的文件，应该标记为什么，例如-rwxrw-r-x

16.关于redis持久化得选择题

17.例如[8,3,6,-7,-2,1]排序后的结果[1,-2,3,6,-7,8]

18.mysql数据库having用法

19.private,public,protected作用域

20.保密学习在行方哪个平台进行?

21.数据安全问题

22.数据库三大范式

23.对称加密算法有哪些

24.update/delete注意事项

25.redis默认日志

26.spring事务相关，比如默认事务，事务失效原因、spring默认日志框架

27.aop原理

28.云计算包含哪些

29.mybatis标签

30.gbase sql正确性

31.linux操作相关指令

32.数据库索引失效

33.观察者模式描述(多选题)

34.math.round(-1.5)的值是多少?

35.TCP、HTTP、UDP分别位于底层的那一层？A 传输层 B 应用层 C 会话层 D 网络层

36.springboot中使用aop的接口(有个选项是事务相关@Transactional)

37.死锁的4个必要条件

38.mysql的隔离级别

39.mybaits中mapper是怎么传递参数的、sql的循环使用foreach、怎么进行结果映射的、sql的索引使用

40.Java的特性抽象继承封装多态

41.class类的初始化方式

42.哪个命令可以跳出多层嵌套循环()? A:break B:continue C:goto

43.可以使联合索引(a,b,c)失效的有()? A:a B:a,b C:a,b,c D:b,c

44.哪个属于DDL操作()？A:select B:update C:truncate D:create

45.数组经过两次排序后可以从小到大排序，使用的是什么排序？A:插入 B 冒泡 C 快速 D 选择

46.变量使用哪个特殊符号会出现Sql注入? A # B＄

47.编写sql语句正确先后顺序是什么？where >group by >having>order by

48.单例模式满足条件？

49.访问修饰符public,private,protected,default 的访问权限是什么？

50.git如何解决冲突？

51.count(1),count(主键)，count(*)哪个查询效率高？

52.count(1) count(*) count(列) null值差异

53.多线程加锁方式

54.sass mass pass rass考察

55.arraylist和linklist是不是继承list、arraylist 是不是线程安全

56.【springboot的多选题】关于启动时加载配置文件，springboot默认日志框架logback

57.【多选题】下列是对称加密的有哪些？

58.【多选题】哪些外部设备不能插入主机

59.根据场景写SQL，根据group by

60.maven查看依赖树的命令

61.finally在return后是否执行相关问题

62.switch的参数类型

63.跨域脚本XSS哪些防御措施

64.多态的表现形式

65.Switch-case语句中不使用break后的计算值问题

66.JDBC创建连接的语句顺序

67.那些sq1高斯数据库执行失败?

68.高斯DB能执行的sql

69.springboot自动装配原理

70.事务默认传播类型

71.Mybatis传多参数的几种方式

72.【多选题】spring注入方式：构造方法、set、注解字段

73.以下那种不是Thread的方法

74.switch case default 输出打印的，主要考case满足条件以后还会继续执行吗

75.哪种方式可以防止跨域请求

防止跨域请求（Cross-Origin Request）通常不是目标，因为跨域请求是现代Web应用中常见的需求。相反，目标是安全地处理跨域请求，防止恶意行为。以下是几种常见的方式来管理和控制跨域请求：

1. CORS（跨域资源共享）

CORS 是一种W3C标准，允许服务器明确指定哪些外部域可以访问其资源。
服务器可以通过设置HTTP响应头来控制跨域请求：
- Access-Control-Allow-Origin: 指定允许访问资源的域名，* 表示允许所有域名。
- Access-Control-Allow-Methods: 指定允许的HTTP方法（如GET、POST等）。
- Access-Control-Allow-Headers: 指定允许的请求头。
- Access-Control-Allow-Credentials: 指定是否允许发送凭据（如cookies）。
通过合理配置CORS，可以限制跨域请求的来源、方法和头信息，防止恶意请求。

2. JSONP（JSON with Padding）

JSONP 是一种绕过同源策略的旧方法，通过动态创建<script>标签来加载跨域数据。
由于JSONP存在安全风险（如XSS攻击），现代应用通常不再推荐使用。

3. 代理服务器

使用代理服务器可以避免跨域问题。客户端请求同域下的代理服务器，代理服务器再请求目标服务器并返回结果。
这种方式可以隐藏跨域请求，但需要额外的服务器资源。

4. Same-Origin Policy（同源策略）

浏览器默认遵循同源策略，阻止跨域请求。如果不需要跨域请求，可以依赖浏览器的同源策略来阻止跨域访问。
同源策略限制不同协议、域名或端口之间的请求。

5. CSRF Token

为了防止跨站请求伪造（CSRF）攻击，可以使用CSRF Token。
服务器生成一个唯一的Token，嵌入到表单或请求头中，客户端在请求时携带该Token，服务器验证Token的合法性。

6. 限制请求来源

服务器可以通过检查请求头中的Origin或Referer字段，判断请求是否来自允许的域名，拒绝非法来源的请求。

7. 使用HTTPS

使用HTTPS可以防止中间人攻击，确保跨域请求的安全性。

8. Content Security Policy (CSP)

通过设置CSP头，可以限制页面加载的外部资源（如脚本、样式、图片等），防止恶意跨域请求。

总结

如果需要完全阻止跨域请求，可以依赖浏览器的同源策略或服务器端的限制。但更常见的做法是通过CORS、代理服务器或CSRF Token等方式安全地处理跨域请求，而不是完全阻止。

76.git pull合并本地代码，fetch不合并

77.REDIS 配置文件

78.范围查询⽤什么索引。

79.Java创建实例有哪些注⼊⽅式。

80.Try catch 捕获到异常后，输出内容。

81.三范式的基本概念。

82.truncate 属于什么语言 DDL DCL DML

TRUNCATE 属于 DML（Data Manipulation Language，数据操作语言）。

详细说明

DML（数据操作语言）：用于操作数据库中的数据，常见的命令包括 INSERT、UPDATE、DELETE 和 TRUNCATE。TRUNCATE 用于快速删除表中的所有数据，但保留表结构。
DDL（数据定义语言）：用于定义或修改数据库结构，例如 CREATE、ALTER、DROP 等。
DCL（数据控制语言）：用于控制数据库访问权限，例如 GRANT、REVOKE 等。

虽然 TRUNCATE 会删除数据，但它不会触发 DELETE 触发器，且通常比 DELETE 更快，因此被归类为 DML 而不是 DDL。

83.Mysql count函数和sum函数的使用

在 MySQL 中，COUNT 和 SUM 是两个常用的聚合函数，分别用于统计行数和计算数值列的总和。以下是它们的具体用法和示例：

1. `COUNT` 函数

COUNT 函数用于统计符合条件的行数。

语法：

1	COUNT(expression)

expression 可以是列名、*（表示所有行）或常量。
COUNT(*) 统计所有行，包括 NULL 值。
COUNT(column_name) 统计指定列中非 NULL 值的行数。

示例：

统计表中所有行的数量：
1
SELECT COUNT(*) FROM employees;
统计某一列中非 NULL 值的行数：
1
SELECT COUNT(salary) FROM employees;

结合 WHERE 条件统计：

1	SELECT COUNT(*) FROM employees WHERE department = 'Sales';

统计不同值的数量（结合 DISTINCT）：

1	SELECT COUNT(DISTINCT department) FROM employees;

2. `SUM` 函数

SUM 函数用于计算数值列的总和。

语法：

1	SUM(expression)

expression 必须是数值类型的列或表达式。
SUM 会忽略 NULL 值。

示例：

计算某一列的总和：
1
SELECT SUM(salary) FROM employees;

结合 WHERE 条件计算总和：

1	SELECT SUM(salary) FROM employees WHERE department = 'Sales';

计算多列的总和：

1	SELECT SUM(salary + bonus) FROM employees;

结合 GROUP BY 分组计算总和：

1
2
3

SELECT department, SUM(salary) 
FROM employees 
GROUP BY department;

3. `COUNT` 和 `SUM` 的区别

函数	作用	适用数据类型	是否忽略 `NULL`
`COUNT`	统计行数或非 `NULL` 值的数量	任意类型	是
`SUM`	计算数值列的总和	数值类型（如整数、浮点数）	是

4. 综合示例

假设有一个 orders 表，包含以下数据：

order_id	customer_id	amount
1	101	100
2	102	200
3	101	150
4	103	NULL

统计订单总数：
1
SELECT COUNT(*) FROM orders;
结果：4
统计有效订单数量（amount 列非 NULL）：
1
SELECT COUNT(amount) FROM orders;
结果：3
计算订单总金额：
1
SELECT SUM(amount) FROM orders;
结果：450

按客户分组统计订单数量和总金额：

1
2
3

SELECT customer_id, COUNT(*) AS order_count, SUM(amount) AS total_amount
FROM orders
GROUP BY customer_id;

结果：

customer_id	order_count	total_amount
101	2	250
102	1	200
103	1	NULL

通过 COUNT 和 SUM，可以轻松实现数据统计和汇总功能。

84.@Transactional 失效场景

在 Spring 中，@Transactional 注解用于声明事务管理。然而，在某些场景下，@Transactional 可能会失效，导致事务无法正常工作。以下是一些常见的失效场景及其原因：

1. `@Transactional` 注解应用于非 `public` 方法

Spring 的事务管理默认只对 public 方法生效。如果 @Transactional 注解应用于 private、protected 或 package-visible 方法，事务将不会生效。

示例：

@Transactional
private void updateData() {
    // 事务不会生效
}

解决方法：

确保 @Transactional 注解仅用于 public 方法。

2. 方法内部调用导致代理失效

Spring 的事务管理基于 AOP 代理实现。如果在同一个类中，一个非事务方法调用另一个事务方法，事务将不会生效，因为代理对象无法拦截内部调用。

示例：

public class UserService {

    public void outerMethod() {
        innerMethod(); // 事务不会生效
    }

    @Transactional
    public void innerMethod() {
        // 事务操作
    }
}

解决方法：

将事务方法移到另一个类中。

使用 AopContext.currentProxy() 获取当前代理对象并调用方法：

1
2
3

public void outerMethod() {
    ((UserService) AopContext.currentProxy()).innerMethod();
}

3. 异常被捕获且未抛出

@Transactional 默认只在抛出未检查异常（RuntimeException 及其子类）或错误时回滚事务。如果异常被捕获且未重新抛出，事务将不会回滚。

示例：

@Transactional
public void updateData() {
    try {
        // 数据库操作
    } catch (Exception e) {
        // 捕获异常但未抛出
    }
}

解决方法：

在捕获异常后重新抛出：

@Transactional
public void updateData() {
    try {
        // 数据库操作
    } catch (Exception e) {
        throw new RuntimeException(e); // 重新抛出异常
    }
}

使用 @Transactional(rollbackFor = Exception.class) 指定回滚的异常类型。

4. 事务传播行为配置不当

@Transactional 的传播行为（propagation）配置不当可能导致事务失效。例如，如果方法配置为 Propagation.NOT_SUPPORTED，则不会开启事务。

示例：

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void updateData() {
    // 不会开启事务
}

解决方法：

根据业务需求正确配置传播行为。

5. 数据库引擎不支持事务

某些数据库引擎（如 MySQL 的 MyISAM）不支持事务。如果使用这些引擎，@Transactional 将失效。

解决方法：

将数据库引擎切换为支持事务的引擎（如 InnoDB）。

6. `@Transactional` 注解未启用

如果 Spring 的事务管理未启用，@Transactional 注解将不会生效。

解决方法：

确保在配置类或 XML 配置中启用了事务管理：

使用注解驱动：

@EnableTransactionManagement
@Configuration
public class AppConfig {
    // 配置数据源和事务管理器
}

使用 XML 配置：
1
<tx:annotation-driven />

7. 事务管理器未正确配置

如果未正确配置事务管理器（如 PlatformTransactionManager），事务将无法正常工作。

解决方法：

确保正确配置事务管理器：

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
}

8. 多线程环境下事务失效

在多线程环境下，事务可能无法跨线程传播，导致事务失效。

示例：

@Transactional
public void updateData() {
    new Thread(() -> {
        // 事务不会生效
    }).start();
}

解决方法：

避免在多线程环境下直接操作事务，或将事务操作放在主线程中执行。

9. `@Transactional` 注解的 `rollbackFor` 配置错误

默认情况下，@Transactional 只在抛出 RuntimeException 时回滚事务。如果抛出了检查异常（checked exception），事务不会回滚。

示例：

@Transactional
public void updateData() throws IOException {
    // 数据库操作
    throw new IOException(); // 事务不会回滚
}

解决方法：

显式指定 rollbackFor：

@Transactional(rollbackFor = Exception.class)
public void updateData() throws IOException {
    // 数据库操作
    throw new IOException(); // 事务会回滚
}

10. 事务超时或只读配置不当

如果事务超时（timeout）或只读（readOnly）配置不当，可能导致事务失效。

示例：

@Transactional(timeout = 1) // 超时时间过短
public void updateData() {
    // 长时间操作
}

解决方法：

根据业务需求合理配置 timeout 和 readOnly。

总结

@Transactional 失效的常见原因包括：

方法非 public。
方法内部调用。
异常被捕获且未抛出。
传播行为配置不当。
数据库引擎不支持事务。
事务管理未启用。
事务管理器未正确配置。
多线程环境下事务失效。
rollbackFor 配置错误。
事务超时或只读配置不当。

通过排查这些问题，可以有效避免 @Transactional 失效的情况。

85.Switch case 条件可以使用什么类型

在 Java 中，switch-case 语句的条件表达式（即 switch 后的表达式）可以使用以下类型：

1. 基本数据类型

byte
short
int
char

示例：

int day = 3;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    default:
        System.out.println("Invalid day");
}

2. 包装类型（从 Java 5 开始支持）

Byte
Short
Integer
Character

示例：

Integer num = 2;
switch (num) {
    case 1:
        System.out.println("One");
        break;
    case 2:
        System.out.println("Two");
        break;
    default:
        System.out.println("Other");
}

3. 枚举类型（从 Java 5 开始支持）

enum

示例：

enum Day { MONDAY, TUESDAY, WEDNESDAY }

Day day = Day.WEDNESDAY;
switch (day) {
    case MONDAY:
        System.out.println("Monday");
        break;
    case TUESDAY:
        System.out.println("Tuesday");
        break;
    case WEDNESDAY:
        System.out.println("Wednesday");
        break;
    default:
        System.out.println("Invalid day");
}

4. 字符串类型（从 Java 7 开始支持）

String

示例：

String fruit = "Apple";
switch (fruit) {
    case "Apple":
        System.out.println("It's an apple.");
        break;
    case "Banana":
        System.out.println("It's a banana.");
        break;
    default:
        System.out.println("Unknown fruit.");
}

5. 不支持的类型

以下类型不能用于 switch-case 语句：

long
float
double
boolean
自定义对象（除非是枚举类型）

示例（错误用法）：

long value = 10L;
switch (value) { // 编译错误：不支持 long 类型
    case 10L:
        System.out.println("Ten");
        break;
    default:
        System.out.println("Other");
}

6. 注意事项

case 标签必须是常量：case 后的值必须是编译时常量，不能是变量或表达式。
default 分支可选：default 分支是可选的，用于处理未匹配的情况。
break 语句：如果没有 break，程序会继续执行后续 case 分支（称为“贯穿”行为）。

示例（贯穿行为）：

int num = 2;
switch (num) {
    case 1:
        System.out.println("One");
    case 2:
        System.out.println("Two"); // 会执行
    case 3:
        System.out.println("Three"); // 会执行
    default:
        System.out.println("Other"); // 会执行
}

总结

switch-case 语句支持以下类型：

基本数据类型：byte、short、int、char
包装类型：Byte、Short、Integer、Character
枚举类型：enum
字符串类型：String

不支持的类型包括 long、float、double、boolean 以及自定义对象（枚举除外）。

86.Springboot简介

Spring Boot 简介

Spring Boot 是 Spring 生态系统中的一个重要项目，旨在简化 Spring 应用的开发和部署。它通过提供默认配置和自动化配置，减少了开发者在搭建和配置 Spring 应用时的复杂性，使开发者能够快速构建独立、生产级的应用程序。

1. Spring Boot 的核心特点

快速启动：通过内嵌的 Tomcat、Jetty 或 Undertow 服务器，Spring Boot 应用可以直接运行，无需部署到外部服务器。
自动配置：Spring Boot 根据项目的依赖自动配置 Spring 框架和第三方库，减少了手动配置的工作量。
独立运行：Spring Boot 应用可以打包为可执行的 JAR 或 WAR 文件，直接通过 java -jar 命令运行。
无代码生成：Spring Boot 不需要生成额外的代码或 XML 配置文件，完全基于注解和约定。
生产就绪：提供健康检查、指标监控、外部化配置等生产级特性。

2. Spring Boot 的核心组件

Spring Boot Starter：一系列依赖描述符，简化 Maven/Gradle 依赖管理。例如：
- spring-boot-starter-web：用于构建 Web 应用。
- spring-boot-starter-data-jpa：用于集成 JPA 和数据库。
- spring-boot-starter-test：用于单元测试。
Spring Boot Auto-Configuration：根据类路径中的依赖自动配置 Spring 应用。
Spring Boot Actuator：提供生产级监控和管理功能，如健康检查、指标收集等。
Spring Boot CLI：命令行工具，支持快速开发和运行 Groovy 脚本。

3. Spring Boot 的优势

简化开发：通过默认配置和自动化配置，减少了开发者的工作量。
快速迭代：支持热部署和热加载，开发效率高。
微服务友好：Spring Boot 是构建微服务架构的理想选择，与 Spring Cloud 无缝集成。
丰富的生态系统：与 Spring 生态系统（如 Spring Data、Spring Security 等）完美集成。
社区支持：Spring Boot 拥有庞大的社区和丰富的文档资源。

4. Spring Boot 的典型应用场景

Web 应用开发：快速构建 RESTful API 或 MVC 应用。
微服务架构：作为微服务的基础框架，与 Spring Cloud 配合使用。
批处理应用：通过 Spring Batch 支持批处理任务。
数据访问应用：集成 JPA、MyBatis 等数据访问框架。
消息驱动应用：集成 RabbitMQ、Kafka 等消息中间件。

5. Spring Boot 的简单示例

示例 1：创建一个简单的 Spring Boot Web 应用

添加依赖（pom.xml）：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

编写主类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

运行应用：
- 运行 MyApplication 类，Spring Boot 会启动内嵌的 Tomcat 服务器。
- 访问 http://localhost:8080/hello，页面会显示 Hello, Spring Boot!。

示例 2：配置文件的使用

Spring Boot 支持通过 application.properties 或 application.yml 文件进行配置。

application.properties：

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456

application.yml：

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: 123456

6. Spring Boot 的启动流程

加载 @SpringBootApplication 注解标记的主类。
扫描类路径下的组件（如 @Component、@Service、@Repository 等）。
根据依赖自动配置 Spring 应用（如数据源、Web 服务器等）。
启动内嵌的 Web 服务器并运行应用。

7. Spring Boot 的生态系统

Spring Cloud：用于构建分布式系统和微服务架构。
Spring Data：简化数据访问操作，支持关系型数据库和 NoSQL 数据库。
Spring Security：提供身份验证和授权功能。
Spring Batch：用于批处理任务。
Spring Integration：支持企业集成模式。

8. Spring Boot 的版本

Spring Boot 的版本号格式为 X.Y.Z：

X：主版本号，表示重大更新。
Y：次版本号，表示新特性或改进。
Z：修订版本号，表示 bug 修复。

截至 2023 年，最新的稳定版本是 Spring Boot 3.x，基于 Spring Framework 6.x 和 Java 17+。

总结

Spring Boot 是一个强大的框架，通过简化配置和提供默认值，极大地提高了开发效率。它适用于各种应用场景，从简单的 Web 应用到复杂的微服务架构。无论是初学者还是经验丰富的开发者，Spring Boot 都是一个值得学习和使用的工具。

87.Arraylist与hashmap的区别

ArrayList 和 HashMap 是 Java 集合框架中两个常用的类，但它们的设计目的和使用场景完全不同。以下是它们的详细区别：

1. 基本定义

ArrayList：
- 是基于动态数组的实现。
- 属于 List 接口的实现类。
- 存储有序的元素集合，允许重复元素。
- 通过索引访问元素。
HashMap：
- 是基于哈希表的实现。
- 属于 Map 接口的实现类。
- 存储键值对（key-value），键不允许重复，值可以重复。
- 通过键访问值。

2. 数据结构

ArrayList：
- 内部使用数组存储元素。
- 元素按插入顺序存储，可以通过索引快速访问。
HashMap：
- 内部使用数组和链表（或红黑树）实现。
- 通过哈希函数将键映射到数组的索引位置，解决哈希冲突时使用链表或红黑树。

3. 元素存储方式

ArrayList：

存储单个元素。

示例：

1
2
3

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");

HashMap：

存储键值对。

示例：

1
2
3

HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

4. 性能特点

ArrayList：
- 查询：通过索引访问元素的时间复杂度为 O(1)。
- 插入/删除：
  - 在末尾插入或删除元素的时间复杂度为 O(1)。
  - 在中间插入或删除元素的时间复杂度为 O(n)（需要移动元素）。
- 适用场景：需要频繁按索引访问元素的场景。
HashMap：
- 查询：通过键访问值的时间复杂度为 O(1)（平均情况）。
- 插入/删除：插入或删除键值对的时间复杂度为 O(1)（平均情况）。
- 适用场景：需要快速查找、插入或删除键值对的场景。

5. 允许的元素类型

ArrayList：

可以存储任意类型的对象（包括 null）。

示例：

ArrayList<Object> list = new ArrayList<>();
list.add("String");
list.add(123);
list.add(null);

HashMap：

键和值可以是任意类型的对象（键不能为 null，值可以为 null）。

示例：

HashMap<String, Object> map = new HashMap<>();
map.put("key1", "value1");
map.put("key2", 123);
map.put("key3", null);

6. 线程安全性

ArrayList：
- 不是线程安全的。
- 如果需要线程安全，可以使用 Collections.synchronizedList 或 CopyOnWriteArrayList。
HashMap：
- 不是线程安全的。
- 如果需要线程安全，可以使用 Collections.synchronizedMap 或 ConcurrentHashMap。

7. 扩容机制

ArrayList：

初始容量为 10，当元素数量超过容量时，自动扩容为原来的 1.5 倍。

示例：

ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 20; i++) {
    list.add(i); // 当元素数量超过 10 时，会自动扩容
}

HashMap：

初始容量为 16，负载因子为 0.75。当元素数量超过容量与负载因子的乘积时，自动扩容为原来的 2 倍。

示例：

HashMap<Integer, String> map = new HashMap<>();
for (int i = 0; i < 20; i++) {
    map.put(i, "value" + i); // 当元素数量超过 12 时，会自动扩容
}

8. 遍历方式

ArrayList：

可以使用索引遍历、迭代器遍历或增强 for 循环。

示例：

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");

// 索引遍历
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// 增强 for 循环
for (String item : list) {
    System.out.println(item);
}

HashMap：

可以使用键遍历、值遍历或键值对遍历。

示例：

HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

// 遍历键
for (String key : map.keySet()) {
    System.out.println(key);
}

// 遍历值
for (Integer value : map.values()) {
    System.out.println(value);
}

// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

9. 适用场景

ArrayList：
- 需要存储有序元素集合。
- 需要频繁按索引访问元素。
- 允许元素重复。
HashMap：
- 需要存储键值对。
- 需要快速查找、插入或删除键值对。
- 键不允许重复，值可以重复。

总结

特性	`ArrayList`	`HashMap`
数据结构	动态数组	哈希表
存储方式	单个元素	键值对
查询性能	按索引访问：`O(1)`	按键访问：`O(1)`（平均情况）
插入/删除性能	末尾操作：`O(1)`；中间操作：`O(n)`	`O(1)`（平均情况）
允许重复	允许元素重复	键不允许重复，值允许重复
线程安全性	非线程安全	非线程安全
适用场景	有序集合、按索引访问	键值对存储、快速查找

根据具体需求选择合适的集合类：如果需要有序集合，使用 ArrayList；如果需要键值对存储，使用 HashMap。

2025-02-24 该篇文章被 up 打上标签: Java 面试题

01.云计算的服务模式不包括以下哪个？

02.group 和having 用法？

1. GROUP BY

语法：

示例：

结果

2. HAVING

语法

示例

结果

3. GROUP BY 和 HAVING 的结合使用

示例：

结果

总结

03.分布式数据库的可扩展性不包括哪个？

不包括的方面

总结

04.主键满足数据库三范式的第几范式？

1. 主键的作用

2. 主键与数据库范式的关系

第一范式（1NF）

第二范式（2NF）

第三范式（3NF）

3. 总结

05.数据库默认的事物传播类型是哪个？

1. MySQL 和 Oracle 数据库的事务支持

2. 事务传播行为的定义

3. 默认传播行为

4. 总结

06.数据库事物读未提交是哪个？（read uncommitted）

1. 读未提交（Read Uncommitted）的特点

2. 读未提交的示例

3. 设置读未提交隔离级别

MySQL：

Oracle：

4. 读未提交的适用场景

5. 数据库事务隔离级别对比

6. 总结

07.【多选题】fetch 和pull用法？

1. git fetch

作用：

用法：

示例：

结果：

2. git pull

作用：

用法：

示例：

结果：

3. fetch 和 pull 的区别

4. 工作流程示例

使用 fetch 的工作流程：

使用 pull 的工作流程：

5. 总结

08.【编程题】给一个数组，包括正数和负数，要求忽略正负，按大小排序

Java 实现

解释

总结

09.数据库的四种隔离级别

10.truncate的属于什么操作？

1. TRUNCATE 的特点

2. TRUNCATE 的语法

示例：

3. TRUNCATE 与 DELETE 的区别

4. TRUNCATE 的适用场景

5. 注意事项

6. 总结

11.数据库聚簇索引和非聚簇索引的问题

1. 聚簇索引（Clustered Index）

定义：

特点：

示例：

2. 非聚簇索引（Non-Clustered Index）

定义：

特点：

示例：

3. 聚簇索引 vs 非聚簇索引

4. 常见问题

问题 1：一个表可以有多个聚簇索引吗？

问题 2：聚簇索引和非聚簇索引哪个更快？

1. `git fetch`

2. `git pull`

3. `fetch` 和 `pull` 的区别

使用 `fetch` 的工作流程：

使用 `pull` 的工作流程：

1. `TRUNCATE` 的特点

2. `TRUNCATE` 的语法

3. `TRUNCATE` 与 `DELETE` 的区别

4. `TRUNCATE` 的适用场景

40.Java的特性抽象继承封装多态