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

Введение

В этом лабораторном занятии (LabEx) вы научитесь проверять, является ли массив в Java null. Сначала мы разберем, как проверить, является ли сам ссылка на массив null, чтобы избежать исключений NullPointerException.

Затем мы рассмотрим, как сочетать проверки на null с проверками длины массива для более надежного управления массивами. Наконец, вы проверите свои знания, работая с инициализированным пустым массивом.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/DataStructuresGroup -.-> java/arrays("Arrays") subgraph Lab Skills java/if_else -.-> lab-560003{{"Как проверить, является ли массив в Java null"}} java/arrays -.-> lab-560003{{"Как проверить, является ли массив в Java null"}} end

Проверка ссылки на массив на `null`

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

Исключение NullPointerException возникает, когда вы пытаетесь использовать переменную, которая не ссылается ни на какой объект (она равна null), как если бы это был объект. Представьте, что вы пытаетесь открыть коробку, которая не существует - это примерно то, что происходит, когда вы получаете NullPointerException.

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

Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.
Замените все содержимое файла следующим кодом:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Объявление ссылки на массив и установка ее в null

        // Проверка, является ли ссылка на массив null, прежде чем пытаться ее использовать
        if (names == null) {
            System.out.println("Массив 'names' равен null.");
        } else {
            System.out.println("Массив 'names' не равен null.");
        }
    }
}
```
Рассмотрим новые части этого кода:
- String[] names = null;: Эта строка объявляет переменную массива с именем names, которая может хранить объекты String. Затем мы сразу присваиваем ей значение null. Это означает, что переменная names в настоящее время не ссылается на какой-либо фактический объект массива в памяти.
- if (names == null): Это оператор if, который используется для принятия решений в программировании. Он проверяет, является ли условие в скобках (names == null) истинным. Оператор == используется для сравнения, равен ли переменная names значению null.
- System.out.println("Массив 'names' равен null.");: Эта строка будет выполнена только в том случае, если условие names == null истинно.
- System.out.println("Массив 'names' не равен null.");: Эта строка будет выполнена только в том случае, если условие names == null ложно (то есть names не равен null).
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу. В терминале выполните следующую команду:
```
javac HelloJava.java
```
Если компиляция прошла успешно, вы не увидите никакого вывода.
Запустите скомпилированную программу:
```
java HelloJava
```
Вы должны увидеть следующий вывод:
```
Массив 'names' равен null.
```
Этот вывод подтверждает, что наша проверка правильно определила, что ссылка на массив names равна null.

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

Комбинирование проверок на `null` и длину массива

На предыдущем этапе мы научились проверять, является ли ссылка на массив null. Теперь давайте рассмотрим, что происходит, когда мы пытаемся получить длину массива, равного null, и как комбинировать проверку на null с проверкой длины массива.

Попытка доступа к свойству .length ссылки на массив, равной null, приведет к исключению NullPointerException. Это происходит потому, что вы пытаетесь получить доступ к свойству объекта, который не существует.

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

Откройте файл HelloJava.java в редакторе WebIDE.
Замените все содержимое файла следующим кодом:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Объявление ссылки на массив и установка ее в null

        // Попытка доступа к длине массива, равного null (вызовет ошибку)
        // int length = names.length; // Раскомментирование этой строки вызовет исключение NullPointerException

        // Комбинирование проверки на null и проверки длины
        if (names != null && names.length > 0) {
            System.out.println("Массив 'names' не равен null и содержит элементы.");
        } else {
            System.out.println("Массив 'names' равен null или пуст.");
        }
    }
}
```
Вот что нового или изменилось:
- Мы сохранили строку String[] names = null;, чтобы начать с массива, равного null.
- Закомментированная строка // int length = names.length; показывает, что произойдет, если мы попытаемся напрямую получить длину массива. Мы закомментировали ее, чтобы программа не аварийно завершалась сразу.
- if (names != null && names.length > 0): Это комбинированная проверка.
  - names != null: Эта часть проверяет, что ссылка на массив names не равна null.
  - &&: Это логический оператор "И". Оба условия по обе стороны от && должны быть истинными, чтобы целое условие было истинным.
  - names.length > 0: Эта часть проверяет, что длина массива names больше 0. Эта проверка выполняется только если первая часть (names != null) истинна, благодаря свойству короткого замыкания оператора && в Java. Это предотвращает возникновение исключения NullPointerException.
- Блок else теперь выводит сообщение, указывающее, что массив либо равен null, либо пуст.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу:
```
javac HelloJava.java
```
Опять же, если компиляция прошла успешно, не будет никакого вывода.
Запустите скомпилированную программу:
```
java HelloJava
```
Вы должны увидеть следующий вывод:
```
Массив 'names' равен null или пуст.
```
Этот вывод показывает, что наша комбинированная проверка правильно определила, что массив либо равен null, либо пуст. Поскольку мы инициализировали его значением null, первая часть условия if (names != null) была ложной, и был выполнен блок else.

Комбинирование таких проверок - это стандартный способ безопасного управления ссылками на массивы в Java, который позволяет избежать исключений NullPointerException при проверке свойств, таких как длина, или доступе к элементам массива.

Тестирование с инициализированным пустым массивом

На предыдущих этапах мы узнали, как проверять ссылки на массивы на null и комбинировать такую проверку с проверкой длины массива. Мы увидели, что наша комбинированная проверка правильно определяла массив, равный null.

Теперь давайте протестируем нашу комбинированную проверку с массивом, который не равен null, но пуст (имеет длину 0). Это еще один распространенный сценарий, с которым вы столкнетесь.

Откройте файл HelloJava.java в редакторе WebIDE.
Измените строку, где мы объявляем и инициализируем массив names. Замените String[] names = null; на String[] names = new String[0];. Остальной код, включая оператор if с комбинированной проверкой, должен остаться без изменений.

Обновленный код должен выглядеть следующим образом:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[0]; // Объявление и инициализация пустого массива

        // Комбинирование проверки на null и проверки длины
        if (names != null && names.length > 0) {
            System.out.println("Массив 'names' не равен null и содержит элементы.");
        } else {
            System.out.println("Массив 'names' равен null или пуст.");
        }
    }
}
```
Вот, что изменилось:
- String[] names = new String[0];: Эта строка теперь создает новый массив объектов String размером 0. Переменная names теперь ссылается на реальный объект массива в памяти, но этот массив не содержит элементов. Он не равен null.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу:
```
javac HelloJava.java
```
Если компиляция прошла успешно, не будет никакого вывода.
Запустите скомпилированную программу:
```
java HelloJava
```
Вы должны увидеть следующий вывод:
```
Массив 'names' равен null или пуст.
```
Этот вывод такой же, как когда массив был равен null. Давайте разберемся, почему. Наше условие if выглядит так: if (names != null && names.length > 0).
- names != null: Эта часть теперь истинна, потому что names ссылается на пустой объект массива.
- names.length > 0: Эта часть проверяет, что длина массива больше 0. Поскольку длина массива равна 0, это условие ложно.
- Поскольку вторая часть условия && ложна, целое условие (names != null && names.length > 0) оценивается как ложное, и выполняется блок else.

Это показывает, что наша комбинированная проверка правильно определяет как массивы, равные null, так и пустые массивы, что часто является желаемым поведением, когда вы хотите обрабатывать массив только в том случае, если он содержит элементы.

Резюме

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

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