Como converter long para int em Java

Neste artigo, vamos explicar como converter long para int em Java e escrever alguns exemplos de código. Como long é um tipo de dados maior que int , aqui devemos usar conversão de tipo para essa conversão. Como você provavelmente já sabe, long e int em Java são tipos de dados primitivos. Isso significa que eles não são objetos de classe. Todos os objetos e matrizes são armazenados no Heap Space, enquanto os tipos primitivos, como int e long, são armazenados na memória Stack. Long e int são um pouco semelhantes. Inteiro significa número inteiro, que pode ser positivo, negativo ou zero. Ambos longose int são tipos inteiros, então eles são compatíveis de certa forma. O problema é que o tipo longo varia de -263 a 263 – 1, ou -9223372036854775808 a 9223372036854775807. Ou seja, o programa Java aloca 64 bits para um tipo longo . Ao mesmo tempo, o tipo int ocupa 32 bits, nos quais você pode colocar números de -231 a 231 - 1 ou, o que é o mesmo, de -2147483648 a 2147483647. Isso significa que qualquer número do tipo int pode caber facilmente em um tipo longo . Em Java, ao trabalhar com primitivas, a conversão de um tipo mais estreito para um tipo mais amplo é automática. De outra forma, é chamado de alargamento.

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

Aqui estamos atribuindo um int a uma variável longa . Tudo correu bem, em uma faixa maior, uma menor cabe tranquilamente e não perdemos nada a não ser espaço de memória. A propósito, quando declaramos uma variável do tipo long e definimos seu valor, é melhor atribuir a letra l a ela, isso será útil quando trabalharmos com números fora do intervalo int .

long myVeryLong = 10000000000l;

Java long para conversão int

Agora vamos voltar à tarefa principal deste artigo — Java long para conversão int . O problema é que nem sempre algo maior cabe em algo menor. Portanto, aqui não podemos simplesmente colocar “menor” em “maior” automaticamente em Java. Se tentarmos agir como no exemplo anterior, mas vice-versa:

//example without typecasting…nice trying!
public static void main(String[] args) {

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

O compilador Java simplesmente não nos permite fazer isso e gera um erro. Portanto, para esta operação, precisamos usar o que chamamos de typecasting. Esse processo é chamado de conversão de tipo de restrição. Para restringir uma variável, você precisa especificar explicitamente o tipo para o qual deseja converter seu valor. Aqui está um exemplo onde vamos tentar colocar um “pequeno” long para int (que deve caber) e dois “grandes” long números que estão fora do intervalo int .

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;//l in the end means ‘long’
       long myVeryLong = 10000000000l;

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

Notificamos o compilador que queremos colocar o valor long em uma variável int e somos responsáveis ​​pelas consequências dessa decisão. O compilador, vendo uma indicação explícita de um tipo mais restrito, executa a conversão. Como resultado, obtemos a saída: Bem, 16000 é definitivamente o que esperávamos ver, mas por que menos está em -2147483648? E o que significa esse 1410065408? O fato é que tais números foram armazenados em uma variável longa , que, como lembramos, leva 64 bits. Estamos tentando colocar esses números em uma variável int que pode armazenar apenas 32 bits. Como regra, essas 32 células conterão zeros e uns dos primeiros 32 bits do número longo , e o restante será simplesmente descartado. Portanto, se o número original não couber em 32 bits, os bits que não couberem serão simplesmente descartados. É por isso que só temos o número correto 16000, pois ocupa menos de 32 bits.

Java 8 long para conversão int

No Java 8, a classe Math tem um novo método que converterá long em int . Aqui está:

Math.toIntExact(value);

A melhor coisa sobre esse método é que ele controla o comprimento do número convertido e, se o valor for muito grande para caber em um int , ele lançará uma exceção. Vejamos como isso funciona em nosso exemplo:

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));
   }
}

A saída é: Assim, o programa imprimiu o único número convertido corretamente 16000 e, ao tentar enviar o número fora do intervalo 2147483648l para int , o método lançou uma exceção. Portanto, não temos o problema de bits descartados, como no caso da conversão clássica de long para int do Java .