Java 字符串空值处理：避免 NullPointerException 的实用技巧

介绍

在 Java 中处理 null 值是处理字符串时一个常见的挑战。不正确地处理 null 值会导致 NullPointerException（空指针异常）以及应用程序中出现意外行为。本实验（Lab）将指导你通过各种技术，在某些值可能为 null 时安全地连接字符串。你将学习创建健壮的字符串操作代码的，包括基础和高级方法，用于你的 Java 应用程序。

理解 Java 中的 Null 值

在这一步，我们将探讨 Java 中的 null 值是什么，并创建一个简单的程序来演示在使用字符串时，null 值如何导致问题。

Java 中的 Null 是什么？

在 Java 中，null 是一个特殊的值，表示引用的缺失。引用类型（如 String、数组和自定义对象）的变量可以被赋值为 null，以表明它们不引用任何对象。

让我们创建一个简单的 Java 程序来理解 null 值的行为：

打开 WebIDE，通过单击左侧边栏中的 Explorer 图标导航到项目目录。
在 /home/labex/project 目录中创建一个名为 NullDemo.java 的新 Java 文件。
将以下代码添加到文件中：

public class NullDemo {
    public static void main(String[] args) {
        // Declaring variables with null values
        String firstName = "John";
        String lastName = null;
        String middleName = null;

        // Printing the variables
        System.out.println("First name: " + firstName);
        System.out.println("Last name: " + lastName);

        // The null value is converted to the string "null" when concatenated
        System.out.println("Full name: " + firstName + " " + lastName);

        // This will cause a NullPointerException
        try {
            System.out.println("Last name length: " + lastName.length());
        } catch (NullPointerException e) {
            System.out.println("Error: Cannot get length of null string");
        }

        // This will also cause a NullPointerException
        try {
            String fullName = firstName.concat(" ").concat(middleName).concat(" ").concat(lastName);
            System.out.println("Full name using concat: " + fullName);
        } catch (NullPointerException e) {
            System.out.println("Error: Cannot concatenate null values using concat()");
        }
    }
}

通过按 Ctrl+S 或从菜单中选择 File > Save 来保存文件。
通过单击 Terminal 菜单并选择 New Terminal，在 WebIDE 中打开一个终端。
使用以下命令编译并运行 Java 程序：

cd ~/project
javac NullDemo.java
java NullDemo

你应该看到类似于以下的输出：

First name: John
Last name: null
Full name: John null
Error: Cannot get length of null string
Error: Cannot concatenate null values using concat()

理解结果

从输出中，我们可以观察到：

当我们直接打印 null 或使用 + 运算符将其与字符串连接时，它会被转换为字符串字面量 "null"。
尝试在 null 引用上调用方法（如 lastName.length()）会导致 NullPointerException。
当与 null 值一起使用时，concat() 方法也会抛出 NullPointerException。

这个简单的演示突出了在 Java 中使用字符串时，为什么正确处理 null 值至关重要。在接下来的步骤中，我们将学习不同的技术，以便在连接字符串时安全地处理 null 值。

用于空值安全字符串连接的基本技术

现在我们已经了解了空值带来的挑战，让我们探索一些基本技术，以安全地连接可能包含空值的字符串。

使用空值检查

处理空值的最简单方法是在执行操作之前检查空值：

在 /home/labex/project 目录中创建一个名为 BasicNullHandling.java 的新 Java 文件。
将以下代码添加到文件中：

public class BasicNullHandling {
    public static void main(String[] args) {
        String firstName = "John";
        String middleName = null;
        String lastName = "Doe";

        // Method 1: Using if-else statements
        String fullName1 = firstName;
        if (middleName != null) {
            fullName1 = fullName1 + " " + middleName;
        }
        if (lastName != null) {
            fullName1 = fullName1 + " " + lastName;
        }
        System.out.println("Full name using if-else: " + fullName1);

        // Method 2: Using the ternary operator
        String fullName2 = firstName +
                           (middleName != null ? " " + middleName : "") +
                           (lastName != null ? " " + lastName : "");
        System.out.println("Full name using ternary operator: " + fullName2);

        // Method 3: Using empty string as default
        String fullName3 = firstName + " " +
                           (middleName == null ? "" : middleName) + " " +
                           (lastName == null ? "" : lastName);
        System.out.println("Full name using empty string default: " + fullName3);

        // Let's try with different null combinations
        testNullCombination("Alice", null, "Smith");
        testNullCombination("Bob", "William", null);
        testNullCombination(null, "James", "Brown");
        testNullCombination(null, null, null);
    }

    public static void testNullCombination(String first, String middle, String last) {
        System.out.println("\nTesting with: first=" + first + ", middle=" + middle + ", last=" + last);

        // Handle potential null in first name
        String safeName = "";
        if (first != null) {
            safeName = first;
        }

        // Add middle name if not null
        if (middle != null) {
            if (!safeName.isEmpty()) {
                safeName += " ";
            }
            safeName += middle;
        }

        // Add last name if not null
        if (last != null) {
            if (!safeName.isEmpty()) {
                safeName += " ";
            }
            safeName += last;
        }

        System.out.println("Result: \"" + safeName + "\"");
    }
}

通过按 Ctrl+S 或从菜单中选择 File > Save 来保存文件。
编译并运行 Java 程序：

cd ~/project
javac BasicNullHandling.java
java BasicNullHandling

你应该看到类似于以下的输出：

Full name using if-else: John Doe
Full name using ternary operator: John Doe
Full name using empty string default: John  Doe

Testing with: first=Alice, middle=null, last=Smith
Result: "Alice Smith"

Testing with: first=Bob, middle=William, last=null
Result: "Bob William"

Testing with: first=null, middle=James, last=Brown
Result: "James Brown"

Testing with: first=null, middle=null, last=null
Result: ""

理解基本技术

让我们分析一下我们刚刚使用的技术：

If-else 语句：我们在将每个字符串添加到结果之前，检查它是否为 null。这种方法让你完全控制连接过程。
三元运算符：一种更简洁的方法，使用条件运算符 ?: 在值为空时提供一个空字符串。
空字符串默认值：三元运算符的另一种用法，用空字符串替换 null 值。
testNullCombination 方法：展示了一种更全面的方法，可以处理任何空值的组合，并正确管理姓名部分之间的空格。

这些技术提供了健壮的空值处理，但可能会使你的代码更加冗长。在下一步中，我们将探索现代 Java 中更优雅的解决方案。

用于空值安全字符串连接的高级技术

现在，让我们探索一些更高级、更优雅的技术，用于在连接字符串时处理空值。现代 Java 提供了几种内置方法，使空值处理更加方便。

使用 Java API 方法和 StringBuilder

在 /home/labex/project 目录中创建一个名为 AdvancedNullHandling.java 的新 Java 文件。
将以下代码添加到文件中：

import java.util.Objects;
import java.util.StringJoiner;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class AdvancedNullHandling {
    public static void main(String[] args) {
        String firstName = "John";
        String middleName = null;
        String lastName = "Doe";

        // Method 1: Using Objects.toString() (Java 7+)
        String fullName1 = Objects.toString(firstName, "") + " " +
                           Objects.toString(middleName, "") + " " +
                           Objects.toString(lastName, "");
        System.out.println("Using Objects.toString(): \"" + fullName1 + "\"");

        // Method 2: Using StringBuilder
        StringBuilder builder = new StringBuilder();
        if (firstName != null) {
            builder.append(firstName);
        }
        if (middleName != null) {
            if (builder.length() > 0) {
                builder.append(" ");
            }
            builder.append(middleName);
        }
        if (lastName != null) {
            if (builder.length() > 0) {
                builder.append(" ");
            }
            builder.append(lastName);
        }
        String fullName2 = builder.toString();
        System.out.println("Using StringBuilder: \"" + fullName2 + "\"");

        // Method 3: Using String.join() with filtering (Java 8+)
        List<String> nameParts = Arrays.asList(firstName, middleName, lastName);
        String fullName3 = nameParts.stream()
                                   .filter(Objects::nonNull)
                                   .collect(Collectors.joining(" "));
        System.out.println("Using Stream and String.join(): \"" + fullName3 + "\"");

        // Method 4: Using StringJoiner (Java 8+)
        StringJoiner joiner = new StringJoiner(" ");
        if (firstName != null) joiner.add(firstName);
        if (middleName != null) joiner.add(middleName);
        if (lastName != null) joiner.add(lastName);
        String fullName4 = joiner.toString();
        System.out.println("Using StringJoiner: \"" + fullName4 + "\"");

        // Testing with different combinations
        System.out.println("\nTesting different combinations:");
        testCombination("Alice", null, "Smith");
        testCombination("Bob", "William", null);
        testCombination(null, "James", "Brown");
        testCombination(null, null, null);
    }

    public static void testCombination(String first, String middle, String last) {
        System.out.println("\nInput: first=" + first + ", middle=" + middle + ", last=" + last);

        // Method 1: Using String.join with filtering
        List<String> parts = Arrays.asList(first, middle, last);
        String result = parts.stream()
                            .filter(Objects::nonNull)
                            .collect(Collectors.joining(" "));
        System.out.println("Result: \"" + result + "\"");

        // Method 2: Using StringJoiner - another approach
        StringJoiner joiner = new StringJoiner(" ");
        addIfNotNull(joiner, first);
        addIfNotNull(joiner, middle);
        addIfNotNull(joiner, last);
        System.out.println("Using helper method: \"" + joiner.toString() + "\"");
    }

    private static void addIfNotNull(StringJoiner joiner, String value) {
        if (value != null) {
            joiner.add(value);
        }
    }
}

通过按 Ctrl+S 或从菜单中选择 File > Save 来保存文件。
编译并运行 Java 程序：

cd ~/project
javac AdvancedNullHandling.java
java AdvancedNullHandling

你应该看到类似于以下的输出：

Using Objects.toString(): "John  Doe"
Using StringBuilder: "John Doe"
Using Stream and String.join(): "John Doe"
Using StringJoiner: "John Doe"

Testing different combinations:

Input: first=Alice, middle=null, last=Smith
Result: "Alice Smith"
Using helper method: "Alice Smith"

Input: first=Bob, middle=William, last=null
Result: "Bob William"
Using helper method: "Bob William"

Input: first=null, middle=James, last=Brown
Result: "James Brown"
Using helper method: "James Brown"

Input: first=null, middle=null, last=null
Result: ""
Using helper method: ""

理解高级技术

让我们分析一下这些更高级的技术：

**Objects.toString()**：在 Java 7 中引入，此方法返回对象的字符串表示形式，如果对象为空，则返回默认值。但是，请注意，它不会自动处理姓名部分之间的空格。
StringBuilder：提供对字符串构建的更多控制，并自动将 null 转换为 "null"，但我们添加了自己的空值检查来正确处理空值。
**Stream API 与 String.join()**：一种现代的 Java 8+ 方法，在用分隔符连接字符串之前过滤掉空值。这是一个简洁而优雅的解决方案。
StringJoiner：另一个 Java 8+ 类，专门设计用于使用分隔符连接字符串。结合我们的辅助方法 addIfNotNull()，它提供了一种干净的方式来处理空值。

Stream API 方法（方法 3）和 StringJoiner 方法（方法 4）特别优雅，因为它们以最少的代码处理了空值和姓名部分之间的空格。

创建一个实际应用

现在，我们已经探索了各种处理字符串连接中空值的技术，让我们应用我们所学到的知识来构建一个小型的实际应用。这将有助于巩固我们的理解，并展示如何在现实世界中使用这些技术。

构建用户资料格式化程序

在这一步中，我们将创建一个程序，用于格式化用户资料信息，处理各种字段中可能存在的空值。

在 /home/labex/project 目录中创建一个名为 UserProfileFormatter.java 的新 Java 文件。
将以下代码添加到文件中：

import java.util.StringJoiner;
import java.util.Objects;

public class UserProfileFormatter {
    public static void main(String[] args) {
        // Complete user with all fields
        formatUserProfile("John", "Doe", "john.doe@example.com", "Software Developer", "New York");

        // User with some null fields
        formatUserProfile("Alice", "Smith", null, "Data Scientist", null);

        // User with only name
        formatUserProfile("Bob", "Johnson", null, null, null);

        // User with minimal information
        formatUserProfile(null, "Williams", "robert@example.com", null, null);

        // Let's use our utility method
        User user1 = new User("Sarah", "Connor", "sarah@skynet.com", "Freedom Fighter", "Los Angeles");
        System.out.println("\nFormatted user1 profile:");
        System.out.println(formatUserInfo(user1));

        User user2 = new User("James", null, null, "Student", "Boston");
        System.out.println("\nFormatted user2 profile:");
        System.out.println(formatUserInfo(user2));
    }

    public static void formatUserProfile(String firstName, String lastName,
                                        String email, String occupation, String city) {
        System.out.println("\n------ User Profile ------");

        // Format full name using StringJoiner
        StringJoiner nameJoiner = new StringJoiner(" ");
        if (firstName != null) nameJoiner.add(firstName);
        if (lastName != null) nameJoiner.add(lastName);
        String fullName = nameJoiner.toString();

        System.out.println("Name: " + (fullName.isEmpty() ? "Not provided" : fullName));

        // Email with null check using ternary operator
        System.out.println("Email: " + (email != null ? email : "Not provided"));

        // Occupation with Objects.toString()
        System.out.println("Occupation: " + Objects.toString(occupation, "Not provided"));

        // City with null check using if-else
        String cityInfo;
        if (city != null) {
            cityInfo = city;
        } else {
            cityInfo = "Not provided";
        }
        System.out.println("City: " + cityInfo);

        System.out.println("---------------------------");
    }

    // A more comprehensive utility method to format user information
    public static String formatUserInfo(User user) {
        if (user == null) {
            return "No user information available";
        }

        StringBuilder builder = new StringBuilder();
        builder.append("------ User Profile ------\n");

        // Handle name
        StringJoiner nameJoiner = new StringJoiner(" ");
        if (user.getFirstName() != null) nameJoiner.add(user.getFirstName());
        if (user.getLastName() != null) nameJoiner.add(user.getLastName());
        String fullName = nameJoiner.toString();
        builder.append("Name: ").append(fullName.isEmpty() ? "Not provided" : fullName).append("\n");

        // Handle email
        builder.append("Email: ").append(user.getEmail() != null ? user.getEmail() : "Not provided").append("\n");

        // Handle occupation
        builder.append("Occupation: ").append(Objects.toString(user.getOccupation(), "Not provided")).append("\n");

        // Handle city
        builder.append("City: ").append(Objects.toString(user.getCity(), "Not provided")).append("\n");

        builder.append("---------------------------");
        return builder.toString();
    }

    // User class to represent a user
    static class User {
        private final String firstName;
        private final String lastName;
        private final String email;
        private final String occupation;
        private final String city;

        public User(String firstName, String lastName, String email, String occupation, String city) {
            this.firstName = firstName;
            this.lastName = lastName;
            this.email = email;
            this.occupation = occupation;
            this.city = city;
        }

        public String getFirstName() { return firstName; }
        public String getLastName() { return lastName; }
        public String getEmail() { return email; }
        public String getOccupation() { return occupation; }
        public String getCity() { return city; }
    }
}

通过按 Ctrl+S 或从菜单中选择 File > Save 来保存文件。
编译并运行 Java 程序：

cd ~/project
javac UserProfileFormatter.java
java UserProfileFormatter

你应该看到类似于以下的输出：

------ User Profile ------
Name: John Doe
Email: john.doe@example.com
Occupation: Software Developer
City: New York
---------------------------

------ User Profile ------
Name: Alice Smith
Email: Not provided
Occupation: Data Scientist
City: Not provided
---------------------------

------ User Profile ------
Name: Bob Johnson
Email: Not provided
Occupation: Not provided
City: Not provided
---------------------------

------ User Profile ------
Name: Williams
Email: robert@example.com
Occupation: Not provided
City: Not provided
---------------------------

Formatted user1 profile:
------ User Profile ------
Name: Sarah Connor
Email: sarah@skynet.com
Occupation: Freedom Fighter
City: Los Angeles
---------------------------

Formatted user2 profile:
------ User Profile ------
Name: James
Email: Not provided
Occupation: Student
City: Boston
---------------------------

理解用户资料格式化程序

在这个例子中，我们创建了一个实际应用，用于格式化用户资料信息，这些信息通常包含空值或缺失值。让我们分解一下发生了什么：

我们在 formatUserProfile 方法中使用了不同的空值处理技术：
- StringJoiner 用于组合姓名部分
- 三元运算符用于电子邮件
- Objects.toString() 用于职业
- If-else 语句用于城市
我们创建了一个更全面的 formatUserInfo 方法，该方法接受一个 User 对象，并处理所有字段中可能存在的空值。
User 类演示了一种常见的情况，即某些字段的数据可能缺失。

这个实际的例子展示了我们所学到的技术如何应用于现实世界的场景。代码是健壮的，并且可以优雅地处理空值，在信息缺失时提供默认文本（"Not provided"）。

总结

在这个实验中，你学习了如何在连接 Java 字符串时处理空值，这是 Java 编程中一个常见的挑战。你探索了各种技术，从基本的条件检查到使用现代 Java API 的更高级方法。

以下是你所学内容的总结：

理解空值：你了解了 Java 中的空值是什么，以及它们在字符串操作中未正确处理时如何导致 NullPointerException。
基本技术：
- 使用 if-else 语句检查空值
- 使用三元运算符提供默认值
- 在字符串的各个部分处理空值
高级技术：
- 使用 Objects.toString() 提供默认值
- 使用 StringBuilder 更好地控制字符串构建
- 使用 Java 8+ 的特性，如 StringJoiner 和 Stream API
- 在连接字符串之前过滤空值
实际应用：
- 构建一个处理缺失信息的用户资料格式化程序
- 在实际场景中实现多种空值处理技术

通过掌握这些技术，你可以编写更健壮的 Java 代码，从而优雅地处理空值并避免常见的运行时异常。这些技能对于构建可靠且可维护的 Java 应用程序至关重要。

Java 字符串连接中如何处理空值

介绍

理解 Java 中的 Null 值

Java 中的 Null 是什么？

理解结果

用于空值安全字符串连接的基本技术

使用空值检查

理解基本技术

用于空值安全字符串连接的高级技术

使用 Java API 方法和 StringBuilder

理解高级技术

创建一个实际应用

构建用户资料格式化程序

理解用户资料格式化程序

总结