Types primitifs en Java

1. Liste des types primitifs

Java a 8 types primitifs de base. Ils sont appelés primitifs car les valeurs de ces types ne sont pas des objets et sont stockées directement dans des variables.

Voici un tableau avec quelques brèves informations sur ces types :

Les variables locales d'une méthode n'ont pas de valeur par défaut. Si vous n'attribuez pas de valeur à ces variables, elles sont considérées comme non initialisées et ne peuvent pas être utilisées.

Mais revenons aux types primitifs et examinons-les de plus près.

2. Types entiers

Java a 4 types d'entiers : byte, shortet int. longIls diffèrent par leur taille et la plage de valeurs qu'ils peuvent stocker.

inttaper

Le plus couramment utilisé est le inttype. Le nom vient du mot int eger (nombre entier). Tous les littéraux entiers (nombres entiers) dans le code sont ints(s'ils ne se terminent pas par L, Fou D).

Les variables de ce type peuvent prendre des valeurs de -2,147,483,648à +2,147,483,647.

C'est beaucoup et c'est suffisant pour presque toutes les occasions. Presque toutes les fonctions qui renvoient un nombre renvoient un int.

Exemples:

int n = "String".length();

String[] array = {"Tic", "Tac", "Toe"};
int n = array.length;

shorttaper

Le shorttype tire son nom de short int. Il est aussi souvent appelé entier court . Contrairement au inttype, sa longueur n'est que de deux octets et la plage de valeurs possibles va de -32,768à +32,767.

Cela signifie que vous ne pouvez pas y stocker le nombre un million. Ou même 50 000. C'est le type d'entier le plus rarement utilisé en Java. La principale motivation pour l'utiliser est de conserver la mémoire.

Supposons que vous ayez une situation où vous savez à l'avance que vous travaillerez avec des valeurs qui ne dépassent jamais 30 000, et il y aura des millions de ces valeurs.

Par exemple, supposons que vous écriviez une application qui traite des images ultra-haute définition qui utilisent 10-bits par couleur. Et vous avez un million de pixels dans votre image. C'est un scénario où la décision d'utiliser intou shortimporte.

longtaper

Ce type tire son nom de long intet est également appelé entier long . Contrairement au inttype, il a une plage de valeurs fabuleusement énorme : de à .-9*1018+9*1018

Pourquoi n'est-ce pas le type entier de base ?

Parce que Java est apparu au milieu des années 90, lorsque la plupart des ordinateurs étaient en 32 bits. Cela signifie que tous les processeurs ont été optimisés pour travailler avec des nombres composés de 32 bits. Les processeurs pouvaient fonctionner avec des entiers 64 bits, mais les opérations avec eux étaient plus lentes.

En conséquence, les programmeurs ont raisonnablement décidé de créer intle type entier standard et de n'utiliser le longtype que lorsque cela était vraiment nécessaire.

bytetaper

C'est le plus petit type entier en Java, mais loin d'être le moins utilisé. Son nom, byte, est également le mot désignant le plus petit bloc de mémoire adressable en Java.

Il n'y a pas beaucoup de valeurs valides pour le bytetype : de -128à +127. Mais ce n'est pas sa force. Le bytetype est le plus souvent utilisé lorsque vous avez besoin de stocker une grande quantité de données blob en mémoire. Un tableau de bytes est idéal à cette fin.

Supposons que vous ayez besoin de copier un fichier quelque part.

Vous n'avez pas besoin de traiter le contenu du fichier : vous voulez simplement créer une zone de mémoire (tampon), y copier le contenu du fichier, puis écrire ces données du tampon dans un autre fichier. Un bytetableau est ce dont vous avez besoin pour cela.

Gardez à l'esprit qu'une variable tableau ne stocke qu'une référence à une zone de mémoire. Lorsque la variable est transmise à une méthode, seule l'adresse mémoire est transmise. Le bloc de mémoire lui-même n'est pas copié.

byte[] buffer = new byte[1024*1024];
FileInputStream sourceFile = new FileInputStream("c:\\data.txt");
FileOutputStream destFile = new FileOutputStream("c:\\output.txt");
while (true)
{
   int size = sourceFile.read(buffer); // Read data from a file into a buffer
   destFile.write(buffer, 0, size); // Write data from the buffer to a file

   // Stop copying if the buffer is not full
   if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();

3. Types réels

Les types primitifs incluent deux types pour les nombres réels. Bien qu'il ne soit pas tout à fait exact d'utiliser ce terme. Lorsque les ordinateurs manipulent des nombres réels, nous les appelons des nombres à virgule flottante . Le nom vient d'une norme de représentation des nombres, dans laquelle les parties entières et fractionnaires d'un nombre sont séparées par un point (un point, pas une virgule).

Java a deux types primitifs à virgule flottante : doubleet float.

Comme nous l'avons dit précédemment, ces types ont un agencement interne très spécifique : en fait, à l'intérieur de chaque variable de ces types se trouve non pas un nombre, mais deux :

Par exemple, le nombre à virgule flottante 987654.321peut être représenté par . Puis en mémoire il sera représenté par deux nombres (la mantisse , c'est à dire la partie significative du nombre) et ( l'exposant , c'est à dire une puissance de dix)0.987654321*1069876543216

floattaper

Le nom du floattype vient du nombre à virgule flottante . La taille de ce type est assez petite — seulement 4 octets (32 bits) — mais il peut stocker des valeurs de à . 24 bits sont alloués pour représenter la mantisse, et 8 bits pour l'exposant. Ce type est capable de stocker seulement 8 chiffres significatifs.-3.4*10383.4*1038

Cette approche permet de stocker des nombres beaucoup plus grands qu'un int, tout en utilisant les mêmes 4 octets. Mais pour ce faire, nous sacrifions la précision. Parce qu'une partie de la mémoire stocke la mantisse, ces variables ne stockent que 6 à 7 décimales tandis que le reste est ignoré.

Exemple:

float a = (float) 123.456789;

float a = (float) 12345.9999;

float a = (float) -123.456789E-2;

Comme vous pouvez le voir, le principal inconvénient de ce type est le très petit nombre de chiffres significatifs, et la perte de précision dès le huitième chiffre. C'est pourquoi le floattype n'est pas très populaire parmi les programmeurs Java.

doubletaper

Le doubletype est le type à virgule flottante standard. Le nom vient du nombre à virgule flottante double précision . Tous les vrais littéraux sont doubles par défaut.

Ce type occupe 8 octets de mémoire (64 bits) et peut stocker des valeurs de à . Une chose importante à savoir est que 53 bits sont alloués pour la mantisse, tandis que les 11 restants sont pour l'exposant.-1.7*103081.7*10308

Cela permet de stocker 15 à 17 chiffres significatifs.

Exemple:

double a = 1234567890.1234567890;

double a = 1234567890.1234512345;

double a = 1234567890.1357913579;

Cette précision, notamment par rapport au floattype, est déterminante : 99 % de toutes les opérations sur les nombres réels sont réalisées à l'aide du doubletype.

11des bits sont alloués pour l'exposant, ce qui signifie que vous pouvez stocker des puissances de dix de -323à +308(c'est une puissance de deux de -1024à +1023). Le doubletype peut facilement stocker un nombre avec des centaines de zéros après la virgule :

double a = 2E-300 * 3E+302

4. Infini

Les nombres à virgule flottante ont une autre caractéristique intéressante : ils peuvent stocker une valeur spéciale indiquant l'infini . Et vous pouvez représenter l'infini positif et l'infini négatif .

Exemples:

System.out.println( 100.0 / 0.0 );

Infinity

System.out.println( -100.0 / 0.0 );

-Infinity

double a = 1d / 0d;
double b = a * 10;
double c = b - 100;

a == Infinity
b == Infinity
c == Infinity

Si l'infini est multiplié par un nombre, vous obtenez l'infini. Si vous ajoutez un nombre à l'infini, vous obtenez l'infini. C'est super pratique.

Pas un nombre ( NaN)

Toute opération impliquant l'infini donne l'infini. Eh bien, la plupart mais pas tous.

Les nombres à virgule flottante peuvent stocker une autre valeur spéciale : NaN. C'est l'abréviation de Not a Number ( pas un nombre).

En mathématiques, si vous divisez l'infini par l'infini, le résultat est indéfini.

Mais, en Java, si vous divisez l'infini par l'infini, le résultat est NaN.

Exemples:

System.out.println(0.0 / 0.0);

NaN

double infinity = 1d / 0d;
System.out.println(infinity / infinity);

NaN

double a = 0.0 / 0.0;
double b = a * 10;
double c = b - 100;
double d = a + infinity;

a == NaN
b == NaN
c == NaN
d == NaN

Toute opération avec NaNdes rendements NaN.

5. chartaper

Parmi les types primitifs de Javachar , un mérite une attention particulière : le type. Son nom vient du mot char acter , et le type lui-même est utilisé pour stocker des caractères.

Les caractères sont ce dont sont faites les chaînes, n'est-ce pas ? Les chaînes sont un tableau de caractères.

Mais encore plus intéressant est le fait que le chartype est aussi un type numérique ! C'est un type à double usage, pour ainsi dire.

La réalité est que le chartype ne fait pas réellement de caractères. Au lieu de cela, il stocke les codes de caractères du codage Unicode. Chaque caractère correspond à un nombre : le code numérique du caractère.

Chaque charvariable occupe deux octets en mémoire (comme le shorttype). Mais contrairement au shorttype, le chartype entier n'est pas signé et peut stocker des valeurs de 0à 65,535.

Le chartype est un type hybride. Ses valeurs peuvent être interprétées à la fois comme des nombres (par exemple, elles peuvent être additionnées et multipliées) et comme des caractères. Cela a été fait parce que bien que les caractères soient des représentations visuelles, pour un ordinateur, ce ne sont avant tout que des nombres. Et c'est beaucoup plus pratique de les utiliser comme des nombres.

Unicode

Unicode est une table spéciale (encodage) qui contient tous les caractères du monde. Et chaque personnage a son propre numéro. Il ressemble approximativement à ceci :

Il existe différentes façons d'attribuer une valeur à une charvariable.

char a = 'A';

char a = 65;

char a = 0x41;

char a = 0x0041;

char a = '\u0041';

Le plus souvent, les gens indiquent simplement le caractère entre guillemets (comme dans la première ligne du tableau). Cela dit, cette dernière méthode est également populaire. Son avantage est qu'il peut être utilisé dans les cordes.

Et comme nous l'avons dit, le chartype est aussi un type entier, vous pouvez donc écrire quelque chose comme ceci :

char a = 'A';
a++;
System.out.println(a);

Travailler avec chars

Chacun charest d'abord un nombre (code de caractère), puis un caractère. Si vous connaissez un code de caractère, vous pouvez toujours obtenir le caractère dans votre programme. Exemple:

char c = (char) 1128;
System.out.println(c);

Ѩ

Codes standards

Voici les codes de caractères les plus connus :

6. booleantaper

Et le dernier type primitif est boolean.

Comme vous le savez déjà, il ne peut prendre que deux valeurs : trueet false.

Et avec ça, vous savez déjà tout ce qu'il y a à savoir sur ce type.