Java Primitives : tout sur le fonctionnement des types de données primitifs

Il existe en Java huit types de données primitives 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 individuels, des caractères ou des valeurs logiques. Les huit primitives Java sont boolean, byte, char, double, float, int, long et short.

Les primitives Java, explication

Comme dans d’autres langages de programmation, il existe en langage Java diffé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 interfaces. Parallèlement à cela, il existe en Java des types de données appelés primitives. Ils ont une taille fixe qui est identique sur toutes les plateformes. Ils disposent tous d’une classe wrapper (classe enveloppe) propre, sont intégrés de manière invariable et ont une plage de valeurs définie. Les primitives Java sont utilisées pour créer des variables qui contiennent des nombres, des caractères ou des valeurs logiques.

En langage Java, il existe huit types de données primitifs différents qui sont si fondamentaux que leur représentation est fermement ancrée dans le langage de programmation. Ils se distinguent 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’application respectifs sont au moins en partie similaires, les primitives en Java sont réparties en quatre catégories :

• 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 caractères (char)

Étant donné que les données sont stockées directement dans la stack (pile), leur taille respective peut être d’une importance capitale. Nous y reviendrons plus en détail par la suite. Mais les types de données primitifs sont aussi très importants 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 primitives Java :

boolean

La primitive Java Boolean est également connue comme valeur de vérité. C’est la plus simple des primitives 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écessaire et fait donc partie du groupe des types de données logiques. Dans les expressions, ses deux valeurs possibles représentent 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 automatiquement false. La primitive Boolean peut être utilisée avec des opérateurs Java booléens tels que AND et `OR. L’affectation 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 correspondent à 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 primitives 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 relativement peu gourmand en mémoire. Par ailleurs, la valeur du complément à deux est souvent utilisée pour des applications 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 correspondante :

14 + 3 = 17

long

long est une extension de int et peut contenir des valeurs numé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’indication obtenue :

47

float

Si vous souhaitez représenter des sous-ensembles de nombres rationnels, Java propose deux primitives 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 compilateur 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 totalement exacts. Une option alternative est la classe BigDecimal. Mais si double vous suffit, voici un exemple de code correspondant :

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 supplémentaire. En voici la sortie :

7.2252

char

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

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

L’indication obtenue est la suivante :

&