枫诀网络科技工作室 · 探索代码与设计的边界

Elasticsearch Linux 服务器安装使用指南

Fri, 03 Apr 2026 00:00:00 GMT

Elasticsearch是基于Apache Lucene的开源分布式搜索和分析引擎，提供RESTful API进行交互，支持近实时搜索和全文检索。

1. 环境要求#

1.1 硬件配置#

组件	最低配置	推荐配置
CPU	2核	4核以上
内存	4GB	16GB以上
磁盘	10GB	100GB以上 SSD

1.2 软件要求#

操作系统：CentOS 7/8、Ubuntu 18.04/20.04/22.04、RHEL 7/8
Java：JDK 11或更高版本（Elasticsearch 8.x自带OpenJDK）

1.3 系统参数要求#

最大文件描述符：至少65535
最大线程数：至少4096
虚拟内存：至少262144

2. 安装前准备#

2.1 创建Elasticsearch用户#

Terminal window

1
sudo groupadd elasticsearch
2
sudo useradd -g elasticsearch -s /bin/bash -m elasticsearch

2.2 配置系统参数#

文件描述符限制：

Terminal window

1
sudo vim /etc/security/limits.conf
2
# 添加以下内容
3
elasticsearch soft nofile 65535
4
elasticsearch hard nofile 65535
5
elasticsearch soft nproc 4096
6
elasticsearch hard nproc 4096

虚拟内存设置：

Terminal window

1
sudo vim /etc/sysctl.conf
2
vm.max_map_count=262144
3
sudo sysctl -p

禁用Swap（推荐）：

Terminal window

1
sudo swapoff -a

3. 安装Elasticsearch#

3.1 RPM包安装（CentOS/RHEL）#

Terminal window

1
# 导入GPG密钥
2
sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
3

4
# 创建仓库（清华大学镜像源）
5
sudo vim /etc/yum.repos.d/elasticsearch.repo
6
# 添加以下内容：
7
# [elasticsearch]
8
# baseurl=https://mirrors.tuna.tsinghua.edu.cn/elasticstack/yum/elastic-8.x/
9
# gpgcheck=1
10
# gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
11

12
sudo yum install elasticsearch -y

3.2 DEB包安装（Ubuntu/Debian）#

Terminal window

1
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg
2
echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://mirrors.tuna.tsinghua.edu.cn/elasticstack/apt/8.x stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
3
sudo apt-get update && sudo apt-get install elasticsearch -y

3.3 tar.gz包安装（通用）#

Terminal window

1
cd /opt
2
sudo wget https://mirrors.tuna.tsinghua.edu.cn/elasticstack/downloads/elasticsearch/elasticsearch-8.11.0-linux-x86_64.tar.gz
3
sudo tar -xzf elasticsearch-8.11.0-linux-x86_64.tar.gz
4
sudo mv elasticsearch-8.11.0 elasticsearch
5
sudo chown -R elasticsearch:elasticsearch /opt/elasticsearch

4. 启动服务#

4.1 Systemd管理（RPM/DEB安装）#

Terminal window

1
sudo systemctl daemon-reload
2
sudo systemctl enable elasticsearch
3
sudo systemctl start elasticsearch
4
sudo systemctl status elasticsearch

4.2 手动启动（tar.gz安装）#

Terminal window

1
su - elasticsearch
2
/opt/elasticsearch/bin/elasticsearch -d -p pid

4.3 保存初始密码#

安装完成后会显示自动生成的密码，请务必保存：

1
用户名：elastic
2
密码：d8Yoo5g5g*TFbcAFpJSg

重置密码命令：

Terminal window

1
sudo /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic

5. 配置Elasticsearch#

5.1 配置文件位置#

RPM/DEB安装：/etc/elasticsearch/elasticsearch.yml
tar.gz安装：/opt/elasticsearch/config/elasticsearch.yml

5.2 基本配置#

Terminal window

1
sudo vim /etc/elasticsearch/elasticsearch.yml

添加以下内容：

1
cluster.name: my-elasticsearch-cluster
2
node.name: node-1
3
discovery.type: single-node
4
network.host: 0.0.0.0
5
http.port: 9200
6
path.data: /var/lib/elasticsearch
7
path.logs: /var/log/elasticsearch

5.3 JVM配置#

编辑jvm.options文件：

Terminal window

1
sudo vim /etc/elasticsearch/jvm.options

设置堆内存（建议不超过物理内存的50%）：

1
-Xms512m
2
-Xmx1g

5.4 2核2G环境优化配置#

1
indices.queries.cache.size: 5%
2
indices.requests.cache.size: 1%
3
thread_pool.write.queue_size: 200
4
thread_pool.search.queue_size: 500

5.5 目录权限#

Terminal window

1
sudo chown -R elasticsearch:elasticsearch /var/lib/elasticsearch
2
sudo chown -R elasticsearch:elasticsearch /var/log/elasticsearch
3
sudo chown -R elasticsearch:elasticsearch /etc/elasticsearch

6. 验证安装#

6.1 检查服务状态#

Terminal window

1
# 等待服务启动（通常需要10-30秒）
2
sleep 15
3

4
# 使用curl测试
5
curl -k -u elastic:你的密码 https://localhost:9200

6.2 预期输出#

1
{
2
  "name" : "node-1",
3
  "cluster_name" : "my-elasticsearch-cluster",
4
  "version" : {
5
    "number" : "8.11.0"
6
  },
7
  "tagline" : "You Know, for Search"
8
}

6.3 查看集群健康#

Terminal window

1
curl -k -u elastic:你的密码 https://localhost:9200/_cluster/health?pretty

健康状态说明：

green：所有分片都可用
yellow：主分片可用，副本分片不可用
red：部分主分片不可用

7. 基本使用#

7.1 索引操作#

创建索引：

Terminal window显示更多显示更少

1
curl -k -X PUT "https://localhost:9200/products" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d @"{
5
    \"settings\": {
6
      \"number_of_shards\": 1,
7
      \"number_of_replicas\": 0
8
    },
9
    \"mappings\": {
10
      \"properties\": {
11
        \"name\": { \"type\": \"text\" },
12
        \"price\": { \"type\": \"float\" },
13
        \"description\": { \"type\": \"text\" },
14
        \"created_at\": { \"type\": \"date\" }
15
      }
16
    }
17
  }"@

显示更多显示更少

查看所有索引：

Terminal window

1
curl -k -u elastic:你的密码 "https://localhost:9200/_cat/indices?v"

删除索引：

Terminal window

1
curl -k -X DELETE "https://localhost:9200/products" -u elastic:你的密码

7.2 文档操作#

添加文档：

Terminal window

1
curl -k -X POST "https://localhost:9200/products/_doc" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"name\": \"笔记本电脑\", \"price\": 5999.00, \"description\": \"高性能办公笔记本\"}"
5

6
curl -k -X PUT "https://localhost:9200/products/_doc/1" \
7
  -u elastic:你的密码 \
8
  -H "Content-Type: application/json" \
9
  -d "{\"name\": \"台式电脑\", \"price\": 8999.00}"

查询文档：

Terminal window

1
curl -k -X GET "https://localhost:9200/products/_doc/1?pretty" -u elastic:你的密码
2
curl -k -X GET "https://localhost:9200/products/_search?pretty" -u elastic:你的密码

更新文档：

Terminal window

1
curl -k -X POST "https://localhost:9200/products/_update/1" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"doc\": {\"price\": 7999.00}}"

删除文档：

Terminal window

1
curl -k -X DELETE "https://localhost:9200/products/_doc/1" -u elastic:你的密码

7.3 搜索查询#

全文搜索：

Terminal window

1
curl -k -X GET "https://localhost:9200/products/_search?pretty" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"query\": {\"match\": {\"name\": \"电脑\"}}}"

精确匹配：

Terminal window

1
curl -k -X GET "https://localhost:9200/products/_search?pretty" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"query\": {\"term\": {\"price\": 5999.00}}}"

范围查询：

Terminal window

1
curl -k -X GET "https://localhost:9200/products/_search?pretty" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"query\": {\"range\": {\"price\": {\"gte\": 100, \"lte\": 6000}}}}"

组合查询：

Terminal window

1
curl -k -X GET "https://localhost:9200/products/_search?pretty" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"query\": {\"bool\": {\"must\": [{\"match\": {\"description\": \"办公\"}}], \"filter\": [{\"range\": {\"price\": {\"lte\": 6000}}}]}}}"

8. 安全配置#

8.1 重置用户密码#

Terminal window

1
cd /usr/share/elasticsearch/bin
2
sudo ./elasticsearch-reset-password -u elastic

8.2 创建新用户#

Terminal window

1
curl -k -X POST "https://localhost:9200/_security/user/myuser" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"password\": \"mypassword\", \"roles\": [\"kibana_admin\", \"monitoring_user\"]}"

8.3 配置防火墙#

Terminal window

1
# CentOS/RHEL
2
sudo firewall-cmd --permanent --add-port=9200/tcp
3
sudo firewall-cmd --permanent --add-port=9300/tcp
4
sudo firewall-cmd --reload
5

6
# Ubuntu/Debian
7
sudo ufw allow 9200/tcp
8
sudo ufw allow 9300/tcp

9. 常见问题与解决方案#

9.1 vm.max_map_count is too low#

Terminal window

1
sudo sysctl -w vm.max_map_count=262144
2
echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf

9.2 max file descriptors too low#

编辑/etc/security/limits.conf添加：

1
elasticsearch soft nofile 65535
2
elasticsearch hard nofile 65535

然后重新登录elasticsearch用户。

9.3 OutOfMemoryError#

Terminal window

1
sudo vim /etc/elasticsearch/jvm.options
2
-Xms512m
3
-Xmx1g
4
sudo systemctl restart elasticsearch

9.4 集群状态为Yellow#

单节点模式下设置副本数为0：

Terminal window

1
curl -k -X PUT "https://localhost:9200/_settings" \
2
  -u elastic:你的密码 \
3
  -H "Content-Type: application/json" \
4
  -d "{\"index\": {\"number_of_replicas\": 0}}"

9.5 无法连接Elasticsearch#

Terminal window

1
sudo systemctl status elasticsearch
2
sudo netstat -tlnp | grep 9200
3
sudo tail -f /var/log/elasticsearch/*.log

10. 备份与恢复#

10.1 创建快照仓库#

Terminal window

1
sudo mkdir -p /opt/elasticsearch/backup
2
sudo chown -R elasticsearch:elasticsearch /opt/elasticsearch/backup
3

4
# 编辑elasticsearch.yml添加：path.repo: ["/opt/elasticsearch/backup"]
5

6
curl -k -X PUT "https://localhost:9200/_snapshot/my_backup" \
7
  -u elastic:你的密码 \
8
  -H "Content-Type: application/json" \
9
  -d "{\"type\": \"fs\", \"settings\": {\"location\": \"/opt/elasticsearch/backup\"}}"

10.2 创建快照#

Terminal window

1
curl -k -X PUT "https://localhost:9200/_snapshot/my_backup/snapshot_1?wait_for_completion=true" \
2
  -u elastic:你的密码

10.3 恢复快照#

Terminal window

1
curl -k -X POST "https://localhost:9200/_snapshot/my_backup/snapshot_1/_restore" \
2
  -u elastic:你的密码

11. 监控与维护#

Terminal window显示更多显示更少

1
# 集群健康
2
curl -k -u elastic:你的密码 "https://localhost:9200/_cluster/health?pretty"
3

4
# 节点信息
5
curl -k -u elastic:你的密码 "https://localhost:9200/_cat/nodes?v"
6

7
# 索引状态
8
curl -k -u elastic:你的密码 "https://localhost:9200/_cat/indices?v&s=store.size:desc"
9

10
# 强制合并索引
11
curl -k -X POST "https://localhost:9200/products/_forcemerge?max_num_segments=1" \
12
  -u elastic:你的密码
13

14
# 清理缓存
15
curl -k -X POST "https://localhost:9200/_cache/clear" -u elastic:你的密码

显示更多显示更少

12. 重要文件路径#

类型	RPM/DEB路径	tar.gz路径
配置文件	/etc/elasticsearch	/opt/elasticsearch/config
数据目录	/var/lib/elasticsearch	/opt/elasticsearch/data
日志目录	/var/log/elasticsearch	/opt/elasticsearch/logs

13. 常用端口#

端口	用途
9200	HTTP REST API
9300	节点间通信

结语#

本文详细介绍了Elasticsearch在Linux服务器上的完整安装和使用流程。建议：

合理配置集群（生产环境至少3个主节点）
定期备份重要数据
监控集群健康状态和性能指标
根据业务需求调整索引策略
保持软件版本更新

Java数组元素反转：详解双指针交换算法

Wed, 01 Apr 2026 00:00:00 GMT

数组元素反转#

1
需求：某个数组有5个数据：10,20,30,40,50，请将这个数组中的数据进行反转。
2
      [10, 20, 30, 40, 50]  反转后 [50, 40, 30, 20, 10]

数组元素反转的核心，其实是数组中两个数据的交换。我们可以认为两个数据分别存储在两个水杯中。想要交换两个水杯中的东西，我们得借助第三个水杯，如下图所示

数据交换原理

交换步骤

数组中元素交换，就是用的借用第三方变量的思想。我们把数组中的每一个元素当做一个水杯，然后索引控制哪两个元素互换位置。

怎么样，才能达到元素反转的效果呢？我们只需将第一个和最后一个元素互换、第二个和倒数第二个互换、依次内推… 如下图所示

数组反转过程

代码实现#

怎么样写代码，才能达到上面的效果呢？我们继续分析

1
1.每次交换，需要有左右两边的两个索引，我们可以用i和j表示
2
    刚开始i=0，j=数组长度-1;
3
2.每次让i和j索引位置的两个元素互换位置
4
    arr[i]和arr[j]互换位置
5
3.每次还完位置之后，让i往右移动一位，让j往前移动一位

具体代码如下

1
public class Test2 {
2
    public static void main(String[] args) {
3
        // 目标：完成数组反转。
4
        // 1、准备一个数组
5
        int[] arr = {10, 20, 30, 40, 50};
6

7
        // 2、定义一个循环，设计2个变量，一个在前，一个在后
8
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
9
            // arr[i]   arr[j]
10
            // 交换
11
            // 1、定义一个临时变量记住后一个位置处的值
12
            int temp = arr[j];
13
            // 2、把前一个位置处的值赋值给后一个位置了
14
            arr[j] = arr[i];
15
            // 3、把临时变量中记住的后一个位置处的值赋值给前一个位置处
16
            arr[i] = temp;
17
        }
18

19
        // 3、遍历数组中的每个数据，看是否反转成功了
20
        for (int i = 0; i < arr.length; i++) {
21
            System.out.print(arr[i] + " ");
22
        }
23
    }
24
}

显示更多显示更少

执行流程详解#

第一步：初始化#

i = 0，j = 4（数组长度 - 1）
数组：[10, 20, 30, 40, 50]

第二步：第一次交换#

交换 arr[0] 和 arr[4]：10 ↔ 50
数组变为：[50, 20, 30, 40, 10]
i++ → i = 1，j-- → j = 3

第三步：第二次交换#

交换 arr[1] 和 arr[3]：20 ↔ 40
数组变为：[50, 40, 30, 20, 10]
i++ → i = 2，j-- → j = 2

第四步：循环结束#

当 i >= j 时，循环结束
最终数组：[50, 40, 30, 20, 10]

关键点总结#

双指针技术：使用两个指针从数组两端向中间移动
临时变量：借助第三个变量实现元素交换
循环条件：i < j 确保不会重复交换
时间复杂度：O(n)，其中 n 是数组长度
空间复杂度：O(1)，只使用了常数级别的额外空间

总结#

通过上面的案例，需要我们掌握元素互换位置的编程思路；以后遇到数据互换问题，都这样做。这是数组操作中的经典算法，也是理解更复杂算法的基础。

Java数组

Wed, 01 Apr 2026 00:00:00 GMT

一、认识数组#

1. 什么是数组#

数组就是一个容器，用来存一批同种类型的数据的。

比如：想要存储 20,10,80,60,90 这些数据。我们可以把代码写成这样

1
int[] array = {20,10,80,60,90};

比如：想要存储 “牛二”,“西门”,“全蛋” 这些数据。我们可以把代码写成这样

1
String[] names = {"牛二", "西门", "全蛋"};

二、数组的定义和访问#

数组有两种初始化的方式，一种是静态初始化、一种是动态初始化。我们先用静态初始化来学习数组的操作。

2.1 数组的静态初始化#

所谓静态初始化指的是：在定义数组时直接给数组中的数据赋值。

1. 静态初始化标准格式：

1
数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3};

按照格式定义int类型、double类型数组

1
//定义数组，用来存储多个年龄
2
int[] ages = new int[]{12, 24, 36}
3
//定义数组，用来存储多个成绩
4
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};

2. 静态初始化简化格式

Java语言的设计者为了简化定义数组的写法，还为静态初始化提供了一种简化写法

1
数据类型[] 变量名 = {元素1,元素2,元素3};

使用简化格式定义int类型、double类型数组

1
//定义数组，用来存储多个年龄
2
int[] ages = {12, 24, 36}
3
//定义数组，用来存储多个成绩
4
double[] scores = {89.9, 99.5, 59.5, 88.0};

3. 注意哟！！

定义数组时，数据类型[] 数组名 也可写成 数据类型数组名[]

1
//以下两种写法是等价的。但是建议大家用第一种，因为这种写法更加普遍
2
int[] ages = {12, 24, 36};
3
int ages[] = {12, 24, 36}

4. 数组在计算机中的基本原理

我们知道数组是怎么定义的之后，那么接下来看一下数组在计算机中的基本原理。

我们以int[] ages = {12,24,36};这句话为例，看一下这句话到底在计算机中做了那些事情。

首先，左边int[] ages 表示定义了一个数组类型的变量，变量名叫ages
其次，右边{12,24,36}表示创建一个数组对象，你完全可以把它理解成一个能装数据的东西。这个对象在内存中会有一个地址值[I@4c873330，每次创建一个数组对象都会有不用的地址值。
然后，把右边的地址值[I@4c873330赋值给左边的ages变量
所以，ages变量就可以通过地址值，找到数组这个东西。

数组内存原理

2.2 数组的元素访问#

这里所说的访问，意思就是获取中数组中数据的值、或者给数组中的数据赋值。

数组中存储的数据我们叫做元素；而且数组中的每一个元素都有一个编号与之对应，我们把这个编号叫做索引，这个索引是从0依次递增的整数。如下图所示

数组索引

要想访问数组中的元素，格式如下

1
//数组名可以找到数组对象的地址，再通过索引就可以定位到具体的元素了
2
数组名[索引]

接下来用代码来演示一下

1
//索引：       0   1   2
2
int[] arr = {12, 24, 36};
3
// 1、访问数组的全部数据
4
System.out.println(arr[0]); //12
5
System.out.println(arr[1]); //24
6
System.out.println(arr[2]); //36
7
//下面代码没有3索引，会出现ArrayIndexOutOfBoundsException 索引越界异常
8
//System.out.println(arr[3]);
9

10
// 2、修改数组中的数据
11
arr[0] = 66;
12
arr[2] = 100;
13
System.out.println(arr[0]); //66
14
System.out.println(arr[1]); //24
15
System.out.println(arr[2]); //100

显示更多显示更少

除了访问数组中的元素，我们可以获取数组中元素的个数，后面我们统称为数组的长度。

1
// 3、访问数组的元素个数：数组名.length
2
System.out.println(arr.length);
3

4
// 技巧：获取数组的最大索引: arr.length - 1(前提是数组中存在数据)
5
System.out.println(arr.length - 1);
6

7
int[] arr2 = {};
8
System.out.println(arr2.length - 1);

2.3 数组的遍历#

所谓遍历意思就是将数组中的元素一个一个的取出来。

学习了数组中元素的访问，访问元素必须用到索引，如下列代码。

1
int[] ages = {12, 24, 36};
2
System.out.println(ages[0]);
3
System.out.println(ages[1]);
4
System.out.println(ages[2]);

但是，如果数组中有很多很多元素，索引靠自己一个一个数肯定是不行的！我们可以使用for循环从0开始一直遍历到长度-1的位置，就可以获取所有的索引了。

当你获取到每一个索引，那么每一个元素不就获取到了吗？上代码吧

1
int[] ages = {12, 24, 36};
2
for (int i = 0; i < ages.length; i++) {
3
    // i的取值 = 0,1,2
4
    System.out.println(ages[i]);
5
}

2.4 数组静态初始化案例#

学习完数组的静态初始化之后，接下来我们做一个练习题来巩固一下。

1
需求：某部门5名员工的销售额分别是：16、26、36、6、100，请计算出他们部门的总销售额。
2

3
需求分析：
4
    1.看到有16、26、36、6、100这5个数据数据，而且数据值很明确;
5
        1)想到,可以使用数组静态初始化把这5个数据存起来
6

7
    2.请计算出他们部门的总销售额（这不就是求数组中数据的和吗？）
8
        2)必须先将数组中所有的元素遍历出来
9
        3)想要求和，得先有一个求和变量sum
10
        4)再将每一个元素和求和变量sum进行累加（求和思想）

按照分析的思路来写代码

1
// 1、定义一个数组存储5名员工的销售额
2
//索引          0   1    2  3   4
3
int[] money = {16, 26, 36, 6, 100};
4

5
// 3、定义一个变量用于累加求和
6
int sum = 0;
7

8
// 2、遍历这个数组中的每个数据。
9
for (int i = 0; i < money.length; i++) {
10
    // i = 0  1  2  3  4
11
    sum += money[i];
12
}
13
System.out.println("员工的销售总额：" + sum);

2.5 数组的动态初始化#

刚才我们初始化数组时，都是直接将元素写出来。但是还有另一个初始化数组的方式叫 动态初始化。

动态初始化不需要我们写出具体的元素，而是指定元素类型和长度就行。格式如下

1
//数据类型[]  数组名 = new 数据类型[长度];
2
int[] arr = new int[3];

下面是动态初始化数组的原理图。我们发现int[] arr 其实就是一个变量，它记录了数组对象的地址值，而且数组中的元素默认值是0。

数组动态初始化

注意：

使用动态初始化定义数组时，根据元素类型不同，默认值也有所不同。

数组默认值

2.6 数组动态初始化案例#

1
案例需求：
2
    某歌唱比赛，需要开发一个系统：可以录入6名评委的打分，录入完毕后立即输出平均分做
3
    选手得分
4

5
需求分析：
6
    1.需要录入6名评委的分数，可以用一个数组来保存。
7
       因为在评委没有录入分数之前，还不确定数组中应该存哪些数据。
8
       所以可以使用数组的动态初始化
9
    2.遍历数组中的每一个位置，并录入分数，将分数存入数组中
10
    3.遍历数组中的每一个元素，对元素求和

代码如下

1
// 1、定义一个动态初始化的数组，负责后期存储6个评委的打分。
2
double[] scores = new double[6];
3

4
Scanner sc  = new Scanner(System.in);
5

6
// 2、遍历数组中的每个位置，录入评委的分数，存入到数组中去
7
for (int i = 0; i < scores.length; i++) {
8
    // i = 0 1 2 3 4 5
9
    System.out.println("请您输入当前第" + (i + 1) +"个评委的分数：");
10
    double score = sc.nextDouble();
11
    scores[i] = score;
12
}
13

14
// 3、遍历数组中的每个元素进行求和
15
double sum  = 0;
16
for (int i = 0; i < scores.length; i++) {
17
    sum += scores[i];
18
}
19
System.out.println("选手最终得分是：" + sum / scores.length);

显示更多显示更少

总结#

数组是Java中最基础的数据结构，掌握数组的定义、初始化、访问和遍历是学习Java的必修课。通过静态初始化和动态初始化两种方式，我们可以灵活地处理各种数据存储需求。记住：

静态初始化：数据已知，直接赋值
动态初始化：数据未知，先分配空间
索引从0开始：第一个元素的索引是0
遍历用for循环：从0到length-1
默认值不同：数值类型默认0，布尔默认false，引用类型默认null

JAVA常用结构语句

Wed, 01 Apr 2026 00:00:00 GMT

Java控制流

Java 循环结构 - for, while 及 do…while#

顺序结构的程序语句只能被执行一次。#

如果您想要同样的操作执行多次，就需要使用循环结构。#

Java中有三种主要的循环结构：#

while 循环
do…while 循环
for 循环

while 循环#

1
while( 布尔表达式 ) {
2
  //循环内容
3
}

do…while 循环#

1
do {
2
  //代码语句
3
}while(布尔表达式);

for循环#

1
for(初始化; 布尔表达式; 更新) {
2
  //代码语句
3
}
4

5
//增强for语句
6
for(声明语句 : 表达式)
7
{
8
  //代码句子
9
}

关于 for 循环有以下几点说明：#

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。

Java 条件语句 - if…else#

基本 if 语句#

1
if(布尔表达式)
2
{
3
  //如果布尔表达式为true将执行的语句
4
}

if…else 语句#

1
if(布尔表达式){
2
  //如果布尔表达式的值为true
3
}else{
4
  //如果布尔表达式的值为false
5
}

if…else if…else 语句#

1
if(布尔表达式 1){
2
  //如果布尔表达式 1的值为true执行代码
3
}else if(布尔表达式 2){
4
  //如果布尔表达式 2的值为true执行代码
5
}else if(布尔表达式 3){
6
  //如果布尔表达式 3的值为true执行代码
7
}else {
8
  //如果以上布尔表达式都不为true执行代码
9
}

嵌套的 if…else 语句#

1
if(布尔表达式 1){
2
  //如果布尔表达式 1的值为true执行代码
3
  if(布尔表达式 2){
4
    //如果布尔表达式 2的值为true执行代码
5
  }
6
}

Java switch case 语句#

1
switch(expression){
2
  case value :
3
    //语句
4
    break; //可选
5
  case value :
6
    //语句
7
    break; //可选
8
  //你可以有任意数量的case语句
9
  default : //可选
10
    //语句
11
}

switch case 语句有如下规则：#

支持的数据类型：switch 语句中的变量类型可以是 byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
多个 case 语句：switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
数据类型匹配：case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
执行流程：当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
break 语句：当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
default 分支：switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

实际应用示例#

for 循环示例：

1
// 基本 for 循环
2
for(int i = 0; i < 10; i++) {
3
  System.out.println("i = " + i);
4
}
5

6
// 增强 for 循环（遍历数组）
7
int[] numbers = {1, 2, 3, 4, 5};
8
for(int num : numbers) {
9
  System.out.println(num);
10
}

switch case 示例：

1
int day = 3;
2
switch(day) {
3
  case 1:
4
    System.out.println("Monday");
5
    break;
6
  case 2:
7
    System.out.println("Tuesday");
8
    break;
9
  case 3:
10
    System.out.println("Wednesday");
11
    break;
12
  default:
13
    System.out.println("Other day");
14
}

嵌套条件示例：

1
int score = 85;
2
if(score >= 90) {
3
  System.out.println("Grade: A");
4
} else if(score >= 80) {
5
  System.out.println("Grade: B");
6
} else if(score >= 70) {
7
  System.out.println("Grade: C");
8
} else {
9
  System.out.println("Grade: F");
10
}

总结#

掌握这些基本的控制流语句是编写高效 Java 代码的基础。通过合理使用循环、条件判断和 switch 语句，你可以构建复杂的业务逻辑。记住：

使用 for 循环 处理已知次数的迭代
使用 while 循环 处理条件驱动的迭代
使用 if…else 处理简单的二元或多元条件
使用 switch case 处理多个离散值的判断

Java JSON 序列化库详解：Jackson、Gson、Fastjson

Wed, 01 Apr 2026 00:00:00 GMT

1. 概述#

本文详细介绍 Java 生态中三种最流行的 JSON 处理库：Jackson、Gson 和 Fastjson。内容将涵盖它们的基本用法、高级特性、性能对比、优缺点分析以及最终的选型建议。目标读者是需要为项目选择 JSON 库或希望深入了解这些库区别的 Java 开发者。

2. 库简介#

2.1 Jackson#

官网： https://github.com/FasterXML/jackson
简介： Jackson 是 Java 生态中事实上的标准 JSON 处理库，功能极其丰富，性能优异。它是 Spring Framework 等众多主流框架的默认选择。Jackson 的核心是基于流的解析器（Streaming API），并在此基础上构建了数据绑定（Data Binding）功能，使开发者可以方便地与 POJO（Plain Old Java Object）进行转换。

2.2 Gson#

官网： https://github.com/google/gson
简介：由 Google 开发，以其简单的 API 和易用性著称。Gson 的设计初衷是提供一种简单的方式将 Java 对象转换为 JSON 字符串（序列化），以及将 JSON 字符串转换为 Java 对象（反序列化）。它的上手难度很低，对于简单的场景非常友好。

2.3 Fastjson#

官网： https://github.com/alibaba/fastjson
简介：由阿里巴巴开发，主打极致性能。在诸多性能基准测试中，Fastjson 的序列化/反序列化速度常常名列前茅。它提供了完整的 JSON 功能，并且 API 设计也较为直接。然而，其历史上出现过较多安全漏洞，这是选型时需要重点考虑的因素。

3. 详细使用说明#

3.1 基本依赖引入（Maven）#

1
<!-- Jackson -->
2
<dependency>
3
    <groupId>com.fasterxml.jackson.core</groupId>
4
    <artifactId>jackson-databind</artifactId>
5
    <version>2.15.2</version>
6
</dependency>
7

8
<!-- Gson -->
9
<dependency>
10
    <groupId>com.google.code.gson</groupId>
11
    <artifactId>gson</artifactId>
12
    <version>2.10.1</version>
13
</dependency>
14

15
<!-- Fastjson -->
16
<dependency>
17
    <groupId>com.alibaba</groupId>
18
    <artifactId>fastjson</artifactId>
19
    <version>2.0.40</version> <!-- 注意：强烈建议使用最新安全版本 -->
20
</dependency>

显示更多显示更少

3.2 基本用法示例#

假设我们有一个简单的 Java 对象 User：

1
public class User {
2
    private String name;
3
    private int age;
4
    private String email;
5

6
    // 无参构造器、Getter 和 Setter 方法必须存在
7
    public User() {}
8

9
    public User(String name, int age, String email) {
10
        this.name = name;
11
        this.age = age;
12
        this.email = email;
13
    }
14
    // ... getters and setters
15
}

显示更多显示更少

1. Jackson

1
import com.fasterxml.jackson.databind.ObjectMapper;
2

3
ObjectMapper mapper = new ObjectMapper();
4
User user = new User("张三", 25, "zhangsan@example.com");
5

6
// 序列化：对象 -> JSON字符串
7
String jsonString = mapper.writeValueAsString(user);
8
System.out.println(jsonString); // {"name":"张三","age":25,"email":"zhangsan@example.com"}
9

10
// 反序列化：JSON字符串 -> 对象
11
String jsonInput = "{\"name\":\"李四\",\"age\":30,\"email\":\"lisi@example.com\"}";
12
User userObject = mapper.readValue(jsonInput, User.class);
13
System.out.println(userObject.getName()); // 李四

2. Gson

1
import com.google.gson.Gson;
2

3
Gson gson = new Gson();
4
User user = new User("张三", 25, "zhangsan@example.com");
5

6
// 序列化
7
String jsonString = gson.toJson(user);
8
System.out.println(jsonString); // 输出与 Jackson 类似
9

10
// 反序列化
11
String jsonInput = "{\"name\":\"李四\",\"age\":30,\"email\":\"lisi@example.com\"}";
12
User userObject = gson.fromJson(jsonInput, User.class);
13
System.out.println(userObject.getName()); // 李四

3. Fastjson

1
import com.alibaba.fastjson.JSON;
2

3
User user = new User("张三", 25, "zhangsan@example.com");
4

5
// 序列化
6
String jsonString = JSON.toJSONString(user);
7
System.out.println(jsonString); // 输出与 Jackson 类似
8

9
// 反序列化
10
String jsonInput = "{\"name\":\"李四\",\"age\":30,\"email\":\"lisi@example.com\"}";
11
User userObject = JSON.parseObject(jsonInput, User.class);
12
System.out.println(userObject.getName()); // 李四

从基本用法看，三者非常相似。

3.3 高级特性对比#

特性	Jackson	Gson	Fastjson
注解支持	极其丰富 (`@JsonIgnore`, `@JsonProperty`, `@JsonFormat`, `@JsonInclude` 等)	支持基本注解 (`@SerializedName`, `@Expose`)	支持丰富注解 (`@JSONField`, `@JSONType`)，功能接近 Jackson
日期格式化	通过 `@JsonFormat` 注解或全局配置	通过 `GsonBuilder.setDateFormat()` 或自定义序列化器	通过 `@JSONField(format="yyyy-MM-dd")` 或 `SerializerFeature`
空值处理	通过 `@JsonInclude(Include.NON_NULL)` 控制	通过 `GsonBuilder.serializeNulls()` 控制	通过 `SerializerFeature` 控制，如 `WriteMapNullValue`
多态处理	强大支持 (`@JsonTypeInfo`, `@JsonSubTypes`)	支持，但需要自定义 `TypeAdapter`，较为复杂	支持 (`@JSONType`, `seeAlso`)，功能强大
自定义序列化/反序列化	通过继承 `JsonSerializer`/`JsonDeserializer`	通过实现 `JsonSerializer`/`JsonDeserializer` 接口	通过实现 `ObjectSerializer`/`ObjectDeserializer` 接口
JSON Schema 支持	有	无	无
树模型	`JsonNode`	`JsonElement`	`JSONObject` / `JSONArray`
流式 API	核心优势，高性能解析和生成	有，但不如 Jackson 强大和常用	有

Jackson 注解示例：

1
public class User {
2
    @JsonProperty("full_name") // 指定JSON字段名
3
    private String name;
4

5
    @JsonIgnore // 忽略该字段
6
    private String password;
7

8
    @JsonFormat(pattern = "yyyy-MM-dd")
9
    private Date birthday;
10

11
    @JsonInclude(JsonInclude.Include.NON_NULL) // 为空时不序列化
12
    private String nickname;
13
    // ...
14
}

4. 优缺点对比#

方面	Jackson	Gson	Fastjson
性能	非常高，尤其是流式 API。在大多数场景下与 Fastjson 互有胜负，综合表现最优。	良好，但在处理复杂对象和大数据量时通常慢于 Jackson 和 Fastjson。	极致序列化速度，尤其在特定场景下。但反序列化性能优势不一定明显，且高版本由于安全修复性能有所下降。
功能/灵活性	最丰富，提供了从底层流处理到高级数据绑定的完整解决方案，支持大量数据格式（JSON, XML, CSV等）。	简单够用，API 直观，满足日常大部分需求。高级功能需要自定义，灵活性较差。	功能丰富，注解等功能向 Jackson 看齐，但整体生态和扩展性不如 Jackson。
易用性	中等，API 略复杂，需要学习的概念较多（如 `ObjectMapper` 的各种配置）。	极高，`new Gson().toJson/fromJson` 即可完成大部分工作，上手飞快。	高，API 设计简单直接，与 Gson 类似，易于上手。
社区/生态	最活跃和强大，是 Spring、JAX-RS 等框架的默认集成库，文档齐全，社区支持好。	活跃，由 Google 维护，社区庞大，稳定可靠。	活跃但存在争议，由阿里巴巴维护，但历史上安全漏洞频发，影响其声誉。
安全性	非常高，经过大规模企业级应用验证，安全记录良好。	非常高，同样经过广泛验证，安全性值得信赖。	历史记录较差，曾多次曝出高危反序列化远程代码执行（RCE）漏洞，选型时需特别谨慎，务必使用最新版本。
稳定性	极高，API 稳定，向后兼容性好。	极高，API 非常稳定。	一般，不同大版本间 API 变化可能较大。

5. 总结与选型建议#

场景	推荐库	理由
新项目/企业级项目	Jackson	功能、性能、生态、安全性的最佳平衡。尤其是基于 Spring 的项目，无需额外引入，无缝集成。
快速原型/简单应用	Gson	API 极其简单，学习成本低，能让开发者快速实现功能。对于逻辑不复杂的 Android 应用也是好选择。
极致性能优先（非敏感场景）	Fastjson	如果项目的主要瓶颈在于 JSON 序列化性能，且能承担潜在的安全风险（例如严格的内网环境），并承诺始终跟进最新安全版本，可考虑 Fastjson。
高安全性要求项目	Jackson 或 Gson	绝对避免使用 Fastjson。金融、政务等对安全有严苛要求的项目应选择经过长期考验、安全记录良好的 Jackson 或 Gson。

最终建议：

对于绝大多数 Java 项目，尤其是微服务、Web 后端等企业级应用，Jackson 是毋庸置疑的首选。 它是功能、性能和可靠性上的”三好学生”，拥有最健康的生态。Gson 则在简单性和易用性上胜出，是轻量级项目的绝佳选择。而 Fastjson，尽管在性能上有其亮点，但其历史上的安全问题像一把达摩克利斯之剑，使得在大多数严肃项目中不推荐使用，除非有非常特殊的性能需求并且能完全掌控其安全风险。

在选择时，请务必结合项目的具体需求、团队的技术背景以及对安全性的要求进行综合判断。

Java方法详解：从入门到实战，掌握代码复用的核心

Wed, 01 Apr 2026 00:00:00 GMT

面向对象最核心的套路是：设计对象来处理数据，解决问题。

目前我们学习的面向对象高级部分的知识点，就像一个一个的螺丝钉，在学习过程中你可能并不知道这些螺丝钉是用在哪里的，解决的什么问题。必须等这些内容都学习完之后，才能知道用这些螺丝钉可以用来搞飞机、造航母、造火箭。

面向对象

一、静态#

面向对象编程中很常见的一个关键字static.

static读作静态，可以用来修饰成员变量，也能修饰成员方法。static修饰成员变量。

1.1 static修饰成员变量#

Java中的成员变量按照有无static修饰分为两种：类变量、实例变量。它们的区别如下图所示：

类变量与实例变量

由于静态变量是属于类的，只需要通过类名就可以调用：类名.静态变量

实例变量是属于对象的，需要通过对象才能调用：对象.实例变量

下面是代码演示（注意静态变量，和实例变量是如何调用的）

代码演示

在这里给大家在啰嗦几句，我们来看一下上面代码的内存原理。

内存原理

最后总结一下

1
- 1.类变量：属于类，在内存中只有一份，用类名调用
2
- 2.实例变量：属于对象，每一个对象都有一份，用对象调用

1.2 static修饰成员变量的应用场景#

static修饰成员变量在实际工作中的应用。

在实际开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住。

我们看一个案例
需求：系统启动后，要求用于类可以记住自己创建了多少个用户对象。

第一步：先定义一个User类，在用户类中定义一个static修饰的变量，用来表示在线人数；

1
public class User{
2
    public static int number;
3
    //每次创建对象时，number自增一下
4
    public User(){
5
        User.number++;
6
    }
7
}

第二步：再写一个测试类，再测试类中创建4个User对象，再打印number的值，观察number的值是否再自增。

1
public class Test{
2
    public static void main(String[] args){
3
        //创建4个对象
4
        new User();
5
        new User();
6
        new User();
7
        new User();
8

9
        //查看系统创建了多少个User对象
10
        System.out.println("系统创建的User对象个数："+User.number);
11
    }
12
}

运行上面的代码，查看执行结果是：系统创建的User对象个数：4

1.3 static修饰成员方法#

成员方法根据有无static也分为两类：类方法、实例方法

类方法与实例方法

有static修饰的方法，是属于类的，称为类方法；调用时直接用类名调用即可。
无static修饰的方法，是属于对象的，称为实例方法；调用时，需要使用对象调用。

我们看一个案例，演示类方法、实例方法的基本使用

先定义一个Student类，在类中定义一个类方法、定义一个实例方法

1
public class Student{
2
    double score;
3

4
    //类方法：
5
    public static void printHelloWorld{
6
        System.out.println("Hello World!");
7
        System.out.println("Hello World!");
8
    }
9

10
    //实例方法（对象的方法）
11
    public void printPass(){
12
        //打印成绩是否合格
13
        System.out.println(score>=60?"成绩合格":"成绩不合格");
14
    }
15
}

显示更多显示更少

在定义一个测试类，注意类方法、对象方法调用的区别

1
public class Test2{
2
    public static void main(String[] args){
3
        //1.调用Student类中的类方法
4
        Student.printHelloWorld();
5

6
        //2.调用Student类中的实例方法
7
        Student s = new Student();
8
        s.printPass();
9

10
        //使用对象也能调用类方法【不推荐，IDEA连提示都不给你，你就别这么用了】
11
        s.printHelloWorld();
12
    }
13
}

搞清楚类方法和实例方法如何调用之后,看static修饰成员方法的内存原理。

1
1.类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的；
2
         所以类名直接就可以找到static修饰的方法
3

4
2.实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实            例变量，而实例变量需要创建对象后才存在。
5
          所以实例方法，必须创建对象后才能调用。

方法内存原理

1.4 工具类#

一个有关类方法的应用知识，叫做工具类。

如果一个类中的方法全都是静态的，那么这个类中的方法就全都可以被类名直接调用，由于调用起来非常方便，就像一个工具一下，所以把这样的类就叫做工具类。

我们写一个生成验证码的工具类

1
public class MyUtils{
2
    public static String createCode(int n){
3
        //1.定义一个字符串，用来记录产生的验证码
4
        String code = "";
5

6
        //2.验证码是由所有的大写字母、小写字母或者数字字符组成
7
        //这里先把所有的字符写成一个字符串，一会从字符串中随机找字符
8
        String data = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKMNOPQRSTUVWXYZ";
9

10
        //3.循环n次，产生n个索引,再通过索引获取字符
11
        Random r = new Random();
12
        for(int i=0; i<n; i++){
13
            int index = r.nextInt(data.length());
14
            char ch = data.charAt(index);
15
            //4.把获取到的字符，拼接到code验证码字符串上。
16
            code+=ch;
17
        }
18

19
        //最后返回code,code的值就是验证码
20
        return code;
21
    }
22
}

显示更多显示更少

接着可以在任何位置调用MyUtils的createCOde()方法产生任意个数的验证码

1
//比如这是一个登录界面
2
public class LoginDemo{
3
    public static void main(String[] args){
4
        System.out.println(MyUtils.createCode());
5
    }
6
}

1
//比如这是一个注册界面
2
public class registerDemo{
3
    public static void main(String[] args){
4
        System.out.println(MyUtils.createCode());
5
    }
6
}

工具类的使用就是这样子的

工具类里的方法全都是静态的，推荐用类名调用为了防止使用者用对象调用。我们可以把工具类的构造方法私有化。

1
public class MyUtils{
2
    //私有化构造方法：这样别人就不能使用构造方法new对象了
3
    private MyUtils(){
4

5
    }
6

7
    //类方法
8
    public static String createCode(int n){
9
       ...
10
    }
11
}

1.5 static的注意事项#

到现在在我们已经学会了static修饰的变量、方法如何调用了。但是有一些注意事项还是需要给大家说明一下，目的是让大家知道，使用static写代码时，如果出错了，要知道为什么错、如何改正。

static注意事项

1
public class Student {
2
    static String schoolName; // 类变量
3
    double score; // 实例变量
4

5
    // 1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
6
    public static void printHelloWorld(){
7
        // 注意：同一个类中，访问类成员，可以省略类名不写。
8
        schoolName = "黑马";
9
        printHelloWorld2();
10

11
        System.out.println(score); // 报错的
12
        printPass(); // 报错的
13

14
        ystem.out.println(this); // 报错的
15
    }
16

17
    // 类方法
18
    public static void printHelloWorld2(){
19

20
    }
21

22
    // 实例方法
23
    public void printPass2(){
24

25
    }
26

27
    // 实例方法
28
    // 2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
29
    // 3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的
30
    public void printPass(){
31
        schoolName = "黑马2"; //对的
32
        printHelloWorld2(); //对的
33

34
        System.out.println(score); //对的
35
        printPass2(); //对的
36

37
        System.out.println(this); //对的
38
    }
39
}

显示更多显示更少

1.6 static应用（代码块）#

代码块；代码块根据有无static修饰分为两种：静态代码块、实例代码块

静态代码块：

静态代码块

1
public class Student {
2
    static int number = 80;
3
    static String schoolName = "黑马";
4
    // 静态代码块
5
    static {
6
        System.out.println("静态代码块执行了~~");
7
        schoolName = "黑马";
8
    }
9
}

静态代码块不需要创建对象就能够执行

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：认识两种代码块，了解他们的特点和基本作用。
4
        System.out.println(Student.number);
5
        System.out.println(Student.number);
6
        System.out.println(Student.number);
7

8
        System.out.println(Student.schoolName); // 黑马
9
    }
10
}

执行上面代码时，发现没有创建对象，静态代码块就已经执行了。

静态代码块执行

关于静态代码块重点注意：静态代码块，随着类的加载而执行，而且只执行一次。

实例代码块

实例代码块

实例代码块的作用和构造器的作用是一样的，用来给对象初始化值；而且每次创建对象之前都会先执行实例代码块。

1
public class Student{
2
    //实例变量
3
    int age;
4
    //实例代码块：实例代码块会执行在每一个构造方法之前
5
    {
6
        System.out.println("实例代码块执行了~~");
7
        age = 18;
8
        System.out.println("有人创建了对象：" + this);
9
    }
10

11
    public Student(){
12
        System.out.println("无参数构造器执行了~~");
13
    }
14

15
    public Student(String name){
16
        System.out.println("有参数构造器执行了~~");
17
    }
18
}

显示更多显示更少

接下来在测试类中进行测试，观察创建对象时，实例代码块是否先执行了。

1
public class Test {
2
    public static void main(String[] args) {
3
        Student s1 = new Student();
4
        Student s2 = new Student("张三");
5
        System.out.println(s1.age);
6
        System.out.println(s2.age);
7
    }
8
}

对于实例代码块重点注意：实例代码块每次创建对象之前都会执行一次

1.7 static应用（单例设计模式）#

关于static的应用我们再补充一个使用的技巧，叫做单例设计模式。

所谓设计模式指的是，一类问题可能会有多种解决方案，而设计模式是在编程实践中，多种方案中的一种最优方案。

二、继承#

2.1 继承快速入门#

面向对象编程之所以能够能够被广大开发者认可，有一个非常重要的原因，是因为它有三大特征，继承、封装和多态。

继承概念

接下来，我们演示一下使用继承来编写代码，注意观察继承的特点。

1
public class A{
2
    //公开的成员
3
    public int i;
4
    public void print1(){
5
        System.out.println("===print1===");
6
    }
7

8
    //私有的成员
9
    private int j;
10
    private void print2(){
11
        System.out.println("===print2===");
12
    }
13
}

然后，写一个B类，让B类继承A类。在继承A类的同时，B类中新增一个方法print3

1
public class B extends A{
2
    public void print3(){
3
        //由于i和print1是属于父类A的公有成员，在子类中可以直接被使用
4
        System.out.println(i); //正确
5
        print1(); //正确
6

7
        //由于j和print2是属于父类A的私有成员，在子类中不可以被使用
8
        System.out.println(j); //错误
9
        print2();
10
    }
11
}

接下来，我们再演示一下，创建B类对象，能否调用父类A的成员。再写一个测试类

1
public class Test{
2
    public static void main(String[] args){
3
        B b = new B();
4
        //父类公有成员，子类对象是可以调用的
5
        System.out.println(i); //正确
6
        b.print1();
7

8
        //父类私有成员，子类对象时不可以调用的
9
        System.out.println(j); //错误
10
        b.print2(); //错误
11
    }
12
}

为了让大家对继承有更深入的认识，我们来看看继承的内存原理。

这里我们只需要关注一点：子类对象实际上是由子、父类两张设计图共同创建出来的。

所以，在子类对象的空间中，既有本类的成员，也有父类的成员。但是子类只能调用父类公有的成员。

继承内存原理

2.2 继承的好处#

继承好处

观察代码发现，我们会发现Teacher类中和Consultant类中有相同的代码；其实像这种两个类中有相同代码时，没必要重复写。

我们可以把重复的代码提取出来，作为父类，然后让其他类继承父类就可以了，这样可以提高代码的复用性。改造后的代码如下：

继承重构

接下来使用继承来完成上面的案例，这里只演示People类和Teacher类，然后你尝试自己完成Consultant类。

先写一个父类 People，用来设计Teacher和Consultant公有的成员。

1
public class People{
2
    private String name;
3

4
    public String getName(){
5
        return name;
6
    }
7
    public void setName(String name){
8
        this.name=name;
9
    }
10
}

再写两个子类Teacher继承People类，同时在子类中加上自己特有的成员。

1
public class Teacher extends People{
2
    private String skill; //技能
3

4
    public String getSkill(){
5
        return skill;
6
    }
7

8
    public void setSkill(String skill){
9
        this.skill=skill;
10
    }
11

12
    public void printInfo(){
13
        System.out.println(getName()+"具备的技能："+skill);
14
    }
15
}

显示更多显示更少

最后再写一个测试类，再测试类中创建Teacher、Consultant对象，并调用方法。

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：搞清楚继承的好处。
4
        Teacher t = new Teacher();
5
        t.setName("播仔");
6
        t.setSkill("Java、Spring");
7
        System.out.println(t.getName());
8
        System.out.println(t.getSkill());
9
        t.printInfo();
10
    }
11
}

执行代码，打印结果如下：

执行结果

关于继承的好处我们只需要记住：继承可以提高代码的复用性

2.3 权限修饰符#

在刚才使用继承编写的代码中我们有用到两个权限修饰符，一个是public（公有的）、一个是private（私有的），实际上还有两个权限修饰符，一个是protected（受保护的）、一个是缺省的（不写任何修饰符）。

接下来我们就学习一下这四个权限修饰符分别有什么作用。

什么是权限修饰符呢？
权限修饰符是用来限制类的成员（成员变量、成员方法、构造器…）能够被访问的范围。

每一种权限修饰符能够被访问的范围如下

权限修饰符

下面我们用代码演示一下，在本类中可以访问到哪些权限修饰的方法。

1
public class Fu {
2
    // 1、私有:只能在本类中访问
3
    private void privateMethod(){
4
        System.out.println("==private==");
5
    }
6

7
    // 2、缺省：本类，同一个包下的类
8
    void method(){
9
        System.out.println("==缺省==");
10
    }
11

12
    // 3、protected: 本类，同一个包下的类，任意包下的子类
13
    protected void protectedMethod(){
14
        System.out.println("==protected==");
15
    }
16

17
    // 4、public： 本类，同一个包下的类，任意包下的子类，任意包下的任意类
18
    public void publicMethod(){
19
        System.out.println("==public==");
20
    }
21

22
    public void test(){
23
        //在本类中，所有权限都可以被访问到
24
        privateMethod(); //正确
25
        method(); //正确
26
        protectedMethod(); //正确
27
        publicMethod(); //正确
28
    }
29
}

显示更多显示更少

接下来，在和Fu类同一个包下，创建一个测试类Demo，演示同一个包下可以访问到哪些权限修饰的方法。

1
public class Demo {
2
    public static void main(String[] args) {
3
        Fu f = new Fu();
4
        // f.privateMethod();    //私有方法无法使用
5
        f.method();
6
        f.protectedMethod();
7
        f.publicMethod();
8
    }
9
}

接下来，在另一个包下创建一个Fu类的子类，演示不同包下的子类中可以访问哪些权限修饰的方法。

1
public class Zi extends Fu {
2
    //在不同包下的子类中，只能访问到public、protected修饰的方法
3
    public void test(){
4
        // privateMethod(); // 报错
5
        // method(); // 报错
6
        protectedMethod();    //正确
7
        publicMethod();    //正确
8
    }
9
}

接下来，在和Fu类不同的包下，创建一个测试类Demo2，演示一下不同包的无关类，能访问到哪些权限修饰的方法；

1
public class Demo2 {
2
    public static void main(String[] args) {
3
        Fu f = new Fu();
4
        // f.privateMethod(); // 报错
5
        // f.method();          //报错
6
        // f.protecedMethod();//报错
7
        f.publicMethod();    //正确
8

9
        Zi zi = new Zi();
10
        // zi.protectedMethod();
11
    }
12
}

2.4 单继承、Object#

刚才我们写的代码中，都是一个子类继承一个父类，那么有同学问到，一个子类可以继承多个父类吗？

Java语言只支持单继承，不支持多继承，但是可以多层继承。就像家族里儿子、爸爸和爷爷的关系一样：一个儿子只能有一个爸爸，不能有多个爸爸，但是爸爸也是有爸爸的。

单继承

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：掌握继承的两个注意事项事项。
4
        // 1、Java是单继承的：一个类只能继承一个直接父类；
5
        // 2、Object类是Java中所有类的祖宗。
6
        A a = new A();
7
        B b = new B();
8

9
        ArrayList list = new ArrayList();
10
        list.add("java");
11
        System.out.println(list.toString());
12
    }
13
}
14

15
class A {} //extends Object{}
16
class B extends A{}
17
// class C extends B , A{} // 报错
18
class D extends B{}

显示更多显示更少

2.5 方法重写#

学习完继承之后，在继承的基础之上还有一个很重要的现象需要给大家说一下。

叫做方法重写。为了让大家能够掌握方法重写，我们先认识什么是方法重写，再说一下方法的应用场景。

什么是方法重写

当子类觉得父类方法不好用，或者无法满足父类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意：重写后，方法的访问遵循就近原则。下面我们看一个代码演示

写一个A类作为父类，定义两个方法print1和print2

1
public class A {
2
    public void print1(){
3
        System.out.println("111");
4
    }
5

6
    public void print2(int a, int b){
7
        System.out.println("111111");
8
    }
9
}

再写一个B类作为A类的子类，重写print1和print2方法。

1
public class B extends A{
2
    // 方法重写
3
    @Override // 安全，可读性好
4
    public void print1(){
5
        System.out.println("666");
6
    }
7

8

9
    // 方法重写
10
    @Override
11
    public void print2(int a, int b){
12
        System.out.println("666666");
13
    }
14
}

接下来，在测试类中创建B类对象，调用方法

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：认识方法重写，掌握方法重写的常见应用场景。
4
        B b =  new B();
5
        b.print1();
6
        b.print2(2, 3);
7
    }
8
}

执行代码，我们发现真正执行的是B类中的print1和print2方法

方法重写执行

知道什么是方法重写之后，还有一些注意事项，需要和大家分享一下。

1
- 1.重写的方法上面，可以加一个注解@Override,用于标注这个方法是复写的父类方法
2
- 2.子类复写父类方法时，访问权限必须大于或者等于父类方法的权限
3
    public > protected > 缺省
4
- 3. 重写的方法返回值类型，必须与被重写的方法返回值类型一样，或者范围更小
5
- 4. 私有方法、静态方法不能被重写，如果重写会报错。

关于这些注意事项，只需要了解一下就可以了。实际上我们实际写代码时，只要和父类写的一样就可以（总结起来就8个字：声明不变，重新实现）

方法重写的应用场景

学习完方法重写之后，接下来，我们还需要大家掌握方法重写，在实际中的应用场景。方法重写的应用场景之一就是：子类重写Object的toString()方法，以便返回对象的内容。

比如：有一个Student类，这个类会默认继承Object类。

1
public class Student extends Object{
2
    private String name;
3
    private int age;
4

5
    public Student() {
6
    }
7

8
    public Student(String name, int age) {
9
        this.name = name;
10
        this.age = age;
11
    }
12

13
    public String getName() {
14
        return name;
15
    }
16

17
    public void setName(String name) {
18
        this.name = name;
19
    }
20

21
    public int getAge() {
22
        return age;
23
    }
24

25
    public void setAge(int age) {
26
        this.age = age;
27
    }
28
}

显示更多显示更少

其实Object类中有一个toString()方法，直接通过Student对象调用Object的toString()方法，会得到对象的地址值。

1
public class Test {
2
    public static void main(String[] args) {
3
        Student s = new Student("播妞", 19);
4
        // System.out.println(s.toString());
5
        System.out.println(s);
6
    }
7
}

toString输出

但是，此时不想调用父类Object的toString()方法，那就可以在Student类中重新写一个toSting()方法，用于返回对象的属性值。

1
package com.itheima.d12_extends_override;
2

3
public class Student extends Object{
4
    private String name;
5
    private int age;
6

7
    public Student() {
8
    }
9

10
    public Student(String name, int age) {
11
        this.name = name;
12
        this.age = age;
13
    }
14

15
    public String getName() {
16
        return name;
17
    }
18

19
    public void setName(String name) {
20
        this.name = name;
21
    }
22

23
    public int getAge() {
24
        return age;
25
    }
26

27
    public void setAge(int age) {
28
        this.age = age;
29
    }
30

31
    @Override
32
    public String toString() {
33
        return "Student{" +
34
                "name='" + name + '\'' +
35
                ", age=" + age +
36
                '}';
37
    }
38
}

显示更多显示更少

重新运行测试类，结果如下

toString重写

好了，到这里方法什么是方法重写，以及方法重写的应用场景我们就学习完了。

2.6 子类中访问成员的特点#

刚才我们已经学习了继承，我们发现继承至少涉及到两个类，而每一个类中都可能有各自的成员（成员变量、成员方法），就有可能出现子类和父类有相同成员的情况，那么在子类中访问其他成员有什么特点呢？

原则：在子类中访问其他成员（成员变量、成员方法），是依据就近原则的

定义一个父类，代码如下

1
public class F {
2
    String name = "父类名字";
3

4
    public void print1(){
5
        System.out.println("==父类的print1方法执行==");
6
    }
7
}

再定义一个子类，代码如下。有一个同名的name成员变量，有一个同名的print1成员方法；

1
public class Z extends F {
2
    String name = "子类名称";
3
    public void showName(){
4
        String name = "局部名称";
5
        System.out.println(name); // 局部名称
6
    }
7

8
    @Override
9
    public void print1(){
10
        System.out.println("==子类的print1方法执行了=");
11
    }
12

13
    public void showMethod(){
14
        print1(); // 子类的
15
    }
16
}

显示更多显示更少

接下来写一个测试类，观察运行结果，我们发现都是调用的子类变量、子类方法。

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：掌握子类中访问其他成员的特点：就近原则。
4
        Z z = new Z();
5
        z.showName();
6
        z.showMethod();
7
    }
8
}

如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super进行区分。

1
public class Z extends F {
2
    String name = "子类名称";
3

4
    public void showName(){
5
        String name = "局部名称";
6
        System.out.println(name); // 局部名称
7
        System.out.println(this.name); // 子类成员变量
8
        System.out.println(super.name); // 父类的成员变量
9
    }
10

11
    @Override
12
    public void print1(){
13
        System.out.println("==子类的print1方法执行了=");
14
    }
15

16
    public void showMethod(){
17
        print1(); // 子类的
18
        super.print1(); // 父类的
19
    }
20
}

显示更多显示更少

2.7 子类中访问构造器的特点#

我们知道一个类中可以写成员变量、成员方法，还有构造器。在继承关系下，子类访问成员变量和成员方法的特点我们已经学过了；接下来再学习子类中访问构造器的特点。

我们先认识子类构造器的语法特点，再讲一下子类构造器的应用场景

子类中访问构造器的语法规则

首先，子类全部构造器，都会先调用父类构造器，再执行自己。

执行顺序，如下图按照① ② ③ 步骤执行：

构造器执行顺序

子类访问构造器的应用场景

如果不想使用默认的super()方式调用父类构造器，还可以手动使用super(参数)调用父类有参数构造器。

super调用

在本类中访问自己的构造方法

刚才我们学习了通过super()和super(参数)可以访问父类的构造器。有时候我们也需要访问自己类的构造器。语法如下

1
this(): 调用本类的空参数构造器
2
this(参数): 调用本类有参数的构造器

this调用

最后我们被this和super的用法在总结一下

1
访问本类成员：
2
    this.成员变量    //访问本类成员变量
3
    this.成员方法    //调用本类成员方法
4
    this()           //调用本类空参数构造器
5
    this(参数)      //调用本类有参数构造器
6

7
访问父类成员：
8
    super.成员变量    //访问父类成员变量
9
    super.成员方法    //调用父类成员方法
10
    super()           //调用父类空参数构造器
11
    super(参数)      //调用父类有参数构造器
12

13
注意：this和super访问构造方法，只能用到构造方法的第一句，否则会报错。

2026年SEO优化终极指南：从算法原理到排名飙升的实操策略

Tue, 31 Mar 2026 00:00:00 GMT

一、什么是 SEO？网站优化的核心概念#

SEO（Search Engine Optimization，搜索引擎优化）是一种通过技术与内容策略相结合的方式，提升网站在搜索引擎自然结果中的排名，从而获取更多高质量流量的过程。

它的目标并不仅仅是 “获得更多点击”，而是通过精准关键词吸引目标用户，提高转化率与品牌曝光度。

SEO优化

1. SEO 的定义与目标#

SEO 的核心目标是让搜索引擎 “理解” 并 “信任” 你的网站。当你的网页满足搜索意图，技术结构清晰，内容高质量时，Google 或百度等搜索引擎就会提升你的排名。

2. SEO 的三大类型：技术，内容与外链#

技术 SEO：涉及网站加载速度、移动端优化、结构化数据。
内容 SEO：创建高质量内容、优化关键词与标题。
外链 SEO：通过权威网站反向链接提升信任度。

二、关键词研究：SEO 成功的起点#

关键词研究是 SEO 策略的基石。它决定了你的网站是否能与用户的搜索意图相匹配。

1. 使用关键词研究工具#

工具如 Google Keyword Planner、Ahrefs、5118 能帮助你分析关键词搜索量、竞争度及相关词汇。选择 “搜索量适中、竞争度低” 的词，更易快速获得流量。

2. 长尾关键词的重要性#

长尾关键词（如 “如何快速优化网站 SEO”）虽然搜索量较低，但用户意图更明确、转化率更高。

三、站内优化策略：打造高质量网站结构#

站内优化的目标是让搜索引擎 “轻松抓取，理解、索引” 你的网站。

1. 标题标签优化#

确保每个页面的标题唯一且包含目标关键词。示例：

✅ 好标题示例：如何优化网站 SEO - 新手也能快速上首页！

2. 元描述撰写技巧#

撰写吸引人的 Meta Description，长度控制在 120–160 个字符，在描述中自然融入关键词。

3. 网站结构与内部链接#

使用清晰的网站层级结构（首页 → 分类页 → 内容页），并在文章中合理加入内链，提升权重传递。

四，内容优化：让搜索引擎与读者都喜欢#

在 SEO 中，内容为王。无论算法如何变化，高质量内容始终是网站获得排名的核心。

优秀的内容不仅能吸引用户停留时间，还能促使他们分享，从而自然获得更多外链。

1. 高质量内容的特征#

想让搜索引擎喜欢你的内容，首先要让读者喜欢。优质内容应具备以下特点：

原创性：搜索引擎厌恶重复内容。即便主题相似，也要有独到的观点或数据。
可读性：使用短句、分段，项目符号，提升阅读体验。
权威性：引用可靠数据来源（如 Moz 或 Search Engine Journal）。
可操作性：提供明确步骤或可执行的优化策略。

2. 关键词分布与语义优化（LSI）#

过度堆砌关键词会导致被降权。理想的关键词密度约为 1%~1.3%。

此外，可以使用 语义相关关键词（LSI Keywords），让搜索引擎理解你的内容上下文。

例如，围绕 “如何优化网站 SEO”，可加入相关词：“关键词排名""自然流量""搜索算法优化” 等。

五，外链建设：提升网站权重与信任度#

外链（Backlinks）是 Google 排名算法的重要组成部分。高质量反向链接相当于 “网站的投票”。

1. 获取高质量反向链接的方法#

发布客座文章：在行业博客投稿并附带链接。
内容营销：创作可分享的研究报告、图表或数据内容。
建立合作伙伴链接：与同领域网站互换引用。
品牌提及转化为链接：监测品牌提及并请求添加链接。

2. 避免垃圾外链与黑帽 SEO#

不要购买低质量外链或使用自动生成链接工具。垃圾链接会被搜索引擎识别并处罚。

可使用 Google Disavow 工具拒绝不良反向链接，维护网站权重。

六、技术 SEO：从根源提升搜索表现#

技术 SEO 是网站优化的 “幕后英雄”。它确保搜索引擎可以高效抓取，理解并索引网页。

技术SEO

1. 网站加载速度优化#

网页加载速度是排名和用户体验的重要指标。

优化方法包括：

压缩图片和 CSS 文件
使用 CDN 加速
减少第三方脚本调用
利用缓存机制

2. 移动端适配与响应式设计#

随着移动端搜索超过 70%，Google 实施了 “移动优先索引”。

网站必须在手机和平板上完美显示。

👉 提示：可使用 Google Mobile-Friendly Test 检测页面兼容性。

3. 结构化数据（Schema Markup）#

结构化数据能帮助搜索引擎更好地理解内容，比如显示星级、FAQ、产品价格等。

添加 Schema 能显著提升点击率（CTR）。

七、SEO 工具推荐：提高效率与精准分析#

1. Google Search Console 与 Analytics#

这两款免费工具是每个站长的必备：

Search Console：监控关键词排名与索引问题。
Analytics：分析用户行为、跳出率与转化路径。

2. 5118 与 Ahrefs#

5118：适合中文网站关键词研究与竞争对手分析。
Ahrefs：提供强大的外链分析与内容差距工具。

八、常见 SEO 错误与优化建议#

1. 关键词堆砌与内容重复#

避免在标题或正文中过度使用相同关键词。Google 可能将其视为 “作弊” 行为。

2. 忽略移动端体验#

许多企业网站仍在桌面端表现良好，却在移动端崩坏。移动优化是现代 SEO 的必修课。

3. 未正确使用 Canonical 标签#

重复内容可能导致排名分散。正确设置 Canonical 有助于集中权重。

九、SEO 的未来趋势（2026展望）#

SEO未来趋势

未来的 SEO 将更加智能与人性化。以下三大趋势值得关注：

AI 搜索优化（AIO）：搜索算法将更精准识别用户意图。
语音搜索优化：自然语言关键词（如 “我附近的餐厅”）将持续上升。
个性化结果：搜索结果会依据用户历史与偏好定制。

👉 建议：开始关注 ChatGPT、Gemini、Perplexity 等 AI 搜索模型的内容推荐逻辑。

十、结论：持续优化，才能赢得排名#

SEO 并非 “一次性工作”，而是一个持续监测、改进，再优化的过程。

定期分析数据、调整关键词、更新旧内容，才能让你的网站始终保持竞争力。

记住：SEO 是一种长期投资，而非短期投机。

常见问题（FAQ）#

1. SEO 优化需要多长时间见效？

一般 3~6 个月可见初步效果，取决于行业竞争度与优化力度。

2. 网站流量下降该怎么办？

首先检查算法更新、关键词排名变化，外链质量及内容更新频率。

3. 免费 SEO 工具有哪些？

Google Search Console、Ubersuggest、Ahrefs（部分功能免费）。

4. 内容更新频率是否影响排名？

影响显著。定期更新能维持活跃度与爬虫抓取频率。

5. 外链数量和质量哪个更重要？

质量远胜数量。来自高权重网站的一个链接胜过十个垃圾链接。

6. 如何判断 SEO 是否有效？

通过关键词排名提升、自然流量增长、跳出率下降来判断。

总结#

网站 SEO 优化是一场 “马拉松”，不是 “短跑”。

通过系统化的关键词研究、内容优化、外链建设和技术改进，你的网站将在 2026 年的搜索排名中脱颖而出。

无论你是企业主、营销人还是内容创作者，SEO 都是你最值得投资的数字资产。

为什么现在计算机是二进制的，不是三进制的

Tue, 31 Mar 2026 00:00:00 GMT

在当今数字时代，我们使用的每一台计算机、每一部手机，乃至一块手表，几乎都在以 “0” 与 “1” 的形式进行运算与交流。

然而，这种二进制体系并不是唯一的可能。理论上，我们完全可以构建一种使用 “0、1、2” 三种状态的三进制计算机，甚至多进制计算机。

于是，问题来了：为什么如今的计算机世界几乎清一色地采用二进制，而不是三进制呢？

接下来，我们将从历史起源、逻辑原理、硬件特性，工程现实与未来趋势等五大维度，深入剖析这个问题。

一，二进制的起源与发展历程#

1.1 从哲学到逻辑学：莱布尼茨与 “万物二元” 思想#

17 世纪，德国数学家兼哲学家莱布尼茨（Gottfried Leibniz）首次提出用二进制表示一切事物的思想。他认为世界万物都可以用 “存在（1）” 和 “虚无（0）” 表示，这种符号体系能描述宇宙运行的本质。

莱布尼茨

莱布尼茨的想法在当时被认为更像是哲学幻想，但它却为后来的逻辑学和计算理论提供了数学语言的基础。

1.2 布尔代数与逻辑电路：从思想到现实的桥梁#

到了 19 世纪，英国数学家乔治・布尔（George Boole）将 “真 / 假” 逻辑系统化为数学运算，这便是今天我们熟知的布尔代数。

在 20 世纪，随着电子管和晶体管的发明，人们发现这种 “二元逻辑” 与电子电路的 “开 / 关” 状态天然契合。

布尔代数

这一发现直接推动了早期计算机的诞生。

1.3 图灵与冯・诺依曼：现代计算机的诞生蓝图#

艾伦・图灵在 1936 年提出了 “图灵机” 概念，而冯・诺依曼在 1945 年提出了冯・诺依曼架构，奠定了现代计算机的五大组成部分：运算器、控制器、存储器、输入与输出设备。

这两位大师的设计，全部建立在二进制逻辑的基础之上。

二，二进制的数学与逻辑基础#

2.1 二进制：最简洁的逻辑表达方式#

二进制的核心是用最简单的两个符号表达一切信息。

它不仅能高效地进行逻辑判断，还能与电信号的 “高低电平” 自然对应。

在数字电路中，电压高代表 1，电压低代表 0，这种设计几乎零歧义。

2.2 “0” 和 “1” 的哲学含义#

在更抽象的层面上，二进制其实代表着 “存在与虚无”、“真与假”、“开与关” 的普遍规律。

正如光有阴阳、磁有正负，二进制反映了自然界对称性与稳定性的数学映射。

2.3 二进制与信息论的完美结合#

克劳德・香农（Claude Shannon）在 20 世纪 40 年代创立信息论时，将信息单位定义为比特（bit）。

一个比特正好表示一个二进制状态。香农证明了二进制在信息传输中具有最高的抗干扰性与可靠性，因此成为通信与计算的基础标准。

三，三进制计算机的历史尝试与失败#

3.1 苏联 Setun 三进制计算机的传奇#

1958 年，苏联莫斯科国立大学的尼古拉・布鲁森采夫（Nikolay Brusentsov）领导团队，设计出了世界上第一台三进制电子计算机 ——Setun。

Setun 的核心思想是使用三值逻辑（−1、0、+1），能在更少的位数内处理更多信息。

Setun三进制计算机

在实验中，Setun 在某些算术运算上比同年代的二进制机更高效。然而，它很快被放弃，原因有三：

三值逻辑电路复杂，制造成本高。
当时的电子元件难以维持三种稳定电压。
缺乏三进制编程语言与软件生态。

3.2 三进制的理论优势#

理论上，一个三进制位（trit）可表示的信息量为 log₂3 ≈ 1.585 bits。

这意味着同样的存储空间，三进制可以比二进制节省约 40% 的位数。

但从电气工程角度看，要在电路中区分三个电压等级，误差范围会更小、噪声容忍度更低，导致信号更不稳定。

四、为什么二进制最终胜出#

4.1 硬件简化：成本与稳定性的双重胜利#

在电子世界里，简单就是力量。

二进制电路只需区分 “有电流” 和 “无电流”，设计简单、制造成本低、可靠性高。

三进制电路需要三个不同的电压阈值，这在早期的晶体管技术中几乎无法实现。

4.2 错误检测与纠错更高效#

二进制系统可以轻松实现奇偶校验、CRC 校验等常见错误检测算法。

而三进制编码需要复杂得多的纠错逻辑，增加计算负担。

4.3 技术生态的锁定效应#

整个计算机生态 —— 从 CPU 架构到编译器、操作系统、存储设备、通信协议 —— 全部基于二进制逻辑。

要让三进制取代它，不仅需要硬件革命，还需要软件、教育与产业链的全面迁移。

这几乎是不可能的。

二进制生态

五、未来的多进制计算机：从理论走向现实的可能性#

5.1 光子计算：用光代替电的革命#

光子计算机通过光的不同波长或偏振状态进行运算。

与电信号不同，光子可以同时具有多个可区分状态，这使得多进制逻辑成为可能。

光子计算

如果未来光子计算技术成熟，我们或许将迎来 “天然三进制” 甚至 “十进制” 的信息处理模式。

5.2 量子计算：突破二进制束缚的新逻辑#

量子比特（qubit）并非简单的 0 或 1，而是 0 和 1 的叠加态。

这意味着量子计算机可以同时执行多个计算分支，大幅提高效率。

事实上，部分量子系统已经展现出 “多值逻辑” 的特征。

5.3 类脑计算与人工智能芯片的多值尝试#

人脑的神经元并非二进制开关，而是存在多层激活状态。

类脑芯片（如 IBM 的 TrueNorth、Intel 的 Loihi）正在尝试通过多值电路模拟这种复杂性。

未来的 AI 计算芯片可能会采用 “类三进制” 的思维模式。

类脑芯片

六、哲学层面的思考：二进制是否限制了人类思维？#

一些学者认为，二进制的统治让计算机过于 “非黑即白”。

然而，人类思维充满灰度与模糊性，真正的智能可能需要更接近 “三进制” 或 “多进制” 的逻辑系统。

在人工智能伦理、模糊逻辑控制和情感计算等领域，研究者正试图突破二进制思维的限制，让机器理解 “不确定性”。

七、常见问题（FAQs）#

Q1：三进制计算机真的更高效吗？ 理论上是的，但在硬件制造和信号稳定性上，二进制更实用。

Q2：是否存在现代三进制计算机？ 目前没有大规模商用三进制计算机，但部分研究团队仍在进行实验性探索。

Q3：量子计算算多进制吗？ 严格意义上，它是超越二进制的多态计算体系。

Q4：为什么不发展十进制计算机？ 因为区分十种电压状态在工程上几乎不可行，误差太高。

Q5：未来 AI 芯片可能使用三进制逻辑吗？ 是的，特别是在类脑计算和模拟信号处理领域。

Q6：二进制是否会被淘汰？ 短期内不可能，但在新计算范式（如量子或光子计算）下，可能出现并行存在的新体系。

八、结论：二进制的现实主义与未来的浪漫主义#

二进制不是完美的，但它是人类在现实限制下最优的工程选择。

它以最小的复杂度换来了最大程度的稳定性、可扩展性与经济性。

而三进制，虽然在理论上更加优雅，却在现实中被硬件物理的束缚所阻。

然而，科技的故事从不止步。

当未来的计算机不再依赖硅，而是用光、量子、甚至生物分子进行运算时，

也许我们会迎来超越二进制的新纪元。

二进制是人类理性的选择，而三进制，或许是未来计算的诗意理想。

手把手教你使用Markdown

Mon, 30 Mar 2026 00:00:00 GMT

Markdown是一种轻量级标记语言，由John Gruber于2004年创建，现已成为技术文档、博客文章和代码注释的首选写作工具。它结合了易读易写的纯文本格式和强大的排版功能，使创作者能够专注于内容本身而非格式细节，如本文就是用Markdown渲染的。写Markdown既简单又需要技巧，关键在于理解基本语法。本文将通过”代码+效果”的展示方式，全面讲解Markdown的核心语法，让你能够轻松编写出格式美观、内容丰富的Markdown文档。

基础语法#

标题#

Markdown使用井号(#)表示标题，数量从1到6分别对应不同级别的标题。标题与正文之间应保留一个空行，标题之间也应保留空行以增强可读性。

1
# 一级标题
2
## 二级标题
3
### 三级标题
4
#### 四级标题
5
##### 五级标题
6
###### 六级标题

效果：

一级标题#

二级标题#

三级标题#

四级标题#

五级标题#

六级标题#

注意：在标题中避免使用特殊字符如星号、下划线等，如需使用这些字符，应在前面添加反斜杠进行转义。例如：\*This is a title*

段落与换行#

Markdown段落由连续的文本行组成，段落之间用空行分隔。在行尾添加两个空格后按回车即可换行。

1
这是第一段。段落由连续的文本行组成，段落之间用空行分隔。
2

3
这是第二段。注意段落之间必须有一个空行。
4

5
这是同一段内的换行，行尾添加两个空格。
6
这是另一行，换行后显示在同一段落内。

效果：

这是第一段。段落由连续的文本行组成，段落之间用空行分隔。

这是第二段。注意段落之间必须有一个空行。

这是同一段内的换行，行尾添加两个空格。这是另一行，换行后显示在同一段落内。

文字强调#

Markdown提供了多种强调文本的方式，包括斜体、粗体、删除线和加粗斜体组合。

1
*斜体文本* 或 _斜体文本_
2
**粗体文本** 或 __粗体文本__
3
~~删除线文本~~
4
***加粗斜体文本*** 或 __*加粗斜体文本*__

效果：

斜体文本 或 斜体文本 粗体文本 或 粗体文本 删除线文本 加粗斜体文本 或 加粗斜体文本

注意：当文本内容本身包含这些符号时，应在前面添加反斜杠进行转义。例如：这是\*普通文本\*，不是斜体

列表#

Markdown支持无序列表和有序列表，可以轻松创建层次分明的内容结构。

无序列表#

使用连字符(-)、加号(+)或星号()表示无序列表，符号与内容之间应有一个空格。**推荐使用连字符(-)而非星号()，以避免与强调文本的星号混淆。

1
- 项目一
2
- 项目二
3
  - 子项目一（缩进两个空格）
4
  - 子项目二
5
* 另一种无序列表写法
6
+ 第三种无序列表写法

效果：

项目一
项目二
- 子项目一（缩进两个空格）
- 子项目二
另一种无序列表写法
第三种无序列表写法

有序列表#

使用数字加点号(1.)表示有序列表，所有列表项都应使用数字1.开头，Markdown渲染器会自动递增编号，这样便于列表项的重新排序。

1
1. 项目一
2
1. 项目二
3
   1. 子项目一（缩进三个空格）
4
   1. 子项目二
5
1. 项目三

效果：

项目一
项目二
1. 子项目一（缩进三个空格）
2. 子项目二
项目三

注意：

段落与列表之间保留一个空行
列表项后紧跟的段落应缩进两个空格
避免在列表项中混合使用多种符号（如同时使用-和*）

引用与分割线#

引用#

使用大于号(>)表示引用，可以创建多级嵌套引用。

1
> 这是一级引用
2
>> 这是二级引用
3
>>> 这是三级引用
4
> 这是一级引用
5
> > 可以混合使用多个>号

效果：

这是一级引用
这是二级引用
这是三级引用这是一级引用可以混合使用多个>号

分割线#

使用三个或更多的连字符(---)或星号(***)创建分割线，分割线所在行不能有其他内容，否则不会被识别为分割线。

1
这是分割线上方的内容
2
---
3
这是分割线下的内容
4
***
5
这是另一个分割线下的内容

效果：

这是分割线上方的内容

这是分割线下的内容

这是另一个分割线下的内容

五、代码块#

Markdown支持行内代码块和多行代码块两种形式，这对于技术文档尤为重要。

行内代码块#

使用单个反引号(`)包裹短代码片段，使其在文本中以等宽字体显示。

1
使用 `print("Hello World")` 函数可以输出文本。
2
Python的`if`语句用于条件判断。

效果：

使用 print("Hello World") 函数可以输出文本。 Python的if语句用于条件判断。

多行代码块#

使用三个反引号(```)包裹多行代码，可指定编程语言以启用语法高亮。

1
```python
2
def greet(name):
3
    print(f"Hello, {name}!")
4
greet("Alice")
5
```
6

7
```markdown
8
这是展示Markdown语法的代码块：
9
# 标题
10
*斜体*
11
**粗体**
12
```

效果：

1
def greet(name):
2
    print(f"Hello, {name}!")
3
greet("Alice")

1
这是展示Markdown语法的代码块：
2
# 标题
3
*斜体*
4
**粗体**

链接与图片#

超链接#

使用方括号包裹显示文本，圆括号包裹链接地址。这是Markdown最常用的元素之一。

1
[这是超链接文本](https://www.v7w.cn)
2
或者使用参考式链接：这是参考式链接[1]
3
[1]: https://www.v7w.cn

效果：

这是超链接文本

或者使用参考式链接：这是参考式链接1

图片#

图片语法与超链接类似，但在方括号前添加感叹号。

1
![图片替代文本](https://v7w.cn/images/typora-icon.png)
2
或者使用参考式图片：![参考式图片][logo]
3
[logo]: https://v7w.cn/images/typora-icon.png

效果：

图片替代文本

或者使用参考式图片：

参考式图片

注意：在Markdown教程中展示图片语法时，需要使用反斜杠转义感叹号和方括号：

1
\!\[图片替代文本\]\(https://v7w.cn/images/typora-icon.png\)

表格#

Markdown表格使用竖线(|)分隔列，连字符(-)分隔表头。表格语法在不同平台间兼容性差异较大，部分平台（如Microsoft Teams）不支持表格内的换行。

1
| 左对齐 | 居中对齐 | 右对齐 |
2
| :----- | :------: | -----: |
3
| 单元格 | 单元格 | 单元格 |
4
| 单元格 | 单元格 | 单元格 |

效果：

左对齐	居中对齐	右对齐
单元格	单元格	单元格
单元格	单元格	单元格

表格对齐说明：

|:-----| 表示左对齐（冒号在左侧）
|-----:| 表示右对齐（冒号在右侧）
|:-----:| 表示居中对齐（两侧都有冒号）

特殊符号转义#

在Markdown中，某些符号具有特殊含义，如需显示这些符号本身而非其格式功能，应在前面添加反斜杠进行转义。

1
\* 显示星号而非斜体
2
\_ 显示下划线而非斜体
3
\# 显示井号而非标题
4
\> 显示大于号而非引用
5
\| 显示竖线而非表格分隔符
6
\~\~ 显示波浪线而非删除线

效果：

* 显示星号而非斜体 _ 显示下划线而非斜体 # 显示井号而非标题 > 显示大于号而非引用 | 显示竖线而非表格分隔符 ~~ 显示波浪线而非删除线

数学公式#

Markdown支持通过LaTeX语法展示数学公式，这对于学术文档和技术文章非常有用。公式语法在不同平台间兼容性差异较大，部分平台可能需要额外配置才能渲染公式。

行内公式#

使用单个美元符号包裹公式：

1
行内公式示例：$E=mc^2$

效果：

行内公式示例：E=mc2E=mc^2E=mc2

独占公式#

使用双美元符号包裹公式：

1
独占公式示例：
2
$$
3
\sum_{i=1}^n a_i = 0
4
$$

效果：

∑i=1nai=0\sum_{i=1}^n a_i = 0i=1∑nai=0

HTML标签#

Markdown允许直接使用HTML标签，这对于需要特定排版效果的内容非常有用。使用HTML标签时应保持简洁，避免过度复杂。

1
使用HTML标签：
2
<b>粗体文本</b>
3
<em>斜体文本</em>
4
<ins>下划线文本</ins>
5
<del>删除线文本</del>
6
<code>行内代码</code>

效果：

使用HTML标签： 粗体文本 斜体文本 下划线文本删除线文本 行内代码

结尾#

通过实践这些语法，你将能够轻松编写出格式美观、内容丰富的Markdown文档，无论是技术博客、项目文档还是个人笔记，都能得心应手。

Docker：轻量级容器化技术的实战指南

Sun, 29 Mar 2026 00:00:00 GMT

前言#

最近这段平常的学习空闲时间，闲来无事，回顾我这些年的开发历程，从最初的手动部署环境，到使用虚拟机，再到现在的容器化技术，真是感慨万千。记得刚开始工作的时候，每次为新项目配置开发环境都是一场噩梦——不同项目需要不同版本的依赖，经常出现”在我机器上能跑”的经典问题。

后来接触了虚拟机，虽然解决了环境隔离的问题，但虚拟机太重了，启动慢，占用资源多，迁移也不方便。直到我发现了 Docker 这个神器，才真正体会到什么是”一次构建，到处运行”的便利。

作为一个 Coder，怎么能不掌握 Docker 呢？这相当于是你在云时代的生存技能，是团队协作的基石，更是现代应用部署的标准配置。

所以在我的开发流程中，Docker 已经成为了不可或缺的一部分。它不仅让我摆脱了环境配置的困扰，还让我的应用部署变得异常简单和可靠。

让我们开始吧#

首先我们需要用到下列东西#

能够独立思考的大脑 x 1：用于理解 Docker 的核心概念和解决可能遇到的问题
Docker Desktop x 1：Windows/Mac 用户可以直接下载这个集成环境，Linux 用户需要单独安装 Docker 引擎
Docker Hub 账号 x 1：用于拉取和推送镜像，类似于 GitHub 之于代码
Git 版本控制工具 x 1：用于管理你的 Dockerfile 和 docker-compose.yml 文件
一个好奇的心 x 1：Docker 的世界很有趣，值得你深入探索

Docker 是什么？为什么需要它？#

Docker 是一个开源的容器化平台，它让你能够将应用及其所有依赖打包到一个轻量级、可移植的容器中。与传统的虚拟机不同，Docker 容器共享主机操作系统内核，因此更加轻量级和高效。

Docker 的核心优势：

轻量级：容器启动秒级完成，资源占用少
可移植性：一次构建，到处运行
隔离性：每个容器都是独立的运行环境
效率：比虚拟机更高效，性能损失小

快速上手 Docker#

1. 安装 Docker#

Mac/Windows 用户：

直接下载 Docker Desktop 并安装，按照向导完成设置即可。

Linux 用户（Ubuntu 为例）：

Terminal window显示更多显示更少

1
# 卸载旧版本
2
sudo apt-get remove docker docker-engine docker.io containerd runc
3

4
# 安装必要依赖
5
sudo apt-get update
6
sudo apt-get install \
7
    ca-certificates \
8
    curl \
9
    gnupg \
10
    lsb-release
11

12
# 添加 Docker 官方 GPG 密钥
13
sudo mkdir -p /etc/apt/keyrings
14
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
15

16
# 设置仓库
17
echo \
18
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
19
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
20

21
# 安装 Docker 引擎
22
sudo apt-get update
23
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
24

25
# 验证安装
26
sudo docker run hello-world

显示更多显示更少

2. Docker 核心概念#

镜像(Image)：只读的模板，包含运行应用所需的代码、运行时、库和环境变量
容器(Container)：镜像的可运行实例
Dockerfile：定义如何构建镜像的文本文件
Docker Hub：官方的镜像仓库，类似于 GitHub 之于代码

3. 第一个 Docker 实践：运行一个 Nginx Web 服务器#

Terminal window

1
# 拉取官方 Nginx 镜像
2
docker pull nginx
3

4
# 运行 Nginx 容器
5
docker run -d -p 8080:80 --name my-nginx nginx
6

7
# 访问 http://localhost:8080 查看运行结果

就这么简单！你已经成功运行了一个 Web 服务器。

4. 创建自己的 Docker 镜像#

让我们创建一个简单的 Node.js 应用的 Docker 镜像：

1. 项目结构：

1
my-node-app/
2
├── app.js
3
├── package.json
4
└── Dockerfile

2. Dockerfile 示例：

1
# 使用官方 Node.js 镜像作为基础镜像
2
FROM node:18-alpine
3

4
# 设置工作目录
5
WORKDIR /usr/src/app
6

7
# 复制 package.json 和 package-lock.json
8
COPY package*.json ./
9

10
# 安装依赖
11
RUN npm install
12

13
# 复制应用源代码
14
COPY . .
15

16
# 暴露端口
17
EXPOSE 3000
18

19
# 定义容器启动时执行的命令
20
CMD ["node", "app.js"]

显示更多显示更少

3. 构建和运行：

Terminal window

1
# 在项目目录下构建镜像
2
docker build -t my-node-app .
3

4
# 运行容器
5
docker run -d -p 3000:3000 --name my-running-app my-node-app
6

7
# 访问 http://localhost:3000

Docker Compose：多容器应用管理#

对于复杂的应用，通常需要多个服务协同工作（如 Web 应用 + 数据库）。这时候就需要 Docker Compose 了。

docker-compose.yml 示例：

1
version: '3.8'
2

3
services:
4
  web:
5
    build: .
6
    ports:
7
      - "3000:3000"
8
    depends_on:
9
      - redis
10
    environment:
11
      - NODE_ENV=production
12

13
  redis:
14
    image: redis:alpine
15
    ports:
16
      - "6379:6379"

显示更多显示更少

使用方法：

Terminal window

1
# 启动所有服务
2
docker-compose up -d
3

4
# 查看运行中的服务
5
docker-compose ps
6

7
# 停止并删除服务
8
docker-compose down

实战技巧和最佳实践#

1. Dockerfile 优化技巧#

使用官方镜像：尽量使用官方维护的镜像
选择合适的基础镜像：如使用 alpine 版本减小镜像大小
多阶段构建：减小最终镜像大小
合理使用缓存：正确排序 Dockerfile 指令以利用构建缓存

多阶段构建示例：

1
# 构建阶段
2
FROM node:18 AS builder
3
WORKDIR /app
4
COPY . .
5
RUN npm install && npm run build
6

7
# 生产阶段
8
FROM node:18-alpine
9
WORKDIR /app
10
COPY --from=builder /app/package*.json ./
11
COPY --from=builder /app/dist ./dist
12
RUN npm install --production
13
EXPOSE 3000
14
CMD ["node", "dist/app.js"]

2. 常用命令速查#

Terminal window显示更多显示更少

1
# 镜像相关
2
docker images                  # 列出所有镜像
3
docker pull <image>            # 拉取镜像
4
docker rmi <image>             # 删除镜像
5

6
# 容器相关
7
docker ps                      # 列出运行中的容器
8
docker ps -a                   # 列出所有容器
9
docker run [options] <image>   # 运行容器
10
docker start/stop/restart <container>  # 控制容器
11
docker exec -it <container> /bin/bash  # 进入容器
12
docker logs <container>        # 查看容器日志
13
docker rm <container>          # 删除容器
14

15
# 镜像构建
16
docker build -t <tag> .        # 构建镜像
17

18
# 清理
19
docker system prune            # 清理无用资源

显示更多显示更少

3. 数据持久化#

容器是临时的，要持久化数据需要使用卷(volumes)或绑定挂载(bind mounts)：

Terminal window

1
# 创建卷
2
docker volume create my-volume
3

4
# 运行容器并挂载卷
5
docker run -d -v my-volume:/app/data my-image
6

7
# 或者使用绑定挂载（宿主机目录映射到容器）
8
docker run -d -v /host/path:/container/path my-image

结语#

Docker 真的改变了我的开发方式。它不仅解决了环境一致性的问题，还让部署变得如此简单。还记得我第一次在生产环境使用 Docker 部署应用时，那种”无论在哪里都能完美运行”的安心感，是传统部署方式无法给予的。

作为一个 Coder，掌握 Docker 不仅仅是为了部署应用，更是为了理解现代软件架构和 DevOps 实践的基础。它让我们能够更专注于业务逻辑的开发，而不是环境配置的琐事。

现在，每当我开始一个新项目，第一件事就是写 Dockerfile 和 docker-compose.yml。这已经成为了我的标准工作流程，也是我推荐给所有开发者的最佳实践。

Docker 的魅力在于：一次构建，到处运行；简单配置，复杂管理；小而强大，轻而可靠。

开始使用 Docker 吧，你会发现它将成为你开发工具箱中不可或缺的利器！

别再用 CMD 了！换成 Windows Terminal + PowerShell 7!

Sat, 28 Mar 2026 00:00:00 GMT

前言#

2026 年了，不会还有程序员还在用着丑丑的黑色的 CMD 吧，本文就来简单讲下如何打造属于你的 Windows 终端。

概念#

首先要搞清楚 Shell 和 Terminal 的区别。

终端(Terminal):

它是一个程序,提供了一个窗口
你可以在这个窗口里输入命令和看到结果
就像是一个与计算机对话的界面

Shell:

它是一个程序,负责解释和执行你输入的命令
它在终端里运行,处理你输入的指令
常见的Shell有Bash、Zsh等

如果还是不能理解，那我们来举个例子，终端(Terminal)就像餐厅的餐桌和座位，这是你坐下来点餐和享用食物的地方，它提供了一个与厨房（计算机系统）交流的场所。Shell 就像餐厅的服务员，它接收你的点单（命令），将你的要求传达给厨房（操作系统内核），然后把准备好的食物（命令结果）送回到你的桌前。

就像不同的餐厅可能有不同风格的桌椅（不同的终端程序），也可能有不同的服务员（不同类型的Shell，如Bash、Zsh等）。但它们的基本功能是相似的 —— 为你提供一种与计算机系统交互的方式。

终端发展历史#

MS-DOS Command Prompt (cmd.exe)

在 Windows 之前，微软的操作系统是 MS-DOS，一个基于文本的操作系统。MS-DOS 自带了命令提示符工具，这就是早期 Windows 中 cmd.exe 的前身。
在 Windows 95 及后续版本中，cmd.exe 作为 Windows 系统的命令行界面，用于执行 DOS 命令和批处理脚本。cmd.exe 虽然功能有限，但在几十年内一直是 Windows 用户主要的命令行工具。

cmd

PowerShell

为了弥补 cmd.exe 的不足，微软于 2006 年推出了 PowerShell，这是一种面向对象的脚本语言和命令行界面。PowerShell 提供了更强大的脚本编写功能，支持与 .NET 框架的集成，极大地增强了 Windows 系统的自动化管理能力。

powershell

PowerShell 7

PowerShell 最初是作为 Windows 专用的命令行工具和脚本语言，于 2006 年首次发布，后来演变为 PowerShell Core，这是一个基于 .NET Core 的跨平台版本。随着 .NET Core 的不断发展和成熟，微软决定推出 PowerShell 7，以取代 PowerShell Core，并统一 PowerShell 的版本路线。

更换你的终端#

古老的 CMD 已经诞生了二十多年了，是时候换掉它了！

Windows Terminal 是微软开发的一款现代化命令行工具，它旨在为 Windows 用户提供一个更为强大和灵活的命令行体验，它的特点有：

多标签页支持: 用户可以在同一个窗口中打开多个命令行会话，每个会话可以运行不同的 Shell，比如 PowerShell、cmd.exe、WSL、Azure Cloud Shell 等。
自定义界面: Windows Terminal 支持高度的界面自定义，包括背景图片、主题颜色、字体、透明度等，可以通过 JSON 文件进行配置。
GPU 加速的文本渲染: Windows Terminal 使用 DirectWrite 和 DirectX 为文本渲染提供 GPU 加速，带来流畅的文本显示效果。
Unicode 和 UTF-8 字符支持: Windows Terminal 具有对现代编码标准的全面支持，包括 Emoji 和其他特殊字符。
丰富的扩展性: 开发者可以通过插件扩展 Terminal 的功能，并且可以使用脚本自动化一些常见任务。

打开你的 Microsoft Store，搜索 Windows Terminal 就可以找到它。

microsoft-store

安装好之后，你就能在开始菜单中找到它，打开它之后，什么都没配置的 Windows Terminal 应该长这样。

winterm-origin

更换你的 Shell#

现在的终端是不是长的更好看了？但是！以开头的餐厅为例子，我们现在只是更换了餐厅的餐桌和椅子，让我们坐的更舒服了，但是端上来的菜还没变啊！服务员也还是之前的，我们需要一个能力更强、兼容性更广的。

Windows 10 开始，微软便在系统内置了 PowerShell，然而它只能运行在 Windows 上，随着 PowerShell 7 的推出，微软彻底重写了这个 Shell，它基于 .NET Core (从 PowerShell 7.1 开始基于 .NET 5)，意味着支持 Windows、macOS 和各种 Linux 发行版，用户可以在不同的操作系统上使用相同的脚本和命令。以及引入了许多现代开发者和运维人员需要的新特性，例如：

三元操作符 (?:)
管道链运算符 (|| 和 &&)
空合并运算符 (??)
并行处理 (ForEach-Object -Parallel)

微软官方的推荐安装方式是使用 winget，然而 winget 在国内的网络问题，即使切换到了国内的镜像源，也没法顺利下载，因为 winget 下的大部分软件包还是要去 GitHub 下载，所以我们使用安装包的方式。

打开 PowerShell 7 的 GitHub Release，下载 PowerShell-7.x.x-win-x64.msi （截止文章发布日期最新版本为 7.4.4）即可。

如果你不能顺利打开 GitHub，那么可以使用 GitHub 镜像站链接下载，只要在下载链接前加上 https://ghcr.taurusxin.com/ 即可，例如 7.4.4 版本，那么链接就是 https://ghcr.taurusxin.com/https://github.com/PowerShell/PowerShell/releases/download/v7.4.4/PowerShell-7.4.4-win-x64.msi。

下载打开后一路 Next 即可安装完成。

打开 Windows Terminal，你就会发现多了一项 PowerShell 的选项，这就是 PowerShell 7，而第一个也就是默认的是旧版本的。

ps7

点击就可以在新的标签页创建 PowerShell 7 会话了。

winterm-ps7

其实到这一步，我们已经完成了绝大多数的操作，下面的步骤就让我们来做一些美化。

简单美化#

在 Unix / Linux 下我习惯使用 zsh + oh-my-zsh 来作为我的 Shell 环境，那么 PowerShell 有没有类似的工具呢？答案是 oh-my-posh。

安装 oh-my-posh#

msstore-ohmyposh

安装一个 Nerd Font#

oh-my-posh 下有一些带有图标或者特殊符号的主题，这时如果使用默认的 Consola 字体就会显示乱码，所以在配置 oh-my-posh 前，我们需要一个 Nerd Font，它为现有的字体打了一个补丁，支持了那些特殊符号，我们可以前往 https://www.nerdfonts.com/font-downloads 选择一个你喜欢的终端字体，然后下载安装就可以了，我喜欢使用和写代码一样的 JetBrains Mono 字体，于是就选择了 JetBrainsMono Nerd Font。

jetbrainsmono-nerdfont

别忘了在 Window Terminal 中切换到你下载的新字体，点击下拉箭头，选择设置，在左边选择 PowerShell 配置文件，点开右侧的 其他设置-外观，将字体切换到新安装的字体即可。

switch-font

配置文件#

键入如下命令来创建空白的 PowerShell 7 配置文件，它类似于 zsh 的 .zshrc 文件，会在 PowerShell 7 时自动加载并执行这个配置文件。

Terminal window

1
New-Item -Path $PROFILE -Type File -Force

使用 VSCode 打开它，你也可以使用记事本。

Terminal window

1
code $PROFILE

输入下面的内容，保存配置文件，就可以激活 oh-my-posh 了。

Terminal window

1
oh-my-posh init pwsh | Invoke-Expression

重启 Windows Terminal 或者打开一个新的 PowerShell 7 标签后，此时它应该长这样。

ohmyposh-activated

你也可以用下面的命令使得配置文件立即生效。

Terminal window

1
. $PROFILE

现在是不是比一个黑黑的窗口好看多了，当然 oh-my-posh 也内置了很多其它主题，你可以浏览这个链接或者输入下面的命令来找一个你喜欢的主题，会输出每个主题对应的名称。

Terminal window

1
Get-PoshThemes

然后我们来切换到它。依旧是编辑配置文件，我们将激活 oh-my-posh 的那一行命令修改一下，这里以我最喜欢的 ys 主题举例：

Terminal window

1
& ([ScriptBlock]::Create((oh-my-posh init pwsh --config "$env:POSH_THEMES_PATH\ys.omp.json" --print) -join "`n"))

打开一个新的标签页，或者使用 . $PROFILE 命令使配置文件生效。

omp-ys-theme

至此，你已经拥有了一个非常好看的终端了，你可以在 Windows Terminal 中的外观选项自己摸索一下，例如打开半透明的亚克力外观等，最终我的美化结果如下。

final

增强配置#

在 Unix / Linux 下，我们可以方便的使用 Control-D 来关闭当前会话，然而 CMD 和 PowerShell 并不支持 Control-D，只有 Control-C 用于终止当前命令运行，我们来对配置文件做一些增强，下面是我自己整理的最终配置文件，算是送给能看到这儿的读者的一份礼物。有部分为插件，大家可以自行搜索安装，不一定要和我一样。

Terminal window显示更多显示更少

1
# oh-my-posh
2
& ([ScriptBlock]::Create((oh-my-posh init pwsh --config "$env:POSH_THEMES_PATH\ys.omp.json" --print) -join "`n"))
3

4
# ps-read-line
5
Import-Module PSReadLine
6

7
# posh-git
8
Import-Module posh-git
9

10
# 设置预测文本来源为历史记录
11
Set-PSReadLineOption -PredictionSource History
12

13
# 每次回溯输入历史，光标定位于输入内容末尾
14
Set-PSReadLineOption -HistorySearchCursorMovesToEnd
15

16
# 设置 Tab 为菜单补全和 Intellisense
17
Set-PSReadLineKeyHandler -Key "Tab" -Function MenuComplete
18

19
# 设置 Ctrl+d 为退出 PowerShell
20
Set-PSReadlineKeyHandler -Key "Ctrl+d" -Function ViExit
21

22
# 设置 Ctrl+z 为撤销
23
Set-PSReadLineKeyHandler -Key "Ctrl+z" -Function Undo
24

25
# 使用 ll 查看目录
26
function ll {
27
    Get-ChildItem
28
}
29

30
# 设置向上键为后向搜索历史记录
31
Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward
32

33
# 设置向下键为前向搜索历史纪录
34
Set-PSReadLineKeyHandler -Key DownArrow -Function HistorySearchForward
35

36
# rm -rf alias
37
function rmrf ($dir_path){
38
  Remove-Item -Recurse -Force $dir_path
39
}
40

41
# mv alias
42
function mv($file_path, $des_name) {
43
  Move-Item -Path $file_path -Destination $des_name
44
}
45

46
# touch alias
47
function touch {
48
    param (
49
        [string]$path
50
    )
51
    if (!(Test-Path $path)) {
52
        New-Item -ItemType File -Path $path
53
    } else {
54
        (Get-Item $path).LastWriteTime = Get-Date
55
    }
56
}

显示更多显示更少

注意！posh-git 插件需要先进行安装。

Terminal window

1
# 先设置允许允许远程代码执行策略
2
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser -Confirm
3

4
# 安装 posh-git 模块
5
PowerShellGet\Install-Module pos ولی something seems missing in your script—maybe the actual installation command?

结语#

这份教程算是对 Windows 下终端美化的最基本的教程，不需要太多的操作就可以拥有一个高效的终端工具，希望各位读者喜欢！

在 Astro 博客中为 Markdown 添加多图并排的自适应网格画廊功能

Fri, 27 Mar 2026 00:00:00 GMT

背景#

在编写技术博客或是日常分享记录时，我们经常会遇到需要将几张照片（如对比图、风景照片）并排展示的需求。

默认的 Markdown 语法下，直接把好几张图写在一起只会根据屏幕宽度往下折行排布，并不能得到整齐划一的画廊（Gallery）排版效果。如果要使用原生的 HTML 写栅格代码，又会严重破坏 Markdown 中原始书写的流畅感与整洁度。

为了解决这个问题，我决定借助 Unified 体系中的 Remark 插件，在 Astro 环境里无缝开发一个自定义标签 [grid]。只要将图片放进这个标签里，系统就会自动将它们变为自适应的响应式网格布局并自动补齐对齐高度！

这个功能使用 Claude Code 协助完成。

插件最终效果与语法#

设想中的语法十分简单，只要用 [grid] 和 [/grid] 包裹住常规的 Markdown 图片语法即可。

例如两张照片的代码如下：

1
[grid]
2

3
![示例1](image_url_1)
4

5
![示例2](image_url_2)
6

7
![示例3](image_url_1)
8

9
[/grid]

最终效果

image-grid

由于我们在底层介入了 AST（抽象语法树），渲染出的结果将不再是松散的图片，而是带有 Tailwind 栅格属性（grid, grid-cols-2 等）的容器，并且它可以依据内部包了两图还是三图做到自动计算列数进行展现。

原理分析：AST 语法树与 Remark#

在我们的博客打包全流程（Markdown -> HTML）中，主要经历下面两个核心生态的转换：

Remark (mdast): 解析 Markdown，生成抽象语法树 (AST)。
Rehype (hast): 接手 AST 将其转换为 HTML 并添加结构和类名。

我们要实现在 Remark 阶段截获特定的明文标记 [grid] 并进行打包。核心在于利用 unist-util-visit 库遍历这段抽象树中的所有 paragraph（段落），如果我们在段落头部发现了 [grid]，我们就可以通过将其转换成特定的 HTML div 节点来渲染出网格。

第一步：编写核心插件 `remark-image-grid.js`#

我们在 src/plugins/remark-image-grid.js 下编写自己的模块处理器：

1
import { visit } from "unist-util-visit";
2

3
/**
4
 * Custom Remark plugin for creating responsive image grids.
5
 *
6
 * It parses markdown blocks surrounded by `[grid]` and `[/grid]` tags and wraps
7
 * the contained images in a styled `div` container with a grid layout.
8
 * The column count is evaluated automatically based on the number of inserted images
9
 * inside the grid tags (up to 4 columns).
10
 */
11
export function remarkImageGrid() {
12
  return (tree) => {
13
    // 聚焦根节点，以便收集我们要进行重组的元素
14
    if (tree.type === 'root') {
15
      const newChildren = [];
16
      let inGrid = false;
17
      let gridChildren = [];
18

19
      for (let i = 0; i < tree.children.length; i++) {
20
        let node = tree.children[i];
21

22
        // 识别包含图片的段落中的 [grid] 或者 [/grid] 标记
23
        if (node.type === 'paragraph' && node.children.length > 0) {
24
          const first = node.children[0];
25
          const last = node.children[node.children.length - 1];
26

27
          let containsGridStart = false;
28
          let containsGridEnd = false;
29

30
          if (first.type === 'text' && first.value.trim().startsWith('[grid]')) {
31
            containsGridStart = true;
32
          }
33
          if (last.type === 'text' && last.value.trim().endsWith('[/grid]')) {
34
             containsGridEnd = true;
35
          }
36

37
          // Case: 当 [grid] 标签跨越不同段落（中间有空行换行）时
38
          if (!inGrid && containsGridStart) {
39
            inGrid = true;
40
            // 清理语法标签文本本身
41
            first.value = first.value.replace(/^\s*\[grid\]\s*/, '');
42
            if (node.children.length === 1 && first.value.trim() === '') {
43
               // 处理它自成一行的极端情况
44
            } else {
45
               gridChildren.push(node);
46
            }
47
            continue;
48
          }
49

50
          if (inGrid && containsGridEnd) {
51
             inGrid = false;
52
             last.value = last.value.replace(/\s*\[\/grid\]\s*$/, '');
53
             if (node.children.length === 1 && last.value.trim() === '') {
54
             } else {
55
                 gridChildren.push(node);
56
             }
57

58
             // ✨ 重点：动态计数，根据包含的图片自动计算列数，最高支持一行四列
59
             let imgCount = 0;
60
             gridChildren.forEach(child => {
61
                 visit(child, 'image', () => { imgCount++; });
62
             });
63
             const cols = imgCount || 2;
64
             const mdColClass = cols === 1 ? 'md:grid-cols-1' :
65
                                cols === 2 ? 'md:grid-cols-2' :
66
                                cols === 3 ? 'md:grid-cols-3' : 'md:grid-cols-4';
67

68
             // 将节点重新推入为一个自带 class 定义的 HTML 结构节点！
69
             newChildren.push({
70
               type: 'paragraph',
71
               data: {
72
                 hName: 'div',
73
                 hProperties: { className: ['image-grid', 'grid', 'grid-cols-1', mdColClass, 'gap-4', 'my-4'] }
74
               },
75
               children: gridChildren
76
             });
77
             gridChildren = []; // 初始化留待下次使用
78
             continue;
79
          }
80
        }
81

82
        // 把普通的非图节点正常塞回 AST 中
83
        if (inGrid) {
84
           gridChildren.push(node);
85
        } else {
86
           newChildren.push(node);
87
        }
88
      }
89

90
      // 防止用户忘记写闭合标签，帮他们补全推入
91
      if (inGrid) {
92
        newChildren.push(...gridChildren);
93
      }
94

95
      tree.children = newChildren;
96
    }
97
  };
98
}

显示更多显示更少

以上的逻辑非常巧妙地做到了几点：

处理了用户是否在标签里换行的问题（AST 会将其切割为不同的 paragraph 段落，所以需要用类似流的状态机 inGrid 变量开启拦截器）；
动态栅格分配：利用 Tailwind 中 grid 属性灵活分配每一行的占比；

第二步：在 Astro 中引入该插件#

只需前往项目的 astro.config.mjs 中登记上这一插件，它就会自动在我们构建（build）时注入生效了！

1
import { remarkImageGrid } from "./src/plugins/remark-image-grid.js";
2

3
// ...略去无关代码...
4

5
export default defineConfig({
6
  markdown: {
7
    remarkPlugins: [
8
      remarkImageGrid, // 我们自定义开发的网格插件
9
      // ...其他remark插件,
10
    ],
11
  }
12
})

第三步：CSS 兜底高度对齐防翻车#

如果你测试一下可能会发现一个致命问题：虽然左右并排了！但是左侧的图片是个正方形，右边是一张扁平的长图，这就导致底下生成的图注（figcaption）一高一低参差不齐！

因此我们需要结合写好的 image-grid 父类在公共 CSS 样式中添加一套自适应填充满容器宽高的裁剪逻辑：

1
.image-grid {
2
  @apply items-stretch;
3

4
  > figure {
5
    @apply flex flex-col h-full w-full m-0 p-0;
6

7
    img {
8
      /* object-cover魔法让它中心裁剪完美等高，杜绝形变扭曲 */
9
      @apply object-cover w-full flex-grow rounded-xl m-0;
10
      height: 100%;
11
    }
12

13
    figcaption {
14
      @apply mt-2 mb-0; /* 将图注控制在同一底部水平线上 */
15
    }
16
  }
17
}

显示更多显示更少

这里利用 Tailwind (或者纯 CSS 也可) 使用给图片层添加 height: 100% 设置并用 object-cover 进行了中心修剪，这不仅使得画面毫无拉扯而且强制它们保证在了一排同样完美的基线当中！

结语#

通过仅仅一段几十行的轻量 AST Remark 劫持逻辑以及搭配了几行 CSS。我们就十分优雅地给自己的博客注入了超酷的相册画廊（Image Grid）能力。这种完全基于 AST 标准流的方式比通过客户端注入 JS 会产生更少的性能消耗（因为它完全在服务端预渲染 HTML 阶段组装结束了）。

Debian系统重置忘记的 root 密码

Fri, 27 Mar 2026 00:00:00 GMT

1. 打开 Debian Grub 启动菜单

重新启动系统，同时按住键盘上的Shift键，这将使您进入 Debian 的 Grub 菜单。远程服务器则需要用控制台或者VNC连接。

2. 编辑 Gurb 菜单以进入命令行模式

选中 Grub 菜单上的启动菜单后，请直接按键盘上的” e”键，这将允许您编辑 Grub 的引导提示符。请不要触摸或删除此处的任何内容。

在 Grub 编辑屏幕上，使用箭头键移动到以” Linux “开头的这一行文字的末尾。在此行类型的末尾加上：

Terminal window

1
rw init=/bin/bash

添加给定的语法后，接下来，使用此配置启动您的系统。为此，请使用 Ctrl+X 或 F10 进入命令行模式。

3. 重置root用户密码

现在，让我们像在 Linux 系统上一样使用命令终端更改密码。

输入命令：

Terminal window

1
passwd

系统会两次提示您输入新密码，输入完成后回车。

4. 重启系统

完成重置 Linux 密码后，重新启动系统以使用更改后的密码登录。要重新启动，请键入：

Terminal window

1
exec /sbin/init

然后按下Enter键重启。

Docker常用命令

Fri, 27 Mar 2026 00:00:00 GMT

安装 Docker#

Terminal window

1
yum update #更新 yum 版本
2

3
yum install -y yum-utils device-mapper-persistent-data lvm2 # 安装 docker 依赖包
4

5
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #设置 yum 源为阿里云的镜像源
6

7
yum install docker-ce #安装 docker
8

9
docker -v #查看 docker 版本

设置 Docker 镜像源#

编辑 /etc/docker/daemon.json 文件加入下面内容：

1
{
2
  "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
3
}

然后重启 Docker 服务使配置生效。

Docker 服务命令#

Terminal window

1
systemctl start docker    # 启动 Docker
2
systemctl stop docker     # 停止 Docker
3
systemctl restart docker  # 重启 Docker
4
systemctl status docker   # 查看 Docker 状态
5
systemctl enable docker   # 设置开机自启
6
docker info              # 查看 Docker 详细信息
7
docker --help           # 查看帮助信息

镜像相关命令#

Terminal window

1
docker images                    # 查看本地镜像
2
docker search 镜像名称           # 搜索镜像
3
docker pull 镜像名称             # 拉取镜像
4
docker rmi 镜像ID               # 删除指定镜像
5
docker rmi `docker images -q`   # 删除所有镜像

镜像信息说明：

REPOSITORY：镜像名称

TAG：镜像标签

IMAGE ID：镜像 ID

CREATED：镜像的创建日期（不是获取该镜像的日期）

SIZE：镜像大小

这些镜像都是存储在 Docker 宿主机的 /var/lib/docker 目录下
搜索镜像说明：

NAME：仓库名称

DESCRIPTION：镜像描述

STARS：用户评价，反应一个镜像的受欢迎程度

OFFICIAL：是否官方

AUTOMATED：自动构建，表示该镜像由 Docker Hub 自动构建流程创建的

容器相关命令#

1. 查看容器#

Terminal window

1
docker ps                 # 查看正在运行的容器
2
docker ps -a              # 查看所有容器（包括已停止）
3
docker ps -l              # 查看最后一次运行的容器
4
docker ps -f status=exited # 查看已停止的容器

2. 创建与启动容器#

创建容器常用参数说明#

参数	说明
`-i`	表示运行容器
`-t`	容器启动后会进入其命令行，分配一个伪终端
`--name`	为创建的容器命名
`-v`	目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录）
`-d`	守护式容器，在后台运行
`-p`	端口映射（宿主机端口:容器端口）

交互式方式创建容器#

Terminal window

1
docker run -it --name=容器名称 镜像名称:标签 /bin/bash

/bin/bash 为加载命令，这时我们通过 ps 命令查看，可以看到启动的容器，状态为启动状态

退出当前容器：

Terminal window

1
exit

守护式方式创建容器（常用）#

Terminal window

1
docker run -di --name=容器名称 镜像名称:标签

登录守护式容器方式：

Terminal window

1
docker exec -it 容器名称(或者容器ID) /bin/bash

3. 停止与启动容器#

Terminal window

1
docker stop 容器名称（或者容器ID）  # 停止容器
2
docker start 容器名称（或者容器ID）  # 启动容器
3
docker restart 容器名称（或者容器ID） # 重启容器

4. 文件拷贝#

Terminal window

1
# 将文件拷贝到容器内
2
docker cp 需要拷贝的文件或目录 容器名称:容器目录
3

4
# 将文件从容器内拷贝出来
5
docker cp 容器名称:容器目录 需要拷贝的文件或目录

5. 目录挂载#

我们可以在创建容器的时候，将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而影响容器。

Terminal window

1
docker run -di -v /usr/local/myhtml:/usr/local/myhtml --name=mycentos3 centos:7

如果你共享的是多级的目录，可能会出现权限不足的提示。这是因为 CentOS7 中的安全模块 selinux 把权限禁掉了，我们需要添加参数 --privileged=true 来解决挂载的目录没有权限的问题

Terminal window

1
docker run -di --privileged=true -v /usr/local/myhtml:/usr/local/myhtml --name=mycentos3 centos:7

6. 查看容器 IP 地址#

Terminal window

1
# 查看容器运行的各种数据
2
docker inspect 容器名称（容器ID）
3

4
# 直接输出 IP 地址
5
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

7. 删除容器#

Terminal window

1
docker rm 容器名称（容器ID）  # 删除已停止的容器
2
docker rm -f 容器名称（容器ID） # 强制删除运行中的容器

应用部署#

这里以 MySQL 为例说明如何通过 Docker 部署应用。

1. 拉取 MySQL 镜像#

Terminal window

1
docker pull centos/mysql-57-centos7

2. 创建容器#

Terminal window

1
docker run -di --name=tensquare_mysql -p 33306:3306 -e MYSQL_ROOT_PASSWORD=123456 centos/mysql-57-centos7

-p 代表端口映射，格式为 宿主机映射端口:容器运行端口 -e 代表添加环境变量，MYSQL_ROOT_PASSWORD 是 root 用户的登录密码

3. 远程登录 MySQL#

连接宿主机的 IP，指定端口为 33306。

迁移与备份#

容器保存为镜像#

我们可以通过以下命令将容器保存为镜像：

Terminal window

1
docker commit mynginx mynginx_i

镜像备份#

我们可以通过以下命令将镜像保存为 tar 文件：

Terminal window

1
docker save -o mynginx.tar mynginx_i

镜像恢复与迁移#

首先删除掉 mynginx_i 镜像，然后执行此命令进行恢复：

Terminal window

1
docker load -i mynginx.tar

-i 表示输入的文件

执行后再次查看镜像，可以看到镜像已经恢复。

Dockerfile#

Dockerfile 是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。

命令	作用
`FROM image_name`	定义了使用哪个基础镜像启动构建流程
`MAINTAINER user_name`	声明镜像的创建者
`ENV key value`	设置环境变量（可以写多条）
`RUN command`	是 Dockerfile 的核心部分（可以写多条）
`ADD source_dir/file dest_dir/file`	将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
`COPY source_dir/file dest_dir/file`	和 ADD 相似，但是如果有压缩文件并不能解压
`WORKDIR path_dir`	设置工作目录

使用脚本创建镜像#

步骤：

Terminal window

1
mkdir -p /usr/local/dockerjdk8

下载 jdk-8u171-linux-x64.tar.gz 并上传到服务器中的 /usr/local/dockerjdk8 目录
创建文件 Dockerfile

1
# 依赖镜像名称和 ID
2
FROM centos:7
3
# 指定镜像创建者信息
4
MAINTAINER ITCAST
5
# 切换工作目录
6
WORKDIR /usr
7
RUN mkdir /usr/local/java
8
# ADD 是相对路径 jar,把 Java 添加到容器中
9
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/
10
# 配置 Java 环境变量
11
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
12
ENV JRE_HOME $JAVA_HOME/jre
13
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
14
ENV PATH $JAVA_HOME/bin:$PATH

执行命令构建镜像

Terminal window

1
docker build -t='jdk1.8' .

注意：后边的空格和点，不要省略

查看镜像是否建立完成

Terminal window

1
docker images

IntelliJ IDEA 常用快捷键列表（2026珍藏版）

Fri, 27 Mar 2026 00:00:00 GMT

IntelliJ IDEA 是 Java 开发最流行的 IDE，掌握这些快捷键可以让你的开发效率翻倍！

🚀1.高频快捷键列表#

快捷键	含义
Ctrl+Shift + Enter	语句完成
！	否定完成，输入表达式时 ”！“键
Ctrl+E	最近文件
Ctrl+Shift+E	最近更改的文件
Shift+Click	关闭文件
Ctrl+[ OR ]	可以跑到大括号的开头与结尾
Ctrl+F12	显示当前文件的结构
Ctrl+F7	查询当前元素在当前文件中的引用，按 F3 可以选择
Ctrl+N	快速打开类
Ctrl+Shift+N	快速打开文件
Alt+Q	可以看到当前方法的声明
Ctrl+P	可以显示参数信息
Ctrl+Shift+Insert	可以选择剪贴板内容并插入
Alt+Insert	可以生成构造器/Getter/Setter等
Ctrl+Alt+V	可以引入变量。例如：new String(); 自动导入变量定义
Ctrl+Alt+T	可以把代码包在一个块内例如：try/catch
Ctrl+Enter	导入包，自动修正
Ctrl+Alt+L	格式化代码
Ctrl+Alt+I	将选中的代码进行自动缩进编排，这个功能在编辑 JSP 文件时也可以工作
Ctrl+Alt+O	优化导入的类和包
Ctrl+R	替换文本
Ctrl+F	查找文本
Ctrl+Shift+Space	自动补全代码
Ctrl+空格	代码提示（与系统输入法快捷键冲突）
Ctrl+Shift+Alt+N	查找类中的方法或变量
Alt+Shift+C	最近的更改
Alt+Shift+Up/Down	上/下移一行
Shift+F6	重构 – 重命名
Ctrl+X	删除行
Ctrl+D	复制行
Ctrl+/或Ctrl+Shift+/	注释（//或者/**/）
Ctrl+J	自动代码（例如：serr）
Ctrl+Alt+J	用动态模板环绕
Ctrl+H	显示类结构图（类的继承层次）
Ctrl+Q	显示注释文档
Alt+F1	查找代码所在位置
Alt+1	快速打开或隐藏工程面板
Ctrl+Alt+left/right	返回至上次浏览的位置
Alt+left/right	切换代码视图
Alt+Up/Down	在方法间快速移动定位
Ctrl+Shift+Up/Down	向上/下移动语句
F2 或 Shift+F2	高亮错误或警告快速定位
Tab	代码标签输入完成后，按 Tab，生成代码
Ctrl+Shift+F7	高亮显示所有该文本，按 Esc 高亮消失
Alt+F3	逐个往下查找相同文本，并高亮显示
Ctrl+Up/Down	光标中转到第一行或最后一行下
Ctrl+B/Ctrl+Click	快速打开光标处的类或方法（跳转到定义处）
Ctrl+Alt+B	跳转到方法实现处
Ctrl+Shift+Backspace	跳转到上次编辑的地方
Ctrl+O	重写方法
Ctrl+Alt+Space	类名自动完成
Ctrl+Alt+Up/Down	快速跳转搜索结果
Ctrl+Shift+J	整合两行
Alt+F8	计算变量值
Ctrl+Shift+V	可以将最近使用的剪贴板内容选择插入到文本
Ctrl+Alt+Shift+V	简单粘贴
Shift+Esc	不仅可以把焦点移到编辑器上，而且还可以隐藏当前（或最后活动的）工具窗口
F12	把焦点从编辑器移到最近使用的工具窗口
Shift+F1	要打开编辑器光标字符处使用的类或者方法 Java 文档的浏览器
Ctrl+W	可以选择单词继而语句继而行继而函数
Ctrl+Shift+W	取消选择光标所在词
Alt+F7	查找整个工程中使用地某一个类、方法或者变量的位置
Ctrl+I	实现方法
Ctrl+Shift+U	大小写转化
Ctrl+Y	删除当前行
Shift+Enter	向下插入新行
psvm/sout	main/System.out.println(); Ctrl+J，查看更多
Ctrl+Shift+F	全局查找
Ctrl+F	查找/Shift+F3，向上查找/F3，向下查找
Ctrl+Shift+S	高级搜索
Ctrl+U	转到父类
Ctrl+Alt+S	打开设置对话框
Alt+Shift+Inert	开启/关闭列选择模式
Ctrl+Alt+Shift+S	打开当前项目/模块属性
Ctrl+G	定位行
Alt+Home	跳转到导航栏
Ctrl+Enter	上插一行
Ctrl+Backspace	按单词删除
Ctrl+”/-	当前方法展开、折叠
Ctrl+Shift+”/-“	全部展开、折叠

🚀2.调试与编译#

快捷键	含义
Ctrl+F2	停止
Alt+Shift+F9	选择 Debug
Alt+Shift+F10	选择 Run
Ctrl+Shift+F9	编译
Ctrl+Shift+F10	运行
Ctrl+Shift+F8	查看断点
F8	步过
F7	步入
Shift+F7	智能步入
Shift+F8	步出
Alt+Shift+F8	强制步过
Alt+Shift+F7	强制步入
Alt+F9	运行至光标处
Ctrl+Alt+F9	强制运行至光标处
F9	恢复程序
Alt+F10	定位到断点
Ctrl+F8	切换行断点
Ctrl+F9	生成项目
Alt+1	项目
Alt+2	收藏
Alt+6	TODO
Alt+7	结构
Ctrl+Shift+C	复制路径
Ctrl+Alt+Shift+C	复制引用，必须选择类名
Ctrl+Alt+Y	同步
Ctrl+~	快速切换方案（界面外观、代码风格、快捷键映射等菜单）
Shift+F12	还原默认布局
Ctrl+Shift+F12	隐藏/恢复所有窗口
Ctrl+F4	关闭
Ctrl+Shift+F4	关闭活动选项卡
Ctrl+Tab	转到下一个拆分器
Ctrl+Shift+Tab	转到上一个拆分器

🚀3.重构#

快捷键	含义
Ctrl+Alt+Shift+T	弹出重构菜单
Shift+F6	重命名
F6	移动
F5	复制
Alt+Delete	安全删除
Ctrl+Alt+N	内联

🚀4.查找#

快捷键	含义
Ctrl+F	查找
Ctrl+R	替换
F3	查找下一个
Shift+F3	查找上一个
Ctrl+Shift+F	在路径中查找
Ctrl+Shift+R	在路径中替换
Ctrl+Shift+S	搜索结构
Ctrl+Shift+M	替换结构
Alt+F7	查找用法
Ctrl+Alt+F7	显示用法
Ctrl+F7	在文件中查找用法
Ctrl+Shift+F7	在文件中高亮显示用法
Alt+left/right	向后、前
Ctrl + H	看类结构
Ctrl+z	后退

🚀5.文本编辑#

快捷键	含义
Ctrl + Y	删除
Ctrl + D	复制

🚀6.智能提示#

快捷键	含义
Ctrl+ Space	提示
Ctrl + Shift + Space	智能提示
Ctrl + Shift + Enter	完成当前语句
Ctrl + Alt + P	建议提示为参数
Ctrl + Alt + L	对代码重新排列格式
Ctrl + Alt + O	对imports进行优化

🚀7.位置定位#

快捷键	含义
F2 / Shift + F2	定位到下一个或上一个错误
Ctrl+G	定位文件行数
Ctrl+G	定位文件尾
Ctrl + [	定位到代码块开始
Ctrl + ]	定位到代码块结束
F12	回到最近的窗口
Alt + left	回到之前的文件
Alt + right	回到之后的文件
Ctrl + Shift + Backspace	定位到最后编辑位置
Esc	从tool window或其他window切换到文件编辑
Shift + Esc	关闭最近打开的窗口

🚀8.类、方法、文件定位#

快捷键	含义
Ctrl + N	查找类
Ctrl + Shift + N	查找文件
Ctrl + Alt + Shift + N	符号定位
Ctrl + F12	查看文件结构
Ctrl + E	最近打开的文件
Alt + down	定位下一个方法
Alt + up	定位上一个方法
Ctrl + p	查看方法参数信息
Ctrl + Q	查看方法、类的doc

🚀9.类、方法的结构查看、定位#

快捷键	含义
Ctrl + B	跳到类或方法的声明
Ctrl + U	定位到类的父类、接口
Ctrl + H	查看类的继承结构
Ctrl + Shift + H	查看方法的继承结构
Ctrl + Alt +H	查看类或方法被调用情况
Ctrl + Shift + I	原地参看类、方法的声明

🚀10.运行#

快捷键	含义
Ctrl + F9	Make项目(编译、修改和依赖)
Ctrl + Shift + F9	编译选定的文件、包或模块
Alt + Shift + F10	选择配置并运行
Alt + Shift + F9	选择配置和调试
Shift + F10	运行
Shift + F9	调试
Ctrl + Shift + F10	从编辑器运行上下文配置

🚀11.调试#

快捷键	含义
F8	跳过
F7	进入
Shift + F7	自动进入
Shift + F8	跳出
Alt + F9	运行到光标
Alt + F8	计算表达式
F9	恢复程序
Ctrl + F8	Toggle breakpoint
Ctrl + Shift + F8	查看断点

这么详细的总结，记得收藏备用哟！

Windows系统安装OpenClaw并使用Qwen千问接入飞书教程

Fri, 27 Mar 2026 00:00:00 GMT

免责声明 ⚠️#

本教程仅供学习和参考，作者不对使用本教程产生的任何后果承担责任。

使用风险： 读者应自行评估使用本教程的风险，因遵循本教程操作而导致的任何直接或间接损失（包括但不限于数据丢失、系统故障、账号安全问题等），作者不承担任何责任。

技术支持： 本教程为个人经验分享，不提供正式技术支持。遇到问题请优先查阅官方文档或向相关软件官方寻求帮助。

阅读本教程即表示您已阅读并同意上述声明。

这种直接操作电脑的AI使用有风险，大家注意规避风险！！！ 🚨

前言 📝#

最近 OpenClaw（小龙虾）挺火的，这是个什么东西呢，说白了就是通过它可以调度各大AI，相当于一个AI代理程序。🦞

往往之前我们常常是在 web、Idea 中使用 AI 来完成一些对话、编程代码处理等。

有了 OpenClaw 的帮助，可以直接帮我们操作浏览器、填写 Excel 表格，读取系统的文件。💪

那么今天我也是看了些许教程，来试试安装这个工具。

banner

环境准备 🔧#

安装 node.js，在官网安装最新版本的 node.js 📦

安装成功后，管理员身份打开 PowerShell（终端管理员），输入：
Terminal window
```
1
node -v
```
出现版本号则安装成功。✅

安装飞书插件 📱

Terminal window

1
openclaw plugins install @m1heng-clawd/feishu

(谨慎操作，相当于AI直接操作你的电脑)(可选) 安装后 PowerShell（终端管理员） 开启文件权限：
Terminal window
```
1
openclaw config set tools.profile "coding"
```
⚡

（可选）创建飞书应用 🎯#

如果不需要飞书机器人，只是体验 OpenClaw 可跳过这个步骤。

在飞书开放平台注册账号并登录。

进入 开发者后台创建企业自建应用 🏗️
添加机器人 🤖
权限管理，配置应用权限

🔑 赋值文档中的 json 到飞书的权限管理界面，详见下发图片。
飞书开放平台左上角，点击创建应用版本，首次发布免审，提交弹窗点击确认发布即可。 🚀
飞书开放平台凭证与基础信息，这里的 App ID 和 App Secret，后面 OpenClaw 会用到 🔐

下面步骤图片参考：

飞书配置1

飞书配置2

飞书配置3

飞书配置4

飞书配置5

飞书配置6

安装 OpenClaw ⚙️#

下面步骤为官方版安装步骤，中文版安装教程：https://clawd.org.cn/install/

在 PowerShell（终端管理员） 中输入：

Terminal window

1
iwr -useb https://openclaw.ai/install.ps1 | iex

等待下载完成，如图就是下载成功。✨

安装截图

安装向导 🧭#

运行：

Terminal window

1
openClaw onboard --install-daemon

进行启动配置，这里我翻译成中文了，自行查看。

风险提示：Yes ⚠️
安装引导模式：Manual（手动） 🖱️
网关：Local（本地网关） 🌐
工作区目录：默认 📂
模型：Qwen（千问），此时会跳转千问登录页，注册或创建账号登录成功后返回控制台，目前是免费使用。 🆓
默认模型：keep current（保持当前） 💾
默认运行端口：18789 🔌
网关绑定：Loopback（127.0.0.1） 🔄
网关认证：Token 🔑
Tailscale：off 📴
网关令牌：直接回车或自行输入，建议自行输入一个简单的 ✏️

后面如果打开web网页报错，可以尝试将修改的令牌填入如图位置后点击连接 🔗

令牌配置
选择频道：跳过，后续会对接飞书。 ⏭️
配置技能：No ❌
启用钩子：选择跳过后按空格后再按回车 ⏎
此时会新弹出一个控制台，不要关闭，然后通过打开 http://127.0.0.1:18789/ 网址访问Web页面，如果网页无法对话，关闭 PowerShell（终端管理员） 输入 openclaw gateway restart 重启 openclaw 🔍

以下是部分选项截图参考：

向导1

向导2

向导3

向导4

向导安装完成 🎉#

安装完成

（可选）对接飞书 📲#

飞书应用和向导安装完成后，打开 PowerShell（终端管理员） 执行 openclaw config set tools.profile "coding" 开启操作文件权限。 🔓

让小龙虾帮我们安装飞书插件和配置飞书。 🦞

也可以自行安装飞书插件 openclaw plugins install @m1heng-clawd/feishu

安装飞书插件和配置 🛠️#

将我们上面飞书应用的 App ID 和 App Secret，发给 OpenClaw 让它帮我们配置。

飞书对接1

出现图中如下控制台则表示正在与飞书建立连接，这时候就需要去飞书再配置下事件了。 🔄

飞书对接2

飞书事件配置 📋#

在事件与回调中点击订阅方式，配置订阅方式。注意只有出现上面截图的窗口这时候才能配置接收时间，否则会提示无法创建。 ⏰

订阅方式选择长链接后，点击添加事件，添加一个接收信息的事件，然后发布版本即可。 📢

事件配置1

事件配置2

飞书配对 🤝#

事件配置并发布版本后，此时打开飞书，给机器人发一条消息，它会回复 配对码 给你，直接把配对码丢给 OpenClaw 就行了。 💬

配对1

配对2

飞书对接完成 ✅#

完成

总结 📌#

注意开启文件读取操作权限后，谨慎使用 OpenClaw。 ⚡

本教程完整记录了在 Windows 系统上部署 OpenClaw 并接入飞书的整个过程：

核心步骤 📋#

环境准备 - 安装 Node.js 和 OpenClaw 框架 🔧
飞书应用创建 - 在飞书开放平台创建企业自建应用，配置机器人权限 🎯
OpenClaw 安装 - 通过官方脚本安装并完成向导配置 ⚙️
飞书对接 - 配置飞书插件、订阅事件、完成配对 📲

关键配置 ⚙️#

网关端口: 18789 🔌
模型: Qwen（千问） 🤖
连接模式: WebSocket 长连接 🔗

注意事项 ⚠️#

注意开启文件读取操作权限后，谨慎使用 OpenClaw 🔒
遇到问题可访问 OpenClaw 文档或中文社区 📚

后续扩展 🚀#

完成基础对接后，OpenClaw 还可以：

读写飞书文档 📄
管理云空间文件 📁
设置权限和协作 👥
导航知识库 📚
自动回复消息 💬
扩展更多插件功能 🔌

深入理解TCP协议：三次握手与四次挥手的原理与细节

Fri, 27 Mar 2026 00:00:00 GMT

📚概述#

“什么是三次握手，四次挥手？“，该问题作为计算机网络学科中常见问题之一，无论是面试还是考研，我们都有必要细细参透其中的奥妙

在学习之前，我们首先需要了解一些基本的概念

📚基础理论#

📐传输控制协议#

传输控制协议（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，在 OSI 模型中完成传输层指定功能。 TCP 使用校验和函数检验数据是否出现错误，在数据发送和接收时均需要计算校验和。

✒️TCP 特点#

1.TCP 是面向连接的传输层协议#

应用程序在使用 TCP 协议前，必须首先完成 TCP 连接的建立。在数据传输结束后，必须释放先前已建立的 TCP 连接

2.每一条 TCP 连接只能有两个端点#

TCP 连接只能是点对点，一对一的

3.TCP 提供可靠交付服务#

通过 TCP 连接传送的数据，无差错、不丢失、不重复，且按序到达

4.TCP 提供全双工通信#

TCP 允许通信双方的应用进程在任何时候都可以发送数据，TCP连接的两端都设有发送、接收缓存，用于临时存放双向通信的数据，上层应用进程在时机恰当时会读取缓存中的数据#

5.TCP 面向字节流#

字节流示意图

流是指：流入到进程或从进程流出的字节序列 TCP 把应用程序回传的数据看做一连串的无结构的字节流，不保证接收方应用程序所收到的数据块和发送方应用程序所发出的数据块具有对应大小的关系接收方应用程序收到的字节流必须和发送方应用程序发出的字节流完全一致，且接收方的应用程序必须具有识别接收字节流，并将其还原为有意义的应用层数据的能力

✒️TCP 报文首部#

这里需要了解 TCP 报文首部的格式，相关控制位非常重要

TCP报文首部

由于 TCP 报文段首部的前 20 个字节是固定的，其后 4n 个字节是根据需要增加的选项，所以 TCP首部的最小长度是 20 字节

1.源端口和目的端口#

各占 2 字节，分别写入源端口号、目的端口号

2.序号字段#

占 4 字节，范围为 [0，2 ^ 32-1]，序号使用 mod2^32 运算，在一个TCP连接中传送的字节流中的每一个字节都按顺序编号。整个要传送的字节流的起始序号必须在连接建立时设置，首部中的序号字段值则指的是本报文段所发送的数据的第一个字节的序号

3.确认号字段#

占4字节，是期望收到对方下一个报文段的第一个数据字节的序号。若确认号等于 N，则表明：到序号 N-1 为止数据均已正确接收

4.数据偏移字段#

占 4 位，指出 TCP 报文段的数据起始处和 TCP 报文段的起始处的距离。此字段实际上指出了 TCP 报文段的首部长度

5.保留字段#

占 6 位，保留为今后使用，目前应置为0

6.紧急 URG#

URG=1时，表明紧急指针字段有效，它告诉系统此报文段中有紧急数据，应尽快传送，即提高数据传送的优先级

7.确认 ACK#

仅当 ACK=1 时确认号字段才有效，TCP 规定，在连接建立后所有传送的报文段必须将 ACK 置为 1

8.推送 PSH#

接收 TCP 收到 PSH=1 的报文段后，将尽快交付接收的应用进程，不再等到缓存都填满后再继续向上交付

9.复位 RST#

当 RST=1 时，表明 TCP 连接中出现严重差错，必须释放连接，然后再重新建立传输连接。也可以用于拒绝一个非法的报文段或拒绝打开一个连接

10.同步 SYN#

连接建立时用来同步序号，SYN=1就表示这是一个连接请求或连接接受报文

11.终止 FIN#

用于释放一个连接，当 FIN=1 时，表明此报文段的发送方的数据已发送完毕，并要求释放传输连接

12.窗口字段#

占 2 字节，窗口值范围为 [0，2^16-1] 之间的整数。窗口是指发送本报文段的一方的接收窗口，窗口值作为接收方让发送方设置其发送窗口的依据

13.检验和字段#

占 2 字节，检验和字段检验的范围包括首部和数据两部分

14.紧急指针#

占 2 字节，仅当 URG=1 时才有意义，含义是：本报文段中的紧急数据的字数，紧急指针指出了紧急数据的末尾在报文段中的位置当所有紧急数据都处理完时，TCP就告诉应用程序恢复到正常操作。注意：即使窗口为零时也可发送紧急数据

15.选项字段#

长度可变，最长可达 40 字节。未使用”选项”时，TCP 首部长度为 20 字节

📚TCP 连接的建立与释放#

📐三次握手#

TCP 建立连接的过程称为握手，握手需要在客户端和服务器之间交换三个 TCP 报文段

我们举一个简单的例子帮助大家理解这个问题：试想下面这个场景

你出门在外没带钥匙，而房屋钥匙又仅有一把，在不考虑钥匙丢失在哪里的情况下，今晚你还会回家吗？

虽然此例子并不那么恰当，但是可以类比到三次握手的原因上。如果客户端和服务端有一方出现了问题，那么它们之间的通讯、资源传输必定会出问题

因此，TCP 三次握手的作用就是使客户端和服务端双方都明确自己的责任，保证双方都具有资源接收和发送的能力

三次握手示意图

字符释意：

ACK：确认报文段
ack：确认号
SYN：发送连接请求 / 接收报文段
seq：发送数据的第一个字节的序号

客户端与服务端资源收发的三次握手过程如下：

*注：图例中的 Ss、Sa 分别表示 Server send、Server accept（服务端发送能力、服务端接收能力）；Cs、Ca 分别表示 Client send、Client accept（客户端发送能力、客户端接收能力）

1.第一次握手#

第一次握手由客户端发送资源包给到服务端，若该过程正常，则得出结论：服务端接收、客户端发送服务正常

第一次握手

2.第二次握手#

第二次握手由服务端发送资源包给到客户端，若该过程正常，则得出结论：服务端发送、客户端接收服务正常

第二次握手

3.第三次握手#

这里大家可能就会有疑问了？为什么还需要进行第三次握手呢？前两次不是已经得出结论客户端、服务端接收、发送资源包能力正常了吗？

其实并不是，第一、二次握手只是在单独的过程中得出服务正常的结论，但是在第二次握手结束后，==服务端的接收能力和客户端的发送能力未知==，这时候便有了 TCP 的第三次握手过程

第三次握手由客户端发送资源包给到服务端，若该过程正常，则得出结论：服务端接收、客户端发送服务正常

第三次握手

通过这三次的握手过程我们可以分析得到：第二次是对第一次握手的补充，第三次是对第二次握手的补充，最终正好形成闭环，客户端和服务端都确认了自己的接收、发送能力正常，之后方可进行通信

并且，要完成两者状态的监测，这之间至少需要三次过程，两次并不足以判断自身的服务状态。每一个步骤都相互关联，下一次握手的”响应”由上一次”请求”触发，每次握手得出的结论都是对上一次结果的补充，从而得出最终结果

三次握手过程中，客户端和服务端交换 Initial Sequence Number (ISN)，为了使对方清楚下一步接收到的数据信息应以何序列号进行数据整合

并且，ISN 在此过程中是动态生成的。假如 ISN 固定不变，入侵者非常容易就能得出后续数据的确认号，这将会危机到数据信息的安全

📐四次挥手#

当成功建立一个 TCP 连接，服务端在 LISTEN 状态下，收到建立连接请求的 SYN 报文后，将 ACK和 SYN 存放到同一个报文中一起发送给客户端

而关闭连接时，服务端收到客户端的 FIN 报文时，仅表示对方不再发送数据，但仍然能够接收数据。此时，服务端不一定将全部数据都发送给了客户端

因此服务端关闭有两种方式：

立即关闭
继续发送一些数据给客户端后，再发送 FIN 报文给客户端（表示同意关闭连接），是否立刻关闭发送数据通道，需交由上层应用决定

所以，客户端的 ACK 和 FIN 一般都会分开发送，这里就会导致次数增加一

数据传输完毕后，双方均可释放连接。起初，客户端和服务端均处于 ESTABLISHED 状态，然后是客户端主动关闭，服务器被动关闭

整个过程请参考下图：

四次挥手示意图

字符释意：

FIN ：连接终止位
seq：发送的第一个字节的序号
ACK：确认报文段
ack：确认号

四次挥手过程：

客户端发送第一次挥手，之后由 ESTABLISHED 状态转为 FIN_WAIT1 状态
服务器收到客户端的第一次挥手之后，发送第二次挥手给服务器，服务器进入 CLOSE_WAIT 状态，等待服务器自身的 SOCKET 关闭等处理
客户端收到服务器的第二次挥手，进入 FIN_WAIT2 状态，等待服务器关闭
服务器发送第三次挥手，然后进入 LAST_ACK 状态
客户端收到第三次挥手，发送第四次挥手，客户端进入 TIME_WAIT 状态；
服务器收到第四次挥手，进入 CLOSED 状态，客户端等待 2MSL 后，进入 CLOSED 状态

TCP 状态转换过程见下图：

TCP状态转换图

📚总结#

TCP 建立连接的三次握手是指发送了三个报文段，而 TCP 断开连接进行四次挥手是指发送了四个报文段，在此过程中，SYN 和 FIN 均利用重传进行可靠传输

连接的释放本质上两次就可以完成，但若想要完全释放，则需要四次挥手，请看下图

四次挥手总结图

打电话即将结束时，路人甲说完信息”OK，我没事了”后，路人乙回复到”嗯，知道啦”。这就是完成了 TCP 四次挥手的前两次过程；路人乙马上要挂断电话时，路人甲又忽然想起来某件事，说了很多。这时路人乙又回复到”好的好的”。至此，TCP 四次挥手的后两次过程完毕

飞牛私有云 fnOS 官方安装教程（2026 最新版）

Thu, 26 Mar 2026 00:00:00 GMT

你可以将 fnOS 安装部署到你的设备上，支持主流的 x86 架构硬件。以下是安装步骤：

1. 下载安装镜像#

前往飞牛官网下载最新的系统安装 iso 镜像。

2. 制作引导盘#

此步骤需要在电脑上使用写盘工具将镜像文件烧录到 U盘中。U 盘在完成安装后就可推出。写盘工具可选择 Rufus （Rufus4.5 下载 👍、Rufus 4.0 下载、Rufus 官网）、Balenaetcher 等。下文以 Rufus 为例：

1. 选择要写入的 U 盘#

选择U盘

2. 选择下载好的镜像#

选择镜像

3. 点击开始#

进度条显示 “准备就绪” 即为完成，可拔出 U 盘。

开始写入

3. 将系统安装到设备上#

1. 设备准备#

将主机接入至少一块硬盘用于做系统盘。系统盘推荐选择 SSD 固态硬盘以获得更快的系统运行速度。
将主机接好网线。暂时不支持只有无线网卡的情况下安装，后续有计划支持。
接好电源、显示器、键盘、鼠标，鼠标非必需。

2. 选择引导盘#

将制作好的引导盘插入到主机的接口。按主机电源开机，开机同时快速按键盘热键进入boot 设备选择界面。不同设备主板进入boot 页面的热键不同，F2、F7、F8、F10、F11、F12、esc 、Delete 键都有可能。

选择引导盘，按回车，进入安装页面。

选择引导盘

3. 选择安装方式#

推荐选择 Graphical Install（图形化安装流程），回车进入下一步。

注意：

如果页面提示 “暂不支持在当前模式下安装。请前往BIOS关闭 Secure Boot 后重试”，请参考安装系统异常情况处理中第 1 点

如果在后续图形化安装步骤中遇到错误安装失败，请重启设备、在这一步选择 Rescuing Install（应急模式安装）重试。

选择安装方式

4. 选择系统盘#

方向键切换选择要用于系统安装的硬盘，回车或 Alt+N 进入下一步。

选择系统盘

5. 设置系统分区和 Swap 大小#

在系统盘容量充足的情况下，建议系统分区设置为 64 GB。如安装在虚拟机下，可按情况适当减小。Swap 分区大小已按物理内存大小计算推荐值，可按硬件情况自行调整。

注意：在 fnOS 上，系统将只安装在一块硬盘中。系统盘除系统分区以外的空间，可用于创建存储空间安装应用和存储文件。建议根据需要选择合适容量的 SSD 作为系统盘。

确认后，回车或 Alt+N 进入下一步。

设置分区

6. 确认格式化#

所选择的系统盘将被格式化，所有内容将被删除，回车或 Alt+O 确认后开始安装。

确认格式化

格式化确认

7. 设置网络#

安装完成后将自动进入网络设置，系统将自动检测已连接的网卡并获取动态 IP。如网卡未开启 DHCP，你需要手动设置 IP。确认后，回车或 Alt+S 保存设置。

设置网络

8. 重启设备#

网络设置保存成功后，你可以将引导盘从主机上拔出。回车或 Alt+O 重启系统。

重启设备

9. 重启成功进入终端#

设备重启成功后将自动进入终端登录页，这意味着系统已成功安装并启动！请记住所设置的 IP 地址，接下来你将通过浏览器访问此地址来设置和使用 fnOS。现在你可以将显示器、键盘、鼠标从主机上拔除了。

终端登录

4. 浏览器访问 fnOS#

在电脑浏览器上访问上一步所设置的 IP 地址。首次进入 fnOS，你需要完成 2 项简单的系统初始化设置。点击 开始 NAS 之旅 进入初始化。

浏览器访问

1. 设置设备名称#

设备名称支持数字、英文及短横线（-），不能以短横线开头或结尾。

2. 设置管理员账号#

fnOS 用户分为管理员用户和普通用户，且支持创建多个管理员。首位管理员为超级管理员，相较于其他管理员的特殊性在于：创建后不能删除、只能停用，且默认开启 SSH 权限。请设置高强度的密码以提高账号安全性。

确认后，点击 进入fnOS 完成设置。

初始化设置

3. 进入桌面#

建议尽快创建存储空间以便上传文件和安装应用。如果硬盘还没有准备好，也可以点击稍后跳过，后续可从设置 > 存储空间管理 中创建。

进入桌面

5. 下载安装 App#

前往官网下载app

祝你享用愉快 ^ ^