Les 8 types primitifs en Java
Alors que je commençais à éditer ma série Java Basics d'il y a quelques années, j'ai pensé qu'il serait logique de commencer à extraire des informations très détaillées dans leurs propres articles. De cette façon, le contenu pour débutant est beaucoup plus facile à digérer. Pour commencer, je récupère toutes les informations dont je dispose sur les 8 types primitifs de Java.
Types de primitives Java
Comme le titre de cet article le suggère, Java a 8 types primitifs intégrés au langage. Dans les sous-sections suivantes, nous examinerons les huit types primitifs sans ordre particulier. Pour chaque type primitif, nous décrirons comment l'utiliser et quelles sont ses limites.
Le type primitif Int
Pour commencer, les entiers Java sont des valeurs signées 32 bits (c'est-à-dire positives ou négatives), et ils sont désignés par le int mot-clé :
int someNumber = 10;
Bien sûr, comme tous les types primitifs, les entiers ont leurs limites. Puisqu'ils sont 32 bits, nous examinons une plage de valeurs allant de -2 147 483 648 à 2 147 483 647. Cela fait beaucoup de chiffres ! Bien sûr, nous pouvons confirmer cette plage en utilisant une astuce pratique dans le volet des interactions de DrJava :
Integer.MAX_VALUE // Prints 2,147,483,647 Integer.MIN_VALUE // Prints -2,147,483,648
Naturellement, int est probablement le type entier le plus couramment utilisé pour les calculs simples. Si vous avez besoin de plus de portée, voir long ci-dessous.
Le type double primitif
Contrairement à int , les doublons Java sont des valeurs à virgule flottante 64 bits et ils sont marqués par le double mot-clé :
double someNumber = 110.55;
Pour rappel, les nombres à virgule flottante ne sont que des nombres réels. En d'autres termes, nous accédons aux décimales lorsque nous utilisons des doubles.
Puisque les doubles sont en 64 bits, nous avons accès à beaucoup plus de nombres qu'avec des entiers. Si nous utilisons la même astuce du volet d'interactions, nous pouvons découvrir à quel point la plage de valeurs potentielles est massive :
Double.MAX_VALUE // Prints 1.7976931348623157E308 Double.MIN_VALUE // Prints 4.9E-324
Gardez à l'esprit que les exposants négatifs impliquent des nombres extrêmement petits, par opposition aux nombres extrêmement négatifs. Nous n'examinons donc pas exactement le même type de plage qu'avec les nombres entiers.
En général, double est le choix par défaut pour les valeurs à virgule flottante en Java. L'alternative est float .
Le type primitif Char
Comme nous l'avons déjà vu, les caractères Java représentent des caractères 16 bits, et ils sont marqués par le char mot-clé :
char someCharacter = 'f';
Tous les caractères en Java sont définis à l'aide de guillemets simples. Pendant ce temps, les guillemets doubles sont utilisés pour définir les chaînes, dont nous parlerons plus tard.
Comme d'habitude, nous pouvons connaître la plage de caractères à l'aide de l'extrait de code suivant :
Character.MAX_VALUE // Prints '???' Character.MIN_VALUE // Prints ''
Pour donner un sens à cette plage, nous pouvons toujours convertir les résultats en un entier (nous en reparlerons plus tard) :
(int) Character.MAX_VALUE // Prints 65535 (int) Character.MIN_VALUE // Prints 0
Il s'avère que le char type est le seul type non signé en Java. En d'autres termes, un caractère peut aller de 0 à 65 535 où chaque numéro correspond à un caractère spécifique. Afin de créer des caractères au-delà de cette liste, Java peut combiner des paires de caractères. Découvrez Inverser une chaîne en Java pour quelques exemples.
Le type primitif d'octet
Lorsque nous parlions de binaire, nous avons parlé du concept de bit. Eh bien, un groupe de huit bits constitue un octet que Java prend en charge en tant que type primitif. Le byte type est essentiellement juste un nombre de 8 bits qui va de -128 à 127. Comme prévu, les octets sont désignés par le byte mot-clé :
byte someByte = 20;
Comme toujours, nous pouvons confirmer la portée d'un byte tapez en utilisant l'extrait de code suivant :
Byte.MAX_VALUE // Prints 127 Byte.MIN_VALUE // Prints -128
D'après mon expérience, le byte type est utile pour lire et traiter des données brutes. En général, cependant, nous n'en aurons probablement aucune utilité car la plage de valeurs potentielles est si petite.
Le type primitif court
Le short type est un autre type entier, mais il prend moins de place que le type int. En fait, il occupe exactement la moitié de l'espace à 16 bits, et il est marqué par le short mot-clé :
short someNumber = 11;
En termes de portée, le short tapez les horloges à seulement la moitié des bits sous forme d'entier, mais nous pouvons le confirmer comme d'habitude :
Short.MAX_VALUE // Prints 32767 Short.MIN_VALUE // Prints -32768
Pour des raisons pratiques, un short n'a que 65 546 valeurs possibles. Les deux byte et short sont généralement utilisés lorsque la mémoire et l'espace disque sont faibles. Sinon, il est prudent d'utiliser int car c'est le type par défaut lors de la déclaration d'entiers.
Le type primitif long
À l'autre extrémité du spectre se trouve le long genre primitif. Ce type représente des entiers extrêmement grands où nous pourrions vouloir des valeurs encore plus grandes que le int type peut fournir. Le long type est un entier signé 64 bits, ce qui signifie que les valeurs se situent dans les quintillions.
Naturellement, nous notons longs avec le long mot-clé :
long someBigNumber = 1013401346173L;
Pour montrer à quel point une valeur 64 bits peut être étendue, examinons l'extrait de code suivant :
Long.MAX_VALUE // Prints 9,223,372,036,854,775,807 Long.MIN_VALUE // Prints -9,223,372,036,854,775,808
Peut-être un long serait utile pour calculer la distance parcourue par la lumière dans un laps de temps donné. Au bout d'une seconde, la lumière parcourt environ 300 millions de mètres. Si nous écrivions un programme pour suivre la distance de la lumière en temps réel, le type int se terminerait après environ 7 secondes tandis qu'un long pourrait calculer jusqu'à environ 975 ans. Vous ne me croyez pas ? Consultez ce Gist qui parcourt l'ensemble du calcul.
Le type primitif flottant
Alors que nous utilisons souvent le double qui est un type de nombre à virgule flottante 64 bits, Java prend en charge un autre type de nombre à virgule flottante appelé float . Comme int , cependant, Java par défaut est double pour les valeurs à virgule flottante. Dans tous les cas, nous pouvons désigner un nombre à virgule flottante de 32 bits en utilisant le float mot-clé :
float someNumber = 11.4f;
Pour avoir une idée de la portée d'un float , réutilisons notre astuce :
Float.MAX_VALUE // Prints 3.4028235E38 Float.MIN_VALUE // Prints 1.4E-45
Comme nous pouvons le voir, 32 bits réduisent vraiment notre portée et notre précision. Si nous voulons utiliser une valeur décimale avec moins de précision que double en utilisant la moitié de l'espace, le float type est une option.
Le type primitif booléen
Enfin, nous pouvons couvrir le boolean taper. Pour déclarer un boolean , nous pouvons utiliser le boolean mot-clé :
boolean isBool = true;
Les booléens sont un peu uniques car ils ne représentent pas des valeurs numériques comme tous les autres types primitifs. En fait, notre petit MAX_VALUE et MIN_VALUE l'astuce ne fonctionnera pas ici. Au lieu de cela, les booléens représentent true ou false que nous pourrions rappeler de la leçon précédente sur la logique.
Nous n'y consacrerons pas beaucoup de temps maintenant car cela fera partie de presque tout ce que nous faisons en Java. Cela dit, nous ne les déclarerons souvent pas explicitement comme ça. Au lieu de cela, ils sont le résultat de comparaisons qui pilotent la logique dans le code. Consultez la section des opérateurs booléens ci-dessous pour plus d'informations.
Vous voulez en savoir plus ?
Comme mentionné précédemment, ces informations pouvaient être trouvées précédemment dans l'article Types primitifs et variables en Java. Bien sûr, maintenant cet article est beaucoup plus facile à lire.
Si vous avez aimé cet article et que vous en voulez plus, devenez membre de The Renegade Coder. L'adhésion est un excellent moyen de montrer votre soutien, et cela contribue grandement à garantir que ce contenu reste gratuit pour le public.
En tout cas merci encore pour votre soutien. A la prochaine !
