Как проверить, является ли строка в Java null

Введение

В этом практическом занятии (лабораторной работе) вы научитесь основным техникам обработки пустых (null) строк в Java. Мы начнем с изучения фундаментального метода проверки на пустое значение с использованием оператора равенства (==), чтобы понять, почему это важно для предотвращения NullPointerException.

На основе этого вы научитесь комбинировать проверки на пустое значение с проверками на пустую строку, чтобы эффективно обрабатывать различные состояния строк. Наконец, мы представим класс Optional как современный и более безопасный подход к управлению потенциально пустыми значениями, показав, как он может улучшить читаемость кода и предотвратить распространенные ошибки.

Проверка на null с использованием оператора равенства

На этом этапе мы научимся проверять, является ли строковая переменная в Java null с использованием оператора равенства (==). Понимание того, как обрабатывать null, является важной частью программирования на Java для предотвращения ошибок.

В Java переменная ссылочного типа (например, String) может иметь специальное значение, называемое null. Это означает, что переменная не ссылается на какой-либо объект в памяти. Попытка использовать переменную со значением null как обычный объект приведет к NullPointerException, которая является распространенной и раздражающей ошибкой для начинающих программистов.

Самый простой способ проверить, является ли строка null, - использовать оператор равенства (==).

Создадим простую Java-программу, чтобы продемонстрировать это.

Откройте WebIDE и убедитесь, что вы находитесь в директории ~/project. Вы можете это проверить, посмотрев на приглашение в терминале или введя pwd и нажав Enter.
Создайте новый Java-файл с именем NullCheck.java в директории ~/project. Для этого щелкните правой кнопкой мыши в проводнике файлов слева, выберите "New File" и введите NullCheck.java.

Откройте файл NullCheck.java в редакторе и вставьте следующий код:

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // This is an empty string, not null

        System.out.println("Checking myString1:");
        if (myString1 == null) {
            System.out.println("myString1 is null");
        } else {
            System.out.println("myString1 is not null");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null) {
            System.out.println("myString2 is null");
        } else {
            System.out.println("myString2 is not null");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null) {
            System.out.println("myString3 is null");
        } else {
            System.out.println("myString3 is not null");
        }
    }
}

В этом коде:

Мы объявляем три переменные типа String: myString1 присваивается обычная строка, myString2 явно присваивается null, а myString3 присваивается пустая строка ("").
Мы используем оператор if с оператором равенства (==), чтобы проверить, является ли каждая строка null.
Мы выводим сообщение, указывающее, является ли строка null или нет.

Сохраните файл NullCheck.java (Ctrl+S или Cmd+S).
Откройте терминал внизу WebIDE. Убедитесь, что вы находитесь в директории ~/project.
Скомпилируйте Java-программу с помощью команды javac:
```
javac NullCheck.java
```
Если нет ошибок, эта команда создаст файл NullCheck.class в той же директории.
Запустите скомпилированную Java-программу с помощью команды java:
```
java NullCheck
```
Вы должны увидеть вывод, похожий на следующий:
```
Checking myString1:
myString1 is not null

Checking myString2:
myString2 is null

Checking myString3:
myString3 is not null
```

Этот вывод подтверждает, что myString1 и myString3 не являются null, в то время как myString2 является null. Важно отметить разницу между строкой со значением null и пустой строкой (""). Пустая строка - это валидный объект типа String с нулевым количеством символов, в то время как переменная строки со значением null не указывает на какой-либо объект.

Использование == null является стандартным и правильным способом проверки, является ли ссылочная переменная null в Java.

Объединение проверок на null и пустую строку

На предыдущем этапе мы научились проверять, является ли строка null. Однако в многих реальных сценариях вам также может понадобиться проверить, является ли строка пустой (содержит ноль символов) или состоит только из пробелов. Строка, которая является null, пустой или содержит только пробелы, часто считается "пустой" или "фактически пустой".

Проверка на null и пустую строку - это распространенный запрос. Вы можете комбинировать эти проверки, используя логический оператор ИЛИ (||).

Давайте модифицируем нашу предыдущую программу, чтобы включить проверки на null и пустую строку.

Откройте файл NullCheck.java в редакторе WebIDE.
Измените метод main, чтобы включить проверку на пустую строку и объединить проверки. Замените существующий метод main следующим кодом:
```
public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // This is an empty string
        String myString4 = "   "; // This string contains only whitespace

        System.out.println("Checking myString1:");
        if (myString1 == null || myString1.isEmpty()) {
            System.out.println("myString1 is null or empty");
        } else {
            System.out.println("myString1 is not null and not empty");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null || myString2.isEmpty()) {
            System.out.println("myString2 is null or empty");
        } else {
            System.out.println("myString2 is not null and not empty");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null || myString3.isEmpty()) {
            System.out.println("myString3 is null or empty");
        } else {
            System.out.println("myString3 is not null and not empty");
        }

        System.out.println("\nChecking myString4:");
        // Note: isEmpty() does not check for whitespace
        if (myString4 == null || myString4.isEmpty()) {
            System.out.println("myString4 is null or empty");
        } else {
            System.out.println("myString4 is not null and not empty");
        }
    }
}
```
В этом обновленном коде:
- Мы добавили myString4, которая содержит только пробелы.
- Мы используем условие myString == null || myString.isEmpty(), чтобы проверить, является ли строка либо null, либо пустой. Метод isEmpty() - это встроенный метод класса String, который возвращает true, если длина строки равна 0.
- Важно: Метод isEmpty() можно вызывать только на непустой строке. Если вы попытаетесь вызвать isEmpty() на строке со значением null, вы получите NullPointerException. Поэтому важно сначала проверить на null с помощью myString == null перед вызовом myString.isEmpty(). Логический оператор ИЛИ (||) является "ленивым", то есть если первое условие (myString == null) истинно, второе условие (myString.isEmpty()) не вычисляется, предотвращая NullPointerException.
Сохраните файл NullCheck.java.
Скомпилируйте модифицированную программу в терминале:
```
javac NullCheck.java
```

Запустите скомпилированную программу:

java NullCheck

Вы должны увидеть вывод, похожий на следующий:

Checking myString1:
myString1 is not null and not empty

Checking myString2:
myString2 is null or empty

Checking myString3:
myString3 is null or empty

Checking myString4:
myString4 is not null and not empty

Обратите внимание, что myString4 (которая содержит только пробелы) считается "не null и не пустой" этой проверкой. Если вам нужно также считать строки, состоящие только из пробелов, "пустыми", вы можете использовать метод isBlank() (доступен начиная с Java 11).

Давайте быстро обновим код, чтобы использовать isBlank() для myString4:

Измените проверку для myString4 в NullCheck.java:

// ... (previous code) ...

        System.out.println("\nChecking myString4 with isBlank():");
        if (myString4 == null || myString4.isBlank()) {
            System.out.println("myString4 is null or blank");
        } else {
            System.out.println("myString4 is not null and not blank");
        }
    }
}

Сохраните файл, скомпилируйте и запустите снова:
```
javac NullCheck.java
java NullCheck
```
Вывод для myString4 теперь должен быть следующим:
```
Checking myString4 with isBlank():
myString4 is null or blank
```

Это демонстрирует, как комбинировать проверки на null и пустую/пусто-символьную строку, что является очень распространенным шаблоном в программировании на Java.

Использование Optional для безопасной обработки null-строк

На предыдущих этапах мы использовали оператор равенства (==) и методы isEmpty() или isBlank() для проверки на null и пустые/пусто-символьные строки. Хотя эти методы эффективны, начиная с Java 8 был введен класс Optional как способ более явного и функционального подхода к обработке потенциально null значений. Использование Optional может сделать ваш код более читаемым и менее подверженным ошибкам NullPointerException.

Optional - это контейнерный объект, который может содержать или не содержать непустое значение. Если значение присутствует, метод isPresent() вернет true, а метод get() вернет это значение. Если значение отсутствует, объект считается пустым, и метод isPresent() вернет false. Вызов метода get() на пустом Optional вызовет исключение NoSuchElementException.

Давайте рассмотрим, как использовать Optional с строками.

Откройте файл NullCheck.java в редакторе WebIDE.

Замените весь контент файла следующим кодом, который использует Optional:

import java.util.Optional;

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = "";
        String myString4 = "   ";

        // Creating Optional objects from strings
        Optional<String> optionalString1 = Optional.ofNullable(myString1);
        Optional<String> optionalString2 = Optional.ofNullable(myString2);
        Optional<String> optionalString3 = Optional.ofNullable(myString3);
        Optional<String> optionalString4 = Optional.ofNullable(myString4);

        System.out.println("Checking optionalString1:");
        if (optionalString1.isPresent()) {
            System.out.println("optionalString1 has a value: " + optionalString1.get());
        } else {
            System.out.println("optionalString1 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString2:");
        if (optionalString2.isPresent()) {
            System.out.println("optionalString2 has a value: " + optionalString2.get());
        } else {
            System.out.println("optionalString2 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString3:");
        // Optional.ofNullable("") creates an Optional containing an empty string
        if (optionalString3.isPresent()) {
            System.out.println("optionalString3 has a value: " + optionalString3.get());
        } else {
            System.out.println("optionalString3 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString4:");
         if (optionalString4.isPresent()) {
            System.out.println("optionalString4 has a value: " + optionalString4.get());
        } else {
            System.out.println("optionalString4 is empty (contains null)");
        }

        // Using Optional methods for safer handling
        System.out.println("\nUsing Optional methods:");

        // orElse: provides a default value if the Optional is empty
        String value1 = optionalString1.orElse("Default Value");
        String value2 = optionalString2.orElse("Default Value");
        System.out.println("Value from optionalString1 (orElse): " + value1);
        System.out.println("Value from optionalString2 (orElse): " + value2);

        // ifPresent: performs an action if a value is present
        System.out.print("If optionalString1 is present: ");
        optionalString1.ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("If optionalString2 is present: ");
        optionalString2.ifPresent(s -> System.out.println("Value is " + s));

        // filter: filters the value if present
        System.out.print("Filtered optionalString1 (length > 3): ");
        optionalString1.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("Filtered optionalString3 (length > 3): ");
        optionalString3.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));
    }
}

В этом коде:

Мы импортируем класс Optional.
Мы используем Optional.ofNullable(string) для создания объекта Optional<String> из обычной строки String. Этот метод можно безопасно использовать, даже если входная строка равна null. Если входное значение равно null, он возвращает пустой Optional; в противном случае возвращает Optional, содержащий строку.
Мы используем optionalString.isPresent() для проверки, содержит ли Optional значение.
Мы используем optionalString.get() для извлечения значения, если оно присутствует. Обратите внимание: вызов get() на пустом Optional вызовет исключение, поэтому всегда проверяйте isPresent() сначала или используйте другие более безопасные методы.
Мы демонстрируем метод orElse(defaultValue), который возвращает содержащееся значение, если оно присутствует, в противном случае возвращает указанное значение по умолчанию.
Мы демонстрируем метод ifPresent(consumer), который выполняет заданное действие (функцию, которая принимает один аргумент и не возвращает результата), если значение присутствует.
Мы демонстрируем метод filter(predicate), который возвращает Optional, содержащий значение, если оно присутствует и соответствует заданному предикату (функции, которая возвращает логическое значение), в противном случае возвращает пустой Optional.

Сохраните файл NullCheck.java.
Скомпилируйте программу в терминале:
```
javac NullCheck.java
```

Запустите программу:

java NullCheck

Вы должны увидеть вывод, похожий на следующий:

Checking optionalString1:
optionalString1 has a value: Hello

Checking optionalString2:
optionalString2 is empty (contains null)

Checking optionalString3:
optionalString3 has a value:

Checking optionalString4:
optionalString4 has a value:

Using Optional methods:
Value from optionalString1 (orElse): Hello
Value from optionalString2 (orElse): Default Value
If optionalString1 is present: Value is Hello
If optionalString2 is present:
Filtered optionalString1 (length > 3): Value is Hello
Filtered optionalString3 (length > 3):

Использование Optional может сделать ваш код более выразительным в отношении того, может ли значение отсутствовать, и предоставляет полезные методы для обработки наличия или отсутствия значения без явных проверок на null повсюду. Хотя Optional - это мощный инструмент, он не заменяет все проверки на null, но особенно полезен при работе с возвращаемыми значениями, которые могут быть null.

Резюме

В этом практическом занятии (лабораторной работе) мы научились проверять, является ли строка в Java null. Мы начали с использования оператора равенства (==) для прямого сравнения переменной строки с null, понимая, что null означает отсутствие ссылки на объект и то, что отсутствие проверки на null может привести к NullPointerException.

Затем мы рассмотрели, как объединить проверку на null с проверкой на пустую строку, понимая, что пустая строка ("") - это допустимый объект, в отличие от null. Наконец, мы научились использовать класс Optional, введенный в Java 8, как более современный и безопасный способ обработки потенциально пустых значений (null), способствуя созданию более надежного и читаемого кода путем явного указания возможности отсутствия значения.