Types primitifs vs. Types primitifs compressés

• Types primitifs : int, double, booléen, etc.
• Types primitifs compressés : entier, double, booléen, etc.
• Java a un double système de types : les types primitifs et les types de référence (objets).
• Chaque type primitif a une classe wrapper correspondante.

Principales différences

• Identité vs. Valeur:
  Primitives : Elles n'ont aucune identité ; deux primitives de même valeur sont toujours égales.
  Emballés : Ce sont des objets et ont une identité ; deux objets peuvent avoir la même valeur mais des identités différentes.

• Valeurs nulles :
  Primitives : Ayez toujours une valeur par défaut (par exemple 0 pour int).
  Packed : Peut être nul, ce qui peut entraîner des exceptions NullPointerException s'il n'est pas géré correctement.

• Performance:
  Primitives : Plus efficaces en termes de temps et d'espace.
  Packaged : Introduire une surcharge due à la création d'objets supplémentaires.

Problèmes courants lors du mélange de primitives et de packages

• 1. Identité au lieu de comparaison de valeurs
• Lorsque vous comparez des objets emballés à l'aide de ==, vous comparez les références d'objets, pas les valeurs. Cela peut conduire à des résultats inattendus.

Exemple problématique :

Comparator naturalOrder = (i, j) -> (i 



Problème : La comparaison i == j compare les références, pas les valeurs.

Comportement incorrect : naturalOrder.compare(new Integer(42), new Integer(42)) renvoie 1 au lieu de 0.

Solution:

Utilisez la méthode compareTo ou les méthodes utilitaires de la classe Integer.


Comparator naturalOrder = Integer::compare;





Ou, en corrigeant le comparateur d'origine :


Comparator naturalOrder = (iBoxed, jBoxed) -> {
    int i = iBoxed;
    int j = jBoxed;
    return (i 



2. Déballage automatique et NullPointerException

Lors de l'utilisation de types compressés pouvant être nuls, le déballage automatique peut générer des exceptions si l'objet est nul.

Exemple problématique :


Integer i = null;
if (i == 42) {
    System.out.println("Inacreditável");
}





Problème : i est nul ; en comparaison avec 42, un déballage automatique nul se produit, ce qui entraîne NullPointerException.
Solution : Utilisez des types primitifs lorsque cela est possible.


int i = 0;
if (i == 42) {
    System.out.println("Inacreditável");
}





3. Performances dégradées en raison du boxing/déballage automatique

L'utilisation par inadvertance de types encapsulés dans des opérations intensives peut entraîner une dégradation des performances en raison du boxing automatique et de la création d'objets inutiles.

Exemple problématique :


Long sum = 0L;
for (long i = 0; i 



Problème : la somme est un Long emballé ; à chaque itération, un boxing/unboxing automatique se produit.

Impact : code beaucoup plus lent et utilisation excessive de la mémoire.
Solution:

Utilisez des types primitifs pour les variables locales dans les opérations intensives.


long sum = 0L;
for (long i = 0; i 



Quand utiliser les types packagés

Collections : vous ne pouvez pas utiliser de types primitifs dans les collections génériques (par exemple, List).
Paramètres génériques : les types génériques ne prennent pas en charge les types primitifs (par exemple ThreadLocal).
API nécessitant des objets : certaines API nécessitent des objets au lieu de types primitifs.
Bonnes pratiques

Préférez les types primitifs : dans la mesure du possible, utilisez des types primitifs pour plus de simplicité et d'efficacité.
Méfiez-vous de l'Autoboxing/Unboxing : l'Autoboxing réduit la verbosité mais peut introduire des erreurs subtiles.
Évitez les comparaisons avec == dans Wrapped : utilisez des méthodes comme equals() ou comparez les valeurs non enveloppées.
Vérifier les valeurs nulles : lorsque vous travaillez avec des types packagés, sachez qu'ils peuvent être nuls et provoquer une exception NullPointerException.
Résumé
Types primitifs :

Plus simple et plus rapide.

Ils ne peuvent pas être nuls.

Ils n'ont pas d'identité (seulement une valeur).

Types emballés :

Requis pour une utilisation dans les collections et les API génériques.

Ils peuvent être nuls.

Ils ont une identité d'objet.