返回专栏
· 18 分钟阅读

空值、NULL 与 Optional(Null, Nullable & Optional)


一、空值的基本概念

在编程中,变量并不总是拥有一个有效的业务数据。

例如:

  • 用户没有填写手机号。
  • 数据库查询没有找到记录。
  • 函数执行失败,没有返回有效对象。
  • 配置项没有设置。
  • 某个对象尚未初始化。
  • 网络请求返回的数据缺少某个字段。

这些场景都涉及数据缺失,但它们并不一定具有相同的语义。

空值(Null Value)通常用于表示一个值不存在、缺失或无效,但不同语言和系统对空值的定义并不一致。

需要区分以下几个概念:

概念 含义 典型表现
空值(Null Value) 不存在有效数据的一种抽象状态 null、None
NULL 数据库和部分语言中的空值标记 SQL NULL
null Java、JavaScript 等语言中的空引用或空值 null
None Python 中表示无值的单例对象 None
nil Go、Swift、Objective-C 等语言中的特定空值表示 nil
Optional 用类型结构表达值可能存在或不存在 Optional<T>
Undefined JavaScript 中表示未定义值 undefined

这些概念不能简单地视为同一个东西。

尤其需要注意:

NULL 是一种空值语义,Optional 是一种类型建模机制。

Optional 并不是另一种简单的空值字面量,而是通过类型系统明确表达一个值可能不存在。

二、NULL 与 null 的区别

2.1 数据库中的 NULL

在关系型数据库中,NULL 用于表示某个字段缺少可用值。

例如:

CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100),
    phone VARCHAR(20)
);

INSERT INTO users (id, name, phone)
VALUES (1, 'Alice', NULL);

这里 phone 字段为 NULL,表示当前记录没有可用的手机号。

但 NULL 并不等价于以下内容:

  • 空字符串 ''
  • 数字 0
  • 布尔值 FALSE
  • 字符串 'NULL'

它们代表不同的数据状态。

SELECT
    NULL IS NULL,
    '' IS NULL,
    0 IS NULL;

结果分别为:

TRUE
FALSE
FALSE

数据库中的 NULL 有一个非常重要的特征:它会影响 SQL 的逻辑判断。

2.2 编程语言中的 null

在 Java 中:

String name = null;

name 是一个引用变量,目前没有引用任何对象。

String name = "Alice";

name = null;

将 name 设置为 null,意味着该变量不再引用原来的字符串对象。

但这不意味着对象一定立即被销毁。对象的实际回收由垃圾回收机制决定,还取决于是否存在其他引用。

在 JavaScript 中:

let user = null;

null 是一个原始值,用于明确表示变量当前没有对象值。

typeof null; // "object"

这是 JavaScript 历史遗留的语言行为。虽然 typeof null 返回 "object",但 null 本身并不是普通对象。

2.3 Python 中的 None

Python 使用 None 表示无值:

user = None

if user is None:
    print("用户不存在")

None 是一个单例对象,类型为 NoneType。

print(type(None))
# <class 'NoneType'>

Python 中判断空值时,通常使用:

if user is None:
    ...

而不是:

if not user:
    ...

因为 not user 不仅会匹配 None,还可能匹配:

  • False
  • 0
  • 0.0
  • ""
  • []
  • {}

这些值可能是合法的业务数据,并不一定表示缺失。

三、NULL 的特殊语义:三值逻辑

数据库中的 NULL 不只是一个特殊的数据值,它还会改变逻辑表达式的计算规则。

传统布尔逻辑只有两种结果:

  • TRUE
  • FALSE

而 SQL 引入了第三种逻辑状态:

  • TRUE
  • FALSE
  • UNKNOWN

当表达式涉及 NULL,且无法确定真假时,结果通常为 UNKNOWN。

3.1 为什么 NULL 不等于 NULL?

在 SQL 中:

SELECT NULL = NULL;

结果不是 TRUE,而是 UNKNOWN。

原因在于:NULL 表示未知或缺失,两个未知值不能据此判断为相等。

例如:

  • 第一个用户的年龄未知。
  • 第二个用户的年龄也未知。

无法据此证明两个人的年龄相同。

因此,SQL 使用三值逻辑处理 NULL 比较。

3.2 三值逻辑运算规则

SQL 的逻辑运算主要遵循以下规则。

A B A AND B A OR B
TRUE TRUE TRUE TRUE
TRUE FALSE FALSE TRUE
TRUE UNKNOWN UNKNOWN TRUE
FALSE FALSE FALSE FALSE
FALSE UNKNOWN FALSE UNKNOWN
UNKNOWN UNKNOWN UNKNOWN UNKNOWN

NOT 运算规则:

A NOT A
TRUE FALSE
FALSE TRUE
UNKNOWN UNKNOWN

其中有两个容易忽略的地方:

FALSE AND UNKNOWN = FALSE

因为只要 AND 运算中有一个操作数为 FALSE,整个表达式就不可能为 TRUE。

TRUE OR UNKNOWN = TRUE

因为只要 OR 运算中有一个操作数为 TRUE,整个表达式就已经为 TRUE。

3.3 SQL 查询中的 NULL 判断

错误写法:

SELECT *
FROM users
WHERE phone = NULL;

这个条件不会按照预期筛选出 NULL 数据。

因为:

phone = NULL

得到的是 UNKNOWN,而不是 TRUE。

正确写法:

SELECT *
FROM users
WHERE phone IS NULL;

筛选非 NULL 数据:

SELECT *
FROM users
WHERE phone IS NOT NULL;

SQL 的 WHERE 子句只保留条件结果为 TRUE 的记录,FALSE 和 UNKNOWN 都不会通过筛选。

3.4 NULL 对聚合函数的影响

SQL 中大多数聚合函数会忽略 NULL。

例如:

SELECT
    COUNT(*) AS total_count,
    COUNT(phone) AS phone_count,
    AVG(age) AS average_age
FROM users;

区别:

  • COUNT(*) 统计记录数量,包括字段为 NULL 的记录。
  • COUNT(phone) 只统计 phone 非 NULL 的记录。
  • AVG(age) 计算非 NULL 年龄的平均值。

假设数据如下:

id age
1 20
2 30
3 NULL

则:

COUNT(*)  = 3
COUNT(age) = 2
AVG(age)   = 25

因此,数据库中的 NULL 不仅影响条件判断,还会影响聚合、排序、连接和数据统计。

3.5 三值逻辑的判断流程

flowchart TD
    A["执行 SQL 条件表达式"] --> B{"是否涉及 NULL"}
    B -->|"否"| C["按 TRUE 或 FALSE 计算"]
    B -->|"是"| D["根据三值逻辑计算"]
    D --> E{"结果状态"}
    E -->|"TRUE"| F["WHERE 保留记录"]
    E -->|"FALSE"| G["WHERE 排除记录"]
    E -->|"UNKNOWN"| G

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

四、空值与空字符串、默认值的区别

空值经常与空字符串、零值和默认值混淆。

它们的区别在于是否存在一个有效的值。

表现 含义 示例
NULL 没有可用值 手机号未知
空字符串 存在字符串,但长度为零 ""
数字零 存在数值,值为零 0
FALSE 存在布尔值,值为假 false
空集合 存在集合,但没有元素 []
默认值 系统或业务规则提供的初始值 18

例如:

const user = {
    name: "",
    age: 0,
    active: false,
    tags: [],
    phone: null
};

这些字段表达的是不同状态:

  • name: "":姓名字段存在,但字符串为空。
  • age: 0:年龄值为零。
  • active: false:状态明确为否。
  • tags: []:标签集合存在,但没有元素。
  • phone: null:手机号没有可用值。

在业务建模中,不应该随意将这些状态统一转换为 NULL。

否则会丢失原始数据语义。

五、空指针与空引用

在支持引用类型的语言中,空值经常表现为空引用。

5.1 空引用的本质

以 Java 为例:

User user = null;

user 是一个引用变量,但当前没有指向任何对象。

当程序执行:

user.getName();

运行时无法通过空引用访问对象成员,因此会抛出:

NullPointerException

空指针异常的本质是:程序试图通过一个不指向有效对象的引用访问对象或执行相关操作。

5.2 空引用的传播

空引用问题容易沿着函数调用链传播。

例如:

public String getUserName(User user) {
    return user.getProfile().getName();
}

这段代码存在多个潜在空值位置:

  1. user 可能为 null。
  2. user.getProfile() 可能返回 null。
  3. getName() 的调用对象可能因此为空。

调用链越长,空值风险越难排查。

可以将其抽象为:

flowchart TD
    A["接收 User 参数"] --> B{"user 是否为 null"}
    B -->|"是"| X["发生空引用访问风险"]
    B -->|"否"| C["调用 getProfile"]
    C --> D{"profile 是否为 null"}
    D -->|"是"| X
    D -->|"否"| E["调用 getName"]
    E --> F["返回用户名"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style X fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

5.3 空指针问题的常见来源

  • 对象没有初始化。
  • 函数返回了 null。
  • 数据库查询没有找到记录。
  • 外部接口返回了缺失字段。
  • 对象属性在运行过程中被设置为 null。
  • 并发环境中,检查与使用之间发生状态变化。

其中,检查与使用之间的竞态问题尤其值得注意。

if (user.getProfile() != null) {
    user.getProfile().getName();
}

如果 getProfile() 的结果可能在两次调用之间变化,重复获取结果并不一定安全。

更稳妥的方式是先保存引用:

Profile profile = user.getProfile();

if (profile != null) {
    profile.getName();
}

这仍然要求 user 本身非空。如果对象状态存在并发修改,还需要根据具体对象设计同步或不可变策略。

六、Optional 的基本概念

Optional 是一种用于表达可选值的类型。

它将一个值可能存在或不存在的状态封装起来,使这种可能性能够体现在类型结构中。

以 Java 为例:

Optional<String> name;

它表示:

  • 可能包含一个 String。
  • 也可能不包含值。

Optional 的核心思想是:

不要只依赖一个普通引用的运行时状态表达缺失,而是将“可能不存在”作为类型的一部分。

6.1 Optional 的两种状态

Optional<String> name1 = Optional.of("Alice");

Optional<String> name2 = Optional.empty();

两种状态:

状态 含义
Present Optional 内部存在一个非空值
Empty Optional 内部不存在值

需要注意,Java 的 Optional 不允许通过 Optional.of(null) 创建空值。

Optional<String> name = Optional.of(null);

这会抛出 NullPointerException。

如果传入的值可能为 null,可以使用:

Optional<String> name = Optional.ofNullable(null);

结果为 Optional.empty()。

6.2 Optional 的概念结构

可以将 Optional 理解为一个带有两种状态的容器:

flowchart TD
    A["Optional<T>"] --> B{"是否包含值"}
    B -->|"是"| C["Present<T>"]
    B -->|"否"| D["Empty"]
    C --> E["持有有效的 T"]
    D --> F["不持有值"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

从类型设计角度看,可以将 Optional 抽象为:

Optional<T> = Some(T) \;|\; None

其中:

  • Some(T) 表示存在一个类型为 T 的值。
  • None 表示不存在值。

这是代数数据类型中的和类型(Sum Type)思想。

Optional 的具体实现不一定真的使用这两个构造器名称,但表达的类型语义相同。

七、Optional 的实现与使用

7.1 Java Optional

Java 8 引入了 java.util.Optional。

常见创建方式:

Optional<String> a = Optional.of("Alice");

Optional<String> b = Optional.ofNullable(null);

Optional<String> c = Optional.empty();

常用方法:

方法 作用
of(value) 创建非空 Optional,参数为 null 时抛异常
ofNullable(value) 参数为 null 时创建 empty
empty() 创建空 Optional
isPresent() 判断是否存在值
isEmpty() 判断是否不存在值
get() 获取内部值,空状态下抛异常
orElse(value) 不存在时返回默认值
orElseGet(supplier) 不存在时通过 Supplier 获取默认值
orElseThrow() 不存在时抛出异常
map() 转换内部值
flatMap() 转换并展开嵌套 Optional
filter() 根据条件过滤内部值
ifPresent() 存在值时执行操作

7.2 判断并获取值

传统写法:

String name = null;

if (name != null) {
    System.out.println(name.length());
}

使用 Optional:

Optional<String> name = Optional.ofNullable("Alice");

name.ifPresent(value -> {
    System.out.println(value.length());
});

ifPresent 只在存在值时执行回调。

7.3 使用 orElse 提供默认值

Optional<String> name = Optional.empty();

String result = name.orElse("Guest");

当 Optional 为空时,返回 "Guest"。

需要注意 orElse 和 orElseGet 的区别:

String result1 = name.orElse(createDefaultName());

String result2 = name.orElseGet(
    () -> createDefaultName()
);

orElse 的参数表达式会在调用时求值,即使 Optional 已经有值,也会执行参数表达式。

orElseGet 接收 Supplier,只有 Optional 为空时才会调用 Supplier。

如果默认值的计算涉及数据库查询、网络请求或复杂计算,通常应该优先考虑 orElseGet。

7.4 使用 map 转换内部值

Optional<String> name = Optional.of("Alice");

Optional<Integer> length = name.map(String::length);

执行逻辑:

Optional<String>
    → 取出内部值
    → 执行 String::length
    → 将结果包装为 Optional<Integer>

如果原始 Optional 为空,map 不会执行转换函数,而是返回空 Optional。

7.5 map 与 flatMap 的区别

这是 Optional 使用中非常重要的区别。

假设:

Optional<User> user;

有一个方法:

Optional<Address> getAddress(User user);

使用 map:

Optional<Optional<Address>> result =
    user.map(User::getAddress);

因为映射函数本身返回 Optional,所以最终形成嵌套结构。

使用 flatMap:

Optional<Address> result =
    user.flatMap(User::getAddress);

flatMap 会将映射函数返回的 Optional 展开,避免嵌套 Optional。

两者的类型关系:

map: Optional<T> \times (T \rightarrow U) \rightarrow Optional<U>
flatMap: Optional<T> \times (T \rightarrow Optional<U>) \rightarrow Optional<U>

简单理解:

  • map:转换内部值,并自动包装结果。
  • flatMap:转换内部值,并展开已经包装的结果。

7.6 Optional 的链式处理

Optional<String> city =
    Optional.ofNullable(user)
        .map(User::getProfile)
        .map(Profile::getAddress)
        .map(Address::getCity);

如果链条中的某一步没有值,后续映射函数就不会继续执行,最终得到空 Optional。

但需要注意:如果某个映射函数返回 null,Optional.map 会将结果处理为空 Optional,而不是返回一个内部包含 null 的 Optional。

八、其他语言中的 Optional 与空值建模

Optional 并不是 Java 独有的设计思想。不同语言通过不同的类型系统和语法表达可选值。

8.1 Rust:Option

Rust 使用标准库中的 Option<T> 表示可能存在或不存在的值。

其定义在概念上相当于:

enum Option<T> {
    Some(T),
    None,
}

例如:

let name: Option<String> = Some(String::from("Alice"));
let empty: Option<String> = None;

Rust 不允许直接将普通值当作可能为空的引用使用,必须显式处理 Option<T>。

常见处理方式是模式匹配:

let name = Some("Alice");
match name {
    Some(value) => println!("{}", value),
    None => println!("没有名字"),
}

也可以使用 if let:

if let Some(value) = name {
    println!("{}", value);
}

Rust 的 Option<T> 与 Java 的 Optional<T> 思想相似,但在类型系统中的约束更强。

8.2 Kotlin:可空类型

Kotlin 通过类型系统直接区分可空类型和非空类型。

var name: String = "Alice"
var nickname: String? = null

其中:

  • String 表示非空字符串。
  • String? 表示可能为空的字符串。

访问可空变量时,需要使用安全调用:

val length = nickname?.length

如果 nickname 为 null,表达式结果也为 null。

Kotlin 还提供 Elvis 运算符:

val displayName = nickname ?: "Guest"

当左侧为空时,使用右侧默认值。

8.3 Swift:Optional

Swift 原生支持 Optional:

var name: String? = "Alice"