TOC

Conversions Java Primitives

Conversions Java primitives

1. introduction

Java est un langage typé, ce qui signifie qu'il utilise le concept de types. Il existe deux groupes de types distincts:

  1. types de données primitifs

  2. types de données abstraits.

Dans cet article, nous allons nous concentrer sur les conversions de types primitifs.

2. Vue d'ensemble des primitives

La première chose à savoir est quel type de valeurs peut être utilisé avec des types primitifs. Il existe huit types primitifs qui sont:

  • byte - 8 bits et signé

  • short - 16 bits et signé

  • char - 16 bits et non signé, de sorte qu'il puisse représenter des caractères Unicode

  • int - 32 bits et signé

  • long - 64 bits et signé

  • float - 32 bits et signé

  • double - 64 bits et signé

  • boolean - ce n'est pas numérique, ne peut avoir que des valeurstrue oufalse

Il ne s’agit pas d’une discussion approfondie sur les primitives et nous en parlerons un peu plus au besoin pendant les conversions.

3. Élargissement des conversions primitives

Lorsque nous devons effectuer une conversion à partir d'une primitive plus simple ou plus petite que le type de destination, nous n'avons pas besoin d'utiliser de notation spéciale pour cela: 

int myInt = 127;
long myLong = myInt;

Pendant l'élargissement de la conversion, la valeur primitive la plus petite est placée sur un conteneur plus grand, ce qui signifie que tout l'espace supplémentaire situé à gauche de la valeur est rempli de zéros. Ceci peut également être utilisé pour passer du groupe entier au point flottant: 

float myFloat = myLong;
double myDouble = myLong;

Cela est possible car le passage à une primitive plus large ne perd aucune information.

4. Rétrécissement de la conversion primitive

Parfois, nous devons ajuster une valeur plus grande que le type utilisé dans la déclaration de variable. Cela pourrait entraîner une perte d'informations, car certains octets devront être supprimés.

Dans ce cas, nous devons exprimer explicitement que nous sommes conscients de la situation et nous sommes d’accord avec cela, en utilisant un casting: 

int myInt = (int) myDouble;
byte myByte = (byte) myInt;

5. Élargissement et rétrécissement de la conversion primitive

Cette situation se produit dans unvery specific case when we want to convert from a byte to a char. La première conversion est l'élargissement desbyte àint, puis à partir desint, il est réduit àchar.

Un exemple clarifiera ce point: 

byte myLargeValueByte = (byte) 130;   //0b10000010 -126

La représentation binaire de 130 est la même pour -126, la différence est l'interprétation du bit de signal. Passons maintenant debyte àchar: 

char myLargeValueChar = (char) myLargeValueByte;
  //0b11111111 10000010 unsigned value
int myLargeValueInt = myLargeValueChar; //0b11111111 10000010 65410

La représentationchar est une valeur Unicode, mais la conversion enint nous a montré une très grande valeur qui a les 8 bits inférieurs exactement les mêmes que -126.

Si nous le convertissons à nouveau enbyte, nous obtenons: 

byte myOtherByte = (byte) myLargeValueInt; //0b10000010 -126

La valeur d'origine que nous avons utilisée. Si tout le code commençait par unchar, les valeurs seront différentes: 

char myLargeValueChar2 = 130; //This is an int not a byte!
  //0b 00000000 10000010 unsigned value

int myLargeValueInt2 = myLargeValueChar2; //0b00000000 10000010  130

byte myOtherByte2 = (byte) myLargeValueInt2; //0b10000010 -126

Bien que la représentationbyte soit la même, qui est -126, la représentationchar nous donne deux caractères différents.

6. Boxing/Unboxing Conversion

En Java, nous avons une classe Wrapper pour chaque type de primitive. Il s’agit d’une manière astucieuse de fournir aux programmeurs des méthodes de traitement utiles, sans la surcharge de tout avoir comme référence à un objet lourd. Depuis Java 1.5, la possibilité de convertir automatiquement une primitive en un objet et en revenir était incluse et obtenue par simple attribution: 

Integer myIntegerReference = myInt;
int myOtherInt = myIntegerReference;

7. Conversions de chaîne

Tous les types primitifs peuvent être convertis enString via leurs classes wrapper, qui remplacent la méthodetoString(): 

String myString = myIntegerReference.toString();

Si nous devons revenir à un type primitif, nous devons utiliser une méthode d'analyse définie par la classe de wrapper correspondante: 

byte  myNewByte   = Byte.parseByte(myString);
short myNewShort  = Short.parseShort(myString);
int   myNewInt    = Integer.parseInt(myString);
long  myNewLong   = Long.parseLong(myString);

float  myNewFloat  = Float.parseFloat(myString);
double myNewDouble = Double.parseDouble(myString);
boolean myNewBoolean = Boolean.parseBoolean(myString);

La seule exception ici est la classeCharacter car unString est de toute façon fait dechars, de cette façon, considérant que probablement leString est constitué d'un seulchar, nous pouvons utiliser la méthodecharAt() de la classeString: 

char myNewChar = myString.charAt(0);

8. Promotions numériques

Pour exécuter une opération binaire, il est nécessaire que les deux opérandes soient compatibles en termes de taille.

Il existe un ensemble de règles simples qui s'appliquent:

  1. Si l'un des opérandes est undouble, l'autre est promu endouble

  2. Sinon, si l'un des opérandes est unfloat, l'autre est promu enfloat

  3. Sinon, si l'un des opérandes est unlong, l'autre est promu enlong

  4. Sinon, les deux sont considérés commeint

Voyons un exemple: 

byte op1 = 4;
byte op2 = 5;
byte myResultingByte = (byte) op1 + op2;

Les deux opérandes ont été promus enint et le résultat doit être à nouveau descendu enbyte.

9. Conclusion

La conversion entre types est une tâche très courante dans les activités de programmation quotidiennes. There is a set of rules that govern the ways in which statically typed languages operate those conversions. Connaître ces règles peut vous faire gagner beaucoup de temps lorsque vous essayez de comprendre pourquoi un certain code est en cours de compilation ou non.

Le code utilisé dans cet article se trouveover on GitHub.

Related