La pratique habituelle consiste à utiliser les primitives, à moins que vous n'utilisiez des génériques (assurez-vous que vous êtes au courant de l' autoboxing et de la déballage !).
Il y a plusieurs bonnes raisons de suivre la convention:
1. Vous évitez les erreurs simples:
Il existe des cas subtils et non intuitifs qui attrapent souvent les débutants. Même des codeurs expérimentés font des erreurs et font parfois ces erreurs (j'espère que cela sera suivi de jurons quand ils débogueront le code et trouveront l'erreur!).
L’erreur la plus courante est d’utiliser a == bau lieu de a.equals(b). Les gens sont habitués à utiliser des a == bprimitives, alors vous pouvez le faire facilement lorsque vous utilisez les wrappers d’objets.
Integer a = new Integer(2);
Integer b = new Integer(2);
if (a == b) { // Should be a.equals(b)
// This never gets executed.
}
Integer c = Integer.valueOf(2);
Integer d = Integer.valueOf(2);
if (c == d) { // Should be a.equals(b), but happens to work with these particular values!
// This will get executed
}
Integer e = 1000;
Integer f = 1000;
if (e == f) { // Should be a.equals(b)
// Whether this gets executed depends on which compiler you use!
}
2. Lisibilité:
Considérez les deux exemples suivants. La plupart des gens diraient que la seconde est plus lisible.
Integer a = 2;
Integer b = 2;
if (!a.equals(b)) {
// ...
}
int c = 2;
int d = 2;
if (c != d) {
// ...
}
3. Performance:
Le fait est qu'il est plus lent d'utiliser les wrappers d'objet pour les primitives que de simplement utiliser les primitives. Vous ajoutez le coût de l'instanciation d'objet, des appels de méthode, etc. aux éléments que vous utilisez partout .
Knuth "... disons environ 97% du temps: l'optimisation prématurée est la racine de tout le mal" citation ne s'applique pas vraiment ici. Il parlait Optimisations qui rend plus compliqué le code (ou système) - si vous êtes d' accord avec le point # 2, ceci est une optimisation qui rend le code moins compliqué!
4. C'est la convention:
Si vous faites des choix stylistiques différents pour 99% des autres programmeurs Java, il y a 2 inconvénients:
- Vous trouverez le code des autres personnes plus difficile à lire. 99% des exemples / tutoriels / etc utilisera des primitives. Chaque fois que vous en lirez un, vous aurez le surcroît de travail cognitif de penser à la manière dont cela ressemblerait dans le style auquel vous êtes habitué.
- D'autres personnes trouveront votre code plus difficile à lire. Chaque fois que vous posez des questions sur le dépassement de pile, vous devrez passer au crible les réponses / commentaires en demandant "pourquoi n'utilisez-vous pas de primitives?". Si vous ne me croyez pas, il suffit de regarder les batailles que les gens ont sur des choses comme le placement des crochets, qui n'affectent même pas le code généré!
Normalement, je listerais quelques contre-points, mais honnêtement, je ne vois aucune bonne raison de ne pas aller à la convention ici!