Types de données Java

Java est statiquement typé — chaque variable possède un type connu à la compilation. Les types se répartissent en deux familles : les primitifs (valeurs brutes intégrées au langage) et les types référence (objets, tableaux, tout ce qui est créé avec new). Ce chapitre passe en revue les deux.

Les huit types primitifs

Les primitifs sont les seules valeurs en Java qui ne sont pas des objets. Ils stockent leur valeur directement dans l'emplacement mémoire de la variable. Java en définit exactement huit :

Quelques points à mémoriser :

• int est le type entier par défaut. La plupart des compteurs et des index sont des int. Utilisez long uniquement lorsque vous avez réellement besoin de nombres supérieurs à ~2 milliards.
• double est le type virgule flottante par défaut. Un simple 3.14 est un double ; 3.14f est un float. Utilisez double sauf si la mémoire vous impose d'utiliser float.
• Les underscores dans les littéraux numériques améliorent la lisibilité : 1_000_000 est identique à 1000000.
• Les valeurs par défaut s'appliquent uniquement aux champs, pas aux variables locales. Une variable locale n'a pas de valeur par défaut — vous devez l'initialiser avant de la lire.

Types référence

Tout le reste — String, tableaux, vos propres classes, classes de bibliothèques — est un type référence. Une variable de type référence ne contient pas l'objet lui-même ; elle contient une référence (essentiellement un pointeur) vers l'objet sur le tas :

String name = "Ada";
int[] scores = new int[10];
LocalDate today = LocalDate.now();

La valeur par défaut de toute variable référence est null — une valeur spéciale signifiant « aucun objet ».

String s = null;
System.out.println(s.length());  // throws NullPointerException at runtime

null est à l'origine de l'une des erreurs d'exécution les plus courantes en Java. Le chapitre Java Exceptions explique comment gérer la NullPointerException qui en résulte.

Classes enveloppes

Chaque primitif possède une classe enveloppe correspondante — un véritable objet qui encapsule la valeur primitive :

Vous avez besoin des enveloppes lorsque vous souhaitez placer des primitifs dans des collections (qui ne contiennent que des objets) :

List<Integer> scores = new ArrayList<>();
scores.add(42);   // autoboxed from int → Integer
int first = scores.get(0);  // unboxed from Integer → int

Java convertit automatiquement entre les primitifs et leurs enveloppes — ce qu'on appelle l'autoboxing et l'unboxing — de sorte que la plupart du temps vous n'y prêtez pas attention.

Note sur String

String est un type référence, pas un primitif. Il est suffisamment spécial pour que le langage lui offre une syntaxe littérale ("texte") et l'opérateur +. Les chaînes sont immuables — une fois créées, leur contenu ne change jamais. Toute « modification » renvoie une nouvelle chaîne. Le chapitre Java Strings entre dans les détails.

Choisir un type

Un arbre de décision rapide pour le Java quotidien :

• Compter des éléments ou indexer un tableau → int
• Grands compteurs (tailles de fichiers, horodatages en millisecondes) → long
• Montants monétaires → BigDecimal (pas double — l'arrondi en virgule flottante vous jouera des tours)
• Caractère unique → char
• Oui/non → boolean
• Texte → String
• Date ou heure → types de java.time (LocalDate, Instant, Duration)

Résistez à l'envie d'« économiser de la mémoire » en utilisant byte ou short pour des entiers ordinaires. Les JVM sont optimisées pour les opérations sur int ; short n'utilise pas réellement moins de mémoire dans la plupart des cas.

Pièges courants

Certains comportements de types surprennent régulièrement les débutants. Les connaître à l'avance permet d'économiser des heures de débogage.

Le débordement d'entier est silencieux

L'arithmétique entière en Java ne lève jamais d'exception en cas de débordement — elle revient à zéro. Ajouter 1 au plus grand int produit le plus petit int :

int max = Integer.MAX_VALUE;   // 2147483647
System.out.println(max + 1);   // -2147483648

Si une valeur risque de dépasser ~2,1 milliards, utilisez long. Pour des compteurs qui pourraient déborder même un long, recourez à BigInteger.

La virgule flottante n'est pas exacte

float et double suivent la norme IEEE 754, qui ne peut pas représenter exactement la plupart des fractions décimales. L'exemple classique :

System.out.println(0.1 + 0.2);   // 0.30000000000000004

C'est pourquoi vous ne devez jamais utiliser double pour les montants monétaires. Utilisez BigDecimal (construit à partir d'une String, par exemple new BigDecimal("0.1")) lorsque des valeurs décimales exactes sont nécessaires.

char est un nombre

Un char est un entier non signé de 16 bits contenant une unité de code Unicode, il participe donc à l'arithmétique :

char a = 'A';
System.out.println((int) a);   // 65
System.out.println((char) (a + 1));  // B

Comparer les enveloppes avec .equals(), pas ==

== sur des objets enveloppes compare les références, pas les valeurs. En raison d'un cache d'autoboxing pour les petites valeurs Integer (-128 à 127), == semble fonctionner pour les petits nombres puis échoue pour les grands :

Integer a = 127, b = 127;
System.out.println(a == b);   // true  (cached)
Integer c = 128, d = 128;
System.out.println(c == d);   // false (different objects)
System.out.println(c.equals(d));  // true  (compares values)

Utilisez toujours .equals() pour comparer les valeurs enveloppes. Consultez Java Type Casting pour les règles de conversion entre ces types.

Démonstration pratique

Prochaine étape

Java Type Casting montre comment convertir entre types numériques et entre types référence liés.

Pratique