Les applications Java contiennent deux types de données : les types primitifs et les types référence. Dans cette section, nous allons discuter des différences entre un type primitif et un type référence.
Utilisation des Types Primitifs
Java possède huit types de données intégrés, appelés types primitifs Java. Ces huit types de données représentent les éléments de base des objets Java, car tous les objets Java ne sont qu’une collection complexe de ces types primitifs. Cela dit, un primitif n’est pas un objet en Java et ne représente pas non plus un objet. Un primitif n’est qu’une seule valeur en mémoire, comme un nombre ou un caractère.
Les Types Primitifs
Voici les types primitifs Java avec leur taille en bits et la plage de valeurs que chacun peut contenir.
| Mot-clé | Type | Valeur minimale | Valeur maximale | Valeur par défaut | Exemple |
|---|---|---|---|---|---|
| boolean | vrai ou faux | n/a | n/a | false | true |
| byte | valeur intégrale 8-bit | -128 | 127 | 0 | 123 |
| short | valeur intégrale 16-bit | -32,768 | 32,767 | 0 | 123 |
| int | valeur intégrale 32-bit | -2,147,483,648 | 2,147,483,647 | 0 | 123 |
| long | valeur intégrale 64-bit | -263 | 263 – 1 | 0L | 123L |
| float | valeur à virgule flottante 32-bit | n/a | n/a | 0.0f | 123.45f |
| double | valeur à virgule flottante 64-bit | n/a | n/a | 0.0 | 123.456 |
| char | valeur Unicode 16-bit | 0 | 65,535 | \u0000 | ‘a’ |
String est-il un Type Primitif ?
Non, ce n’est pas le cas. Cela dit, String est souvent confondu avec un neuvième primitif car Java inclut un support intégré pour les littéraux String et les opérateurs. Vous en apprendrez plus sur String plus tard, mais pour l’instant, rappelez-vous simplement que c’est un objet, pas un primitif.
Il y a beaucoup d’informations dans ce tableau. Voyons quelques points clés :
- Les types byte, short, int et long sont utilisés pour les valeurs entières sans décimales.
- Chaque type numérique utilise deux fois plus de bits que le type similaire plus petit. Par exemple, short utilise deux fois plus de bits que byte.
- Tous les types numériques sont signés et réservent un de leurs bits pour couvrir une plage négative. Par exemple, au lieu que byte couvre 0 à 255 (ou même 1 à 256), il couvre en réalité -128 à 127.
- Un float nécessite la lettre f ou F après le nombre pour que Java sache que c’est un float. Sans f ou F, Java interprète une valeur décimale comme un double.
- Un long nécessite la lettre l ou L après le nombre pour que Java sache que c’est un long. Sans l ou L, Java interprète un nombre sans point décimal comme un int dans la plupart des scénarios.
Signed et Unsigned : short et char
Il est important de noter que short et char sont étroitement liés, car tous deux sont stockés comme types intégraux avec la même longueur de 16 bits. La différence principale est que short est signé, ce qui signifie qu’il répartit sa plage entre les entiers positifs et négatifs. En revanche, char est non signé, ce qui signifie que sa plage est strictement positive, y compris 0.
Souvent, les valeurs short et char peuvent être converties l’une en l’autre car la taille des données sous-jacente est la même.
Écriture des Littéraux
Il y a quelques choses supplémentaires que vous devriez savoir sur les primitifs numériques. Lorsqu’un nombre est présent dans le code, on l’appelle un littéral. Par défaut, Java suppose que vous définissez une valeur int avec un littéral numérique. Dans l’exemple suivant, le nombre est plus grand que ce qui peut tenir dans un int :
long nombreMax = 3123456789; // NE COMPILE PASJava se plaint que le nombre est hors limites. Et il l’est — pour un int. Cependant, nous n’avons pas un int. La solution est d’ajouter le caractère L au nombre :
long nombreMax = 3123456789L; // Maintenant Java sait que c'est un longAlternativement, vous pourriez ajouter un l minuscule au nombre. Mais utilisez de préférence le L majuscule. Le l minuscule ressemble trop au chiffre 1.
Création des Classes Wrapper
Chaque type primitif possède une classe wrapper, qui est un type objet correspondant au primitif. Le tableau suivant liste toutes les classes wrapper avec leur méthode de création.
| Type primitif | Classe wrapper | Hérite de Number ? | Exemple de création |
|---|---|---|---|
| boolean | Boolean | Non | Boolean.valueOf(true) |
| byte | Byte | Oui | Byte.valueOf((byte) 1) |
| short | Short | Oui | Short.valueOf((short) 1) |
| int | Integer | Oui | Integer.valueOf(1) |
| long | Long | Oui | Long.valueOf(1) |
| float | Float | Oui | Float.valueOf((float) 1.0) |
| double | Double | Oui | Double.valueOf(1.0) |
| char | Character | Non | Character.valueOf(‘c’) |
Il existe également une variante de valueOf() qui convertit une chaîne de caractères (String) en classe wrapper. Par exemple :
int primitif = Integer.parseInt("123");
Integer wrapper = Integer.valueOf("123");La première ligne convertit une String en primitive int. La seconde convertit une String en classe wrapper Integer.
Toutes les classes numériques du tableau héritent de la classe Number, ce qui signifie qu’elles disposent de méthodes utilitaires : byteValue(), shortValue(), intValue(), longValue(), floatValue(), et doubleValue(). Les classes wrapper Boolean et Character incluent respectivement booleanValue() et charValue().
Comme vous pouvez le deviner, ces méthodes renvoient la valeur primitive d’une instance wrapper, dans le type demandé.
Double pomme = Double.valueOf("200.99");
System.out.println(pomme.byteValue()); // -56
System.out.println(pomme.intValue()); // 200
System.out.println(pomme.doubleValue()); // 200.99Ces méthodes utilitaires font de leur mieux pour convertir les valeurs mais peuvent entraîner une perte de précision. Dans le premier exemple, il n’y a pas de 200 en byte, donc il revient à -56. Dans le deuxième exemple, la valeur est tronquée, ce qui signifie que tous les chiffres après la décimale sont supprimés.
Certaines classes wrapper contiennent des méthodes utilitaires supplémentaires pour travailler avec les nombres. Par exemple, Integer propose :
- max(int num1, int num2) : renvoie le plus grand des deux nombres
- min(int num1, int num2) : renvoie le plus petit des deux nombres
- sum(int num1, int num2) : additionne les deux nombres
Définition des Blocs de Texte
Plus tôt, nous avons vu une simple String avec la valeur “bonjour”. Que faire si nous voulons avoir une String avec quelque chose de plus complexe ? Par exemple, voyons comment créer une String avec cette valeur :
"Guide Java"
par Marie & ThomasPour construire ceci comme une String, nous devons utiliser deux éléments que vous n’avez pas encore appris. La syntaxe \” vous permet d’inclure un ” dans la String, et \n indique que vous voulez une nouvelle ligne.
Ces deux éléments sont appelés caractères d’échappement car le backslash leur donne une signification spéciale. Avec ces deux nouvelles compétences, nous pouvons écrire :
String textTest = "\"Guide Java\"\n par Marie & Thomas";Bien que cela fonctionne, c’est difficile à lire. Heureusement, Java dispose des blocs de texte, également connus sous le nom de chaînes multiligne.
Un bloc de texte commence et se termine par trois guillemets (“””), et le contenu n’a pas besoin d’être échappé. C’est beaucoup plus facile à lire. Notez que le type reste String. Cela signifie que toutes les méthodes que vous utiliserez pour String fonctionnent aussi bien pour un bloc de texte normal.
Vous avez peut-être remarqué les termes espaces incidents et espaces essentiels. Qu’est-ce que c’est ? L’espace essentiel fait partie de votre String et est important pour vous. L’espace incident est simplement là pour rendre le code plus facile à lire.
Imaginez une ligne verticale tracée sur le caractère non-espace le plus à gauche de votre bloc de texte. Tout ce qui est à gauche est un espace incident, et tout ce qui est à droite est un espace essentiel. Essayons un exemple. Combien de lignes cette sortie produit-elle, et combien de caractères d’espace incidents et essentiels commencent chaque ligne ?
String pyramide = """
*
* *
* * *
""";Il y a quatre lignes de sortie. Les lignes ont des étoiles. La dernière ligne est une ligne sans caractères. Les “”” de fermeture auraient dû être sur la ligne avec les étoiles si nous ne voulions pas cette ligne vide. Il n’y a pas de caractères d’espace incidents ici. Les “”” de fermeture sont les caractères les plus à gauche, donc la ligne est tracée à la position la plus à gauche. La première ligne a deux caractères d’espace essentiels, et la deuxième ligne en a un.
| Formatage | Signification dans String normale | Signification dans bloc de texte |
|---|---|---|
| \” | “ | “ |
| \””” | n/a – Invalid | “”” |
| \”\”\” | “”” | “”” |
| Espace (en fin de ligne) | Espace | Ignoré |
| \s | Deux espaces (\s est un espace et préserve l’espace initial sur la ligne) | Deux espaces |
| \ (en fin de ligne) | n/a – Invalid | Supprime la nouvelle ligne sur cette ligne |
Essayons quelques exemples. D’abord, voyez-vous pourquoi ceci ne compile pas ?
String bloc = """chat"""; // NE COMPILE PASLes blocs de texte nécessitent un saut de ligne après les “”” d’ouverture, ce qui rend celui-ci invalide. Maintenant, essayons-en un valide. Combien de lignes pensez-vous qu’il y a dans ce bloc de texte ?
String bloc = """
chat \
chien""";Une seule. La sortie est “chat chien” car le \ indique à Java de ne pas ajouter de nouvelle ligne avant chien. Essayons de déterminer le nombre de lignes dans un autre bloc de texte :
String bloc = """
chat \n
chien
""";Cette fois, nous avons quatre lignes. Puisque le bloc de texte a les “”” de fermeture sur une ligne séparée, nous avons trois lignes pour les lignes dans le bloc de texte plus le \n explicite. Essayons-en un dernier. Que pensez-vous que ceci affiche ?
String bloc = """
"chat\"\"\"
\"chien\"""
""";La réponse est :
"chat"""
"chien"""
Tous les \” échappent les “. Il y a un espace d’espace essentiel sur les lignes chat et chien. Tout autre espace initial est un espace incident.