Java Pri­mi­tives : tout sur le fonc­tion­ne­ment des types de données primitifs

Il existe en Java huit types de données pri­mi­tives qui ont une taille fixe et une plage de valeurs définie. Ils sont utilisés pour créer des variables et leur attribuer des nombres in­di­vi­duels, des ca­rac­tères ou des valeurs logiques. Les huit pri­mi­tives Java sont boolean, byte, char, double, float, int, long et short.

Les pri­mi­tives Java, ex­pli­ca­tion

Comme dans d’autres langages de pro­gram­ma­tion, il existe en langage Java dif­fé­rents types de données Java. Java distingue deux types : les types référence font référence à un objet qui peut être défini librement ; exemples, entre autres les strings, les arrays, les classes ou les in­ter­faces. Pa­ral­lè­le­ment à cela, il existe en Java des types de données appelés pri­mi­tives. Ils ont une taille fixe qui est identique sur toutes les pla­te­formes. Ils disposent tous d’une classe wrapper (classe enveloppe) propre, sont intégrés de manière in­va­riable et ont une plage de valeurs définie. Les pri­mi­tives Java sont utilisées pour créer des variables qui con­tien­nent des nombres, des ca­rac­tères ou des valeurs logiques.

En langage Java, il existe huit types de données primitifs dif­fé­rents qui sont si fon­da­men­taux que leur re­pré­sen­ta­tion est fermement ancrée dans le langage de pro­gram­ma­tion. Ils se dis­tin­guent surtout par les valeurs qu’ils stockent. Ils ont tous en commun de ne contenir qu’une seule valeur. Étant donné que leurs domaines d’ap­pli­ca­tion res­pec­tifs sont au moins en partie si­mi­laires, les pri­mi­tives en Java sont réparties en quatre ca­té­go­ries :

• Type de données logique (boolean)
• Type de données entier (byte, short, intet long)
• Type de données à virgule flottante (float et double)
• Type de données ca­rac­tères (char)

Étant donné que les données sont stockées di­rec­te­ment dans la stack (pile), leur taille res­pec­tive peut être d’une im­por­tance capitale. Nous y re­vien­drons plus en détail par la suite. Mais les types de données primitifs sont aussi très im­por­tants parce que Java est un langage à typage statique. Ainsi, lors de la création d’un programme, le type de données d’une variable doit déjà être connu et défini. C’est la seule façon d’exécuter le code sans message d’erreur. Voici un aperçu des pri­mi­tives Java :

boolean

La primitive Java Boolean est également connue comme valeur de vérité. C’est la plus simple des pri­mi­tives en langage Java, car elle ne connaît que deux valeurs possibles : true ou false. Il est utilisé lorsqu’un opérateur logique est né­ces­saire et fait donc partie du groupe des types de données logiques. Dans les ex­pres­sions, ses deux valeurs possibles re­pré­sen­tent souvent une condition qui est soit remplie (true), soit non remplie (false). Si vous n’attribuez pas de valeur à un booléen, celui-ci est au­to­ma­ti­que­ment false. La primitive Boolean peut être utilisée avec des opé­ra­teurs Java booléens tels que AND et `OR. L’af­fec­ta­tion se fait selon le principe suivant :

public class Main {
	public static void main(String[] args) {
		boolean x = true;
		System.out.println(x);
	}
}

Lorsque vous initiez une sortie avec la commande Java System.out.prinln, elle se présente ainsi :

true

byte

byte est la plus petite option de la catégorie des types de données entiers. Cette primitive a une plage de valeurs très limitée, de -128 à 127. En revanche, elle ne prend que 8 bits de mémoire. Elle doit son nom au fait que 8 bits cor­res­pon­dent à un byte (un octet). Si vous n’envisagez que des options de valeurs très limitées, déclarez byte comme suit :

public class Main {
	public static void main(String[] args) {
		byte x = 101;
		System.out.println(x);
	}
}

La sortie ressemble à ceci :

101

short

La primitive short est deux fois plus grande que byte et c’est sans doute pour cette raison qu’elle fait partie des pri­mi­tives Java qui sont rarement utilisées. Cependant, si byte est trop petit et int trop grand, ce type de données entier est une option. On la déclare ainsi :

public class Main {
	public static void main(String[] args) {
		short x = -27412;
		System.out.println(x);
	}
}

La sortie se présente ainsi :

-27412

int

int est le type de données entier le plus souvent utilisé. int a une très grande plage de valeurs tout en étant re­la­ti­ve­ment peu gourmand en mémoire. Par ailleurs, la valeur du com­plé­ment à deux est souvent utilisée pour des ap­pli­ca­tions plus élaborées. Voici comment l’utiliser :

public class Main {
	public static void main(String[] args) {
		int x = 14;
		int y = 3;
		int z = x + y;
		System.out.println(x + " + " + y + " = " + z);
	}
}

Voici la sortie cor­res­pon­dante :

14 + 3 = 17

long

long est une extension de int et peut contenir des valeurs nu­mé­riques encore plus grandes. Dans la plupart des cas, int devrait suffire, mais si vous souhaitez déclarer long, la syntaxe prend la forme suivante :

public class Main {
	public static void main(String[] args) {
		long x = 47;
		System.out.println(x);
	}
}

Voici l’in­di­ca­tion obtenue :

47

float

Si vous souhaitez re­pré­sen­ter des sous-ensembles de nombres ra­tion­nels, Java propose deux pri­mi­tives pour y parvenir. float est la plus petite primitive des deux types de données à virgule flottante et requiert 32 bits. Elle peut afficher jusqu’à sept décimales. Cependant, n’étant pas très précise, elle est rarement utilisée. Si vous en avez néanmoins besoin, déclarez-la ainsi :

public class Main {
	public static void main(String[] args) {
		float x = 7.22f;
		System.out.println(x);
	}
}

Un « f » en minuscule ou en majuscule est inséré après le nombre pour indiquer au com­pi­la­teur qu’il s’agit de float et non de double. La lettre n’apparaît pas dans le résultat :

7.22

double

Le deuxième type de données à virgule flottante est double. Bien que cette primitive soit beaucoup plus précise que float, elle ne permet pas d’obtenir des résultats to­ta­le­ment exacts. Une option al­ter­na­tive est la classe Big­De­ci­mal. Mais si double vous suffit, voici un exemple de code cor­res­pon­dant :

public class Main {
	public static void main(String[] args) {
		double x = 7.2252;
		System.out.println(x);
	}
}

Il est donc possible de renoncer au chiffre sup­plé­men­taire. En voici la sortie :

7.2252

char

La primitive char est utilisée pour re­pré­sen­ter un caractère du standard Unicode. Sa plage de valeur s’étend de ‘\u0000’ à ‘\uffff’, soit de 0 à 65535. Ce type de données ca­rac­tères peut ainsi re­pré­sen­ter presque tous les ca­rac­tères européens et asia­tiques. Chacun d’eux nécessite 16 bits de mémoire. En langage Java, les valeurs de cette primitive sont encadrées d’apos­trophes. Le code suit la syntaxe suivante :

public class Main {
	public static void main(String[] args) {
		char x = '&';
		System.out.println(x);
	}
}

L’in­di­ca­tion obtenue est la suivante :

&