Élément Préférer les types primitifs aux types primitifs packagés

Types primitifs vs. Types primitifs empaquetés

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

Principales différences

• Identité contre. Valeur :
  Primitifs :Ils n'ont aucune identité ; deux primitives de même valeur sont toujours égales.
  Emballés :Ils 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).
  Emballé : Peut être nul, ce qui peut entraîner des exceptions NullPointerException s'il n'est pas géré correctement.

• Performances :
  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. Comparaison de l'identité au lieu de la valeur
• 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<Integer> naturalOrder = (i, j) -> (i < j) ? -1 : (i == j ? 0 : 1);

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<Integer> naturalOrder = Integer::compare;

Ou, en corrigeant le comparateur d'origine :

Comparator<Integer> naturalOrder = (iBoxed, jBoxed) -> {
    int i = iBoxed;
    int j = jBoxed;
    return (i < j) ? -1 : ((i == j) ? 0 : 1);
};

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 de l'Autoboxing/Unboxing
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 <= Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println(sum);

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 <= Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println(sum);

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é.
• Soyez prudent avec 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 aucune 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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!