Как преобразовать Long в Int в Java

🔥 🚀 Важно для всех, кто работает с Java! 🔥
На JavaRocks ты найдешь уникальные туториалы, практические задачи и редкие книги, которых не найти в свободном доступе. Присоединяйся к нашему Telegram-каналу JavaRocks — стань частью профессионального сообщества! 

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

Это означает, что они не являются объектами класса. Все объекты и массивы хранятся в куче, в то время как примитивные типы, такие как int и long, хранятся в стековой памяти.

Long и int в чем-то похожи. Integer означает целое число, которое может быть положительным, отрицательным или нулевым. И long , и int являются целочисленными типами, поэтому они в некотором роде совместимы.

Проблема в том, что тип long находится в диапазоне от -9223372036854775808 до 9223372036854775807.
Для типа long выделяется 64 бита.
При этом тип int занимает 32 бита, в которые можно поместить числа от -2147483648 до 2147483647.

Это значит, что любое число типа int легко уместится в тип long . В Java преобразование из более узкого типа в более широкий происходит автоматически. По-другому это называется расширением.

int myInt= 18;
long myLong= 16000;
       myLong = myInt;

Здесь мы присваиваем переменной типа long значение из переменной типа int . Все пройдет гладко, в большем типе данных спокойно помещается меньший и ничего не теряется, кроме места в памяти :)))). Кстати, когда мы объявляем переменную типа long и определяем ее значение, лучше присвоить ей букву l в конце, это пригодится, когда мы будем работать с числами за пределами диапазона int .

long myVeryLong = 10000000000l;

Преобразование типа long в int в Java

Теперь вернемся к основной задаче этой статьи — преобразованию long в int. Проблема в том, что что-то большее не всегда помещается во что-то меньшее. Если попытаться действовать как в предыдущем примере, но наоборот:

public static void main(String[] args) {

int myInt= 18;
long myLong= 16000;
       myInt = myLong;
}

Компилятор Java просто не позволит нам сделать это и выдаст ошибку. Поэтому для этой операции нам нужно использовать приведение типов. Чтобы сузить переменную, вам нужно явно указать тип, к которому вы хотите привести свое значение. Вот пример, в котором мы попытаемся поместить одно «маленькое» число типа long в переменную типа int и два «больших» long числа, которые выходят за пределы диапазона int.

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;
       long myVeryLong = 10000000000l;

       myInt = (int) myLong;
       System.out.println(myInt);
       myInt = (int) oneMoreLong;
       System.out.println(myInt);
       myInt = (int) myVeryLong;
       System.out.println(myInt);
   }
}

Мы уведомили компилятор, что хотим поместить long значение в переменную типа int. Компилятор, увидев явное указание на более узкий тип, выполняет преобразование. В результате получаем вывод:

16000 
-2147483648
1410065408 

Ну, 16000 — это определенно то, что мы ожидали увидеть, но почему минус в -2147483648? И что означает это 1410065408? Дело в том, что такие числа хранились в переменной long , которая, как мы помним, занимает 64 бита. Мы пытаемся поместить эти числа в переменную int , которая может хранить только 32 бита. Как правило, эти 32 ячейки будут содержать нули и единицы из первых 32 бит long числа , а остальные будут просто отброшены. Поэтому, если исходное число не помещается в 32 бита, то те биты, которые не помещаются, просто отбрасываются. Вот почему у нас есть только правильное число 16000, так как оно занимает меньше 32 бит.

Преобразование Java 8 long в int

В Java 8 класс Math имеет новый метод, который преобразует long в int .

Math.toIntExact(value);

Лучшее в этом методе то, что он контролирует длину преобразованного числа, и если значение слишком велико, чтобы поместиться в int , он выдаст исключение. Давайте посмотрим, как это работает в нашем примере:

public class intToLong {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long oneMoreLong = 2147483648l;
       long myVeryLong = 10000000000l;

       System.out.println(Math.toIntExact(myLong));
       int y = Math.toIntExact(oneMoreLong);
       System.out.println(oneMoreLong);
       System.out.println(Math.toIntExact(myVeryLong));
   }
}

Выходные данные:

16000
Exception in thread "main" java.lang.ArithmeticException: integer overflow
	at java.base/java.lang.Math.toIntExact(Math.java:1080)
	at intToLong.main(intToLong.java:13)

Таким образом, программа вывела единственное правильно преобразованное число 16000, а затем при попытке вставить в int число, выходящее за пределы диапазона 2147483648l , метод выдал исключение. Таким образом, у нас нет проблемы отброшенных битов, как в случае классического преобразования Java long в int .

Использование BigDecimal для преобразования Long в Int

Класс BigDecimal в Java обеспечивает надежный способ обработки больших чисел и гарантирует точность при преобразованиях. Хотя он обычно используется для арифметических операций с числами с плавающей точкой, его также можно использовать для безопасного преобразования long в int.

Пример:

import java.math.BigDecimal;

public class BigDecimalConversion {
    public static void main(String[] args) {
        long longValue = 9223372036854775807L;
        BigDecimal bigDecimal = new BigDecimal(longValue);

        
        int intValue = bigDecimal.intValueExact();
        System.out.println("Converted int value: " + intValue);
    }
}

Примечание: Метод intValueExact() выдает исключение, ArithmeticException если long значение превышает диапазон int.

Использование метода Guava saturatedCast

Библиотека Guava от Google предлагает saturatedCast метод, который безопасно преобразует long в int. Этот метод контролирует, что бы значения за пределами диапазона int автоматически корректировались до Integer.MAX_VALUE или Integer.MIN_VALUE, в зависимости от направления переполнения.

Пример:

import com.google.common.primitives.Ints;

public class GuavaConversion {
    public static void main(String[] args) {
        long longValue = 9223372036854775807L;

        
        int intValue = Ints.saturatedCast(longValue);
        System.out.println("Converted int value: " + intValue);
    }
}

Совет: Guava — мощная библиотека, которая упрощает множество задач программирования на Java. Рассмотрите возможность включения ее в свои проекты для улучшения функциональности.

Понимание классов-обёрток для преобразования типов

Классы-обертки предоставляют объектно-ориентированный подход к обработке примитивных типов данных. Классы Long и Integer предлагают методы для упрощения преобразований между long и int.

Основные характеристики классов-обёрток:

• Предоставляют служебные методы для преобразования типов.
• Включают упаковку и распаковку примитивных типов.
• Предлагают такие методы, как intValue() для простых преобразований.

Использование метода intValue() для преобразования

Метод intValue() класса Long преобразует Long объект в int примитив.

Пример:

public class WrapperClassConversion {
    public static void main(String[] args) {
        Long longValue = 100000L;

        
        int intValue = longValue.intValue();
        System.out.println("Converted int value: " + intValue);
    }
}

Внимание: если Long значение превышает диапазон int, результат будет усечен, что может привести к потере данных.

Перевод статьи «How to Convert Long to Int in Java».