在 Java 中判断一个 Object 是否为“空”是一个常见但需要谨慎处理的问题，因为“空”的定义可能根据不同的场景而变化，一个 Object 可能为“空”通常指以下几种情况：

1. 对象本身是 null：这是最直接的情况,变量没有指向任何对象实例。
2. 对象是空字符串 ：对于 String 类型，一个长度为 0 的字符串通常被认为是空的。
3. 集合或数组为空：
   • 对于 Collection（如 List, Set）或 Map，其 size() 方法返回 0。
   • 对于数组，其 length 属性为 0。
4. 自定义对象为“空”：对于你自己创建的类，你可能定义了某些属性为空时，整个对象就视为“空”，一个 User 对象，username 和 id 都为空，则认为该 User 对象是空的。

下面我将详细介绍如何处理这些情况,并提供最佳实践。

判断对象是否为 null

这是最基础也是最重要的一步，任何对 null 对象的方法调用都会抛出 NullPointerException。

Object myObject = null;
if (myObject == null) {
    System.out.println("对象是 null");
} else {
    System.out.println("对象不是 null");
}

最佳实践：在进行任何其他判断之前，总是先检查 null。

判断 String 是否为空

对于 String 对象，你需要同时检查它是否为 null 以及是否为空字符串 。

使用 和 length() (基础方法)

String str = null;
// 推荐：先检查 null，再调用方法
if (str == null || str.isEmpty()) {
    System.out.println("String 是 null 或空字符串");
}

• str.isEmpty() 是 Java 6 引入的，用于检查字符串长度是否为 0，它在 str 为 null 时会抛出异常，所以必须放在 null 检查之后。

使用 StringUtils (Apache Commons Lang / Spring)

在实际项目中，使用工具类库是更推荐的做法，因为它们代码更简洁、健壮。

使用 Apache Commons Lang: 你需要先添加依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- 使用最新版本 -->
</dependency>

import org.apache.commons.lang3.StringUtils;
String str1 = null;
String str2 = "";
String str3 = "Hello";
System.out.println(StringUtils.isEmpty(str1)); // true
System.out.println(StringUtils.isEmpty(str2)); // true
System.out.println(StringUtils.isEmpty(str3)); // false

StringUtils.isEmpty() 方法内部已经帮你处理了 null 检查,非常安全。

使用 Spring Framework: 如果你的项目已经使用了 Spring,可以直接使用其工具类。

import org.springframework.util.StringUtils;
String str1 = null;
String str2 = "";
String str3 = "Hello";
System.out.println(StringUtils.isEmpty(str1)); // true
System.out.println(StringUtils.isEmpty(str2)); // true
System.out.println(StringUtils.isEmpty(str3)); // false

注意：Spring 的 StringUtils.isEmpty() 和 Apache 的行为略有不同，Spring 的版本会把只包含空格的字符串 也视为非空，如果你需要判断“空白字符串”，可以使用 StringUtils.isBlank()。

判断集合或数组是否为空

同样，你需要先检查 null,再检查其大小或长度。

基础方法

// 对于 List, Set, Map
List<String> myList = null;
Map<String, Integer> myMap = new HashMap<>();
if (myList == null || myList.isEmpty()) {
    System.out.println("List 是 null 或空的");
}
if (myMap != null && !myMap.isEmpty()) {
    System.out.println("Map 不是空的");
}
// 对于数组
String[] myArray = null;
int[] intArray = new int[0];
if (myArray == null || myArray.length == 0) {
    System.out.println("数组是 null 或空的");
}

使用 CollectionUtils (Apache Commons Collections / Spring)

使用 Apache Commons Collections:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version> <!-- 使用最新版本 -->
</dependency>

import org.apache.commons.collections4.CollectionUtils;
List<String> myList = null;
if (CollectionUtils.isEmpty(myList)) {
    System.out.println("List 是 null 或空的"); // true
}

使用 Spring Framework:

import org.springframework.util.CollectionUtils;
List<String> myList = null;
if (CollectionUtils.isEmpty(myList)) {
    System.out.println("List 是 null 或空的"); // true
}

CollectionUtils.isEmpty() 同样是 null-safe 的。

判断自定义对象是否为“空”

对于自定义对象，没有一个通用的“空”标准，你需要根据业务逻辑来定义,通常有几种实现方式：

提供 isEmpty() 方法

在你的类中添加一个 isEmpty() 或 isBlank() 方法来封装你的业务逻辑。

public class User {
    private Long id;
    private String username;
    // 构造方法, getters, setters...
    /**
     * 定义 User 对象为空的逻辑：id 和 username 都为 null
     */
    public boolean isEmpty() {
        return this.id == null && this.username == null;
    }
}
// 使用
User user1 = new User();
user1.setId(null);
user1.setUsername(null);
User user2 = new User();
user2.setId(1L);
System.out.println("user1 is empty: " + user1.isEmpty()); // true
System.out.println("user2 is empty: " + user2.isEmpty()); // false

使用 Java 8 的 Optional (推荐)

Optional 是一个容器对象，它可以包含或不包含非 null 值，它旨在减少 NullPointerException 的风险，并提供更优雅的 API 来处理可能为 null 的值。

import java.util.Optional;
public class User {
    private Long id;
    private String username;
    // 构造方法, getters, setters...
    public Optional<Long> getId() {
        return Optional.ofNullable(id);
    }
    public Optional<String> getUsername() {
        return Optional.ofNullable(username);
    }
}
// 使用
User user = new User();
// 判断 User 是否为空：如果所有关键属性都为 empty，则 User 为空
boolean isUserEmpty = user.getId().isEmpty() && user.getUsername().isEmpty();
System.out.println("Is user empty? " + isUserEmpty); // true
// 安全地获取值
String name = user.getUsername().orElse("默认用户名");
System.out.println("Username: " + name); // 输出: 默认用户名

使用 Optional 的好处是它的 API 非常清晰，强制你处理“值不存在”的情况，避免了 NullPointerException。

总结与最佳实践

核心建议：

1. 永远优先检查 null,这是防御性编程的第一步。
2. 在项目中引入并统一使用一个成熟的工具库，如 Apache Commons Lang 或 Spring Framework 中的工具类,它们能极大地简化代码并提高健壮性。
3. 对于自定义对象，考虑使用 Optional，它能让你写出更清晰、更不易出错的表达式式代码，是现代 Java 开发的最佳实践之一。