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

Введение

В этом лабораторном занятии (LabEx) мы рассмотрим различные методы для определения, является ли число в Java типа Long. Сначала мы научимся использовать оператор instanceof для проверки, является ли объект экземпляром оберточного класса Long.

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

Проверка экземпляра класса Long

На этом этапе мы рассмотрим класс Long в Java и научимся проверять, является ли объект экземпляром класса Long.

В Java примитивные типы данных, такие как long, не являются объектами. Однако Java предоставляет обертки (wrapper classes) для каждого примитивного типа, и Long является оберткой для примитивного типа long. Обертки позволяют рассматривать примитивные значения как объекты, что полезно во многих ситуациях, например, при работе с коллекциями.

Для проверки, является ли объект экземпляром определенного класса, мы используем оператор instanceof. Оператор instanceof - это бинарный оператор, используемый для проверки, является ли объект экземпляром класса, подкласса или интерфейса.

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

Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.

Замените все содержимое файла следующим кодом:

public class HelloJava {
    public static void main(String[] args) {
        // Create a Long object
        Long myLong = 12345L;

        // Create an Integer object
        Integer myInteger = 67890;

        // Check if myLong is an instance of Long
        if (myLong instanceof Long) {
            System.out.println("myLong is an instance of Long.");
        } else {
            System.out.println("myLong is not an instance of Long.");
        }

        // Check if myInteger is an instance of Long
        if (myInteger instanceof Long) {
            System.out.println("myInteger is an instance of Long.");
        } else {
            System.out.println("myInteger is not an instance of Long.");
        }
    }
}

В этом коде:

Мы создаем объект Long с именем myLong со значением 12345L. Суффикс L указывает, что это литерал типа long.
Мы создаем объект Integer с именем myInteger со значением 67890.
Мы используем оператор instanceof для проверки, является ли myLong экземпляром Long.
Мы используем оператор instanceof для проверки, является ли myInteger экземпляром Long.

Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу, выполнив следующую команду в терминале:
```
javac HelloJava.java
```
Если компиляция прошла успешно, вы не увидите никакого вывода.
Запустите скомпилированную программу:
```
java HelloJava
```
Вы должны увидеть следующий вывод:
```
myLong is an instance of Long.
myInteger is not an instance of Long.
```

Этот вывод подтверждает, что myLong, который мы создали как объект Long, действительно является экземпляром класса Long, в то время как myInteger, созданный как объект Integer, не является.

Преобразование строки в тип Long

На этом этапе мы научимся преобразовывать строковое представление числа в объект Long или примитивный тип long. Это распространенная задача, когда числовые данные поступают в виде текста, например, от пользовательского ввода или из файла.

Класс Long предоставляет статические методы для выполнения такого преобразования. Два наиболее часто используемых метода:

Long.parseLong(String s): Этот метод разбирает строковый аргумент как знаковое десятичное число типа long. Он возвращает примитивное значение типа long.
Long.valueOf(String s): Этот метод возвращает объект Long, содержащий значение, представленное строковым аргументом.

Давайте модифицируем нашу программу HelloJava.java, чтобы показать, как преобразовать строку в тип long и объект Long.

Откройте файл HelloJava.java в редакторе WebIDE.
Замените существующий код следующим:
```
public class HelloJava {
    public static void main(String[] args) {
        String numberString = "9876543210";

        // Parse the string to a primitive long
        long primitiveLong = Long.parseLong(numberString);
        System.out.println("Parsed primitive long: " + primitiveLong);

        // Parse the string to a Long object
        Long longObject = Long.valueOf(numberString);
        System.out.println("Parsed Long object: " + longObject);

        // Demonstrate parsing a different string
        String anotherNumberString = "112233445566";
        long anotherPrimitiveLong = Long.parseLong(anotherNumberString);
        System.out.println("Parsed another primitive long: " + anotherPrimitiveLong);
    }
}
```
В этом коде:
- Мы определяем строковую переменную numberString, содержащую текст "9876543210".
- Мы используем метод Long.parseLong(), чтобы преобразовать numberString в примитивный тип long и сохраняем результат в переменной primitiveLong.
- Мы используем метод Long.valueOf(), чтобы преобразовать numberString в объект Long и сохраняем результат в переменной longObject.
- Мы демонстрируем преобразование другой строки, чтобы показать гибкость метода.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу:
```
javac HelloJava.java
```
Убедитесь, что не возникло ошибок компиляции.

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

java HelloJava

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

Parsed primitive long: 9876543210
Parsed Long object: 9876543210
Parsed another primitive long: 112233445566

Этот вывод показывает, что как метод Long.parseLong(), так и метод Long.valueOf() успешно преобразовали строковые представления чисел в соответствующие значения типа long и объект Long.

Важно отметить, что если строка не содержит допустимое число, которое может быть представлено в виде long, эти методы вызовут исключение NumberFormatException. В этом базовом лабораторном занятии мы не будем рассматривать обработку ошибок, но это стоит учитывать при разработке реальных приложений.

Различие между типами Long и Integer

На этом этапе мы сосредоточимся на понимании ключевых различий между типами long (и его оберткой Long) и int (и его оберткой Integer) в Java. Хотя оба типа используются для хранения целых чисел, они существенно различаются по диапазону значений, которые могут хранить, и по использованию памяти.

Основное различие заключается в их размере:

int: Тип int представляет собой 32-битное знаковое целое число в дополнительном коде. Это означает, что он может хранить значения в диапазоне от -2 147 483 648 до 2 147 483 647.
long: Тип long представляет собой 64-битное знаковое целое число в дополнительном коде. Это позволяет ему хранить гораздо более широкий диапазон значений, от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807.

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

Откройте файл HelloJava.java в редакторе WebIDE.
Замените существующий код следующим:
```
public class HelloJava {
    public static void main(String[] args) {
        // Maximum value for int
        int maxInt = Integer.MAX_VALUE;
        System.out.println("Maximum value of int: " + maxInt);

        // Trying to store a value larger than maxInt in an int (will cause error if uncommented)
        // int tooBigInt = 2147483648; // This line would cause a compilation error

        // A value larger than maxInt, stored in a long
        long largeLong = 2147483648L; // Note the 'L' suffix
        System.out.println("A large value stored in long: " + largeLong);

        // Maximum value for long
        long maxLong = Long.MAX_VALUE;
        System.out.println("Maximum value of long: " + maxLong);

        // Demonstrating the size difference with literals
        System.out.println("Size of int in bits: " + Integer.SIZE);
        System.out.println("Size of long in bits: " + Long.SIZE);
    }
}
```
В этом коде:
- Мы выводим максимальное значение, которое может хранить тип int, используя константу Integer.MAX_VALUE.
- Мы показываем закомментированную строку, которая вызовет ошибку компиляции, если ее раскомментировать, так как значение 2147483648 превышает максимальное значение типа int.
- Мы сохраняем то же большое значение в переменную типа long с именем largeLong, используя суффикс L, чтобы указать, что это литерал типа long.
- Мы выводим максимальное значение, которое может хранить тип long, используя константу Long.MAX_VALUE.
- Мы выводим размер типов int и long в битах, используя константы Integer.SIZE и Long.SIZE.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу:
```
javac HelloJava.java
```
Убедитесь, что не возникло ошибок компиляции.

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

java HelloJava

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

Maximum value of int: 2147483647
A large value stored in long: 2147483648
Maximum value of long: 9223372036854775807
Size of int in bits: 32
Size of long in bits: 64

Этот вывод четко показывает, что тип long может хранить значительно большие значения, чем тип int, и подтверждает их соответствующие размеры в битах. При выборе между типами int и long учитывайте диапазон значений, которые должна хранить ваша переменная. Используйте тип int для меньших чисел, чтобы сэкономить память, и тип long для больших чисел.

Резюме

В этом лабораторном занятии мы научились проверять, является ли число типом Long в Java. Мы изучили обертку Long и ее связь с примитивным типом long. Мы сосредоточились на использовании оператора instanceof для определения, является ли объект экземпляром класса Long. С помощью практического примера мы показали, как применить instanceof для различения между объектами Long и Integer.