Comment convertir long en int en Java

Dans cet article, nous allons expliquer comment convertir long en int en Java et écrire quelques exemples de code. Étant donné que long est un type de données plus grand que int , nous devons ici utiliser la conversion de type pour une telle conversion. Comme vous le savez probablement déjà, long et int en Java sont des types de données primitifs. Cela signifie qu'ils ne sont pas des objets de classe. Tous les objets et tableaux sont stockés dans Heap Space tandis que les types primitifs tels que int et long sont stockés dans la mémoire Stack. Long et int sont quelque peu similaires. Entier signifie nombre entier, qui peut être positif, négatif ou nul. Les deux longset int sont des types entiers, ils sont donc compatibles d'une certaine manière. Le problème est que le type long va de -263 à 263 – 1, ou -9223372036854775808 à 9223372036854775807. Autrement dit, le programme Java alloue 64 bits pour un type long . En même temps, le type int occupe 32 bits, dans lesquels vous pouvez mettre des nombres de -231 à 231 - 1 ou, ce qui revient au même, de -2147483648 à 2147483647. Cela signifie que n'importe quel nombre de type int peut facilement tenir dans un type long . En Java, lorsque vous travaillez avec des primitives, la conversion d'un type plus étroit vers un type plus large est automatique. D'une autre manière, cela s'appelle l'élargissement.

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

Ici, nous attribuons un int à une variable longue . Tout s'est bien passé, dans une plage plus large, une plus petite rentre tranquillement et on ne perd rien sauf de l'espace mémoire. D'ailleurs, lorsque nous déclarons une variable de type long et définissons sa valeur, il est préférable de lui attribuer la lettre l , cela sera utile lorsque nous travaillerons avec des nombres en dehors de la plage int .

long myVeryLong = 10000000000l;

Conversion Java long en entier

Revenons maintenant à la tâche principale de cet article - la conversion Java long vers int . Le problème est que quelque chose de plus grand ne rentre pas toujours dans quelque chose de plus petit. Donc, ici, nous ne pouvons pas simplement mettre "plus petit" dans "plus grand" automatiquement en Java. Si nous essayons d'agir comme dans l'exemple précédent, mais vice versa :

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

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

Le compilateur Java ne nous laissera tout simplement pas faire cela et générera une erreur. Donc, pour cette opération, nous devons utiliser ce qu'on appelle le transtypage. Ce processus est appelé conversion de type de réduction. Pour restreindre une variable, vous devez spécifier explicitement le type vers lequel vous souhaitez convertir votre valeur. Voici un exemple où nous allons essayer de mettre un "petit" long à int (qui devrait tenir) et deux "gros" longs nombres qui sont hors de la plage 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);
   }
}

Nous avons informé le compilateur que nous voulons mettre la valeur longue dans une variable int et nous sommes responsables des conséquences de cette décision. Le compilateur, voyant une indication explicite d'un type plus étroit, effectue la conversion. En conséquence, nous obtenons la sortie : Eh bien, 16000 est certainement ce que nous nous attendions à voir, mais pourquoi est-ce moins dans -2147483648 ? Et que signifie ce 1410065408 ? Le fait est que ces nombres étaient stockés dans une longue variable qui, comme on s'en souvient, prend 64 bits. Nous essayons de mettre ces nombres dans une variable int qui ne peut stocker que 32 bits. En règle générale, ces 32 cellules contiendront des zéros et des uns parmi les 32 premiers bits du nombre long , et le reste sera simplement ignoré. Par conséquent, si le nombre d'origine ne rentre pas dans 32 bits, les bits qui ne rentrent pas sont simplement ignorés. C'est pourquoi nous n'avons que le bon nombre 16000, puisqu'il occupe moins de 32 bits.

Conversion Java 8 long en entier

Dans Java 8, la classe Math a une nouvelle méthode qui convertira long en int . C'est ici:

Math.toIntExact(value);

La meilleure chose à propos de cette méthode est qu'elle contrôle la longueur du nombre converti, et si la valeur est trop grande pour tenir dans un int , elle lèvera une exception. Voyons comment cela fonctionne dans notre exemple :

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

La sortie est : Ainsi, le programme a imprimé le seul nombre correctement converti 16000, puis en essayant de pousser le nombre hors plage 2147483648l dans int , la méthode a levé une exception. Nous n'avons donc pas le problème des bits ignorés, comme dans le cas de la conversion Java classique long vers int .