Lors de l'utilisation de primitives et quand les types de référence en Java
Dans quel cas faut-il utiliser les types primitifs(int
) ou des types de référence (Integer
)?
Ce question a suscité ma curiosité.
Vous devez vous connecter pour publier un commentaire.
Comme une règle du pouce, je vais utiliser une primitive (comme
int
), sauf si je dois utiliser une classe qui encapsule une primitive.L'un des cas ont été on doit utiliser une classe wrapper comme
Integer
est dans le cas de l'utilisation de les génériques, comme Java ne prend pas en charge l'utilisation de types primitifs comme les paramètres de type:Et, dans de nombreux cas, je vais profiter de l'autoboxing et unboxing, donc je n'ai pas explicitement d'effectuer des conversions de primitives pour sa classe wrapper et vice versa:
Aussi, comme une note complémentaire, lors de la conversion à partir des primitives pour l'emballage des objets de la classe, et les instances uniques d'objets ne sont pas nécessaires, utiliser le
valueOf
méthode prévue par le wrapper de méthode, il effectue la mise en cache et revenir par le même exemple, pour une certaine valeur, en réduisant le nombre d'objets qui sont créés:Pour plus d'informations sur le
valueOf
méthodes, la spécification de l'API pour laInteger.valueOf
méthode peut servir comme référence pour savoir comment ces méthodes se comportent dans les classes wrapper pour les primitives.Qui dépend vraiment du contexte. Premier préfère le primitif, parce que c'est plus intuitif et a moins de frais généraux. Si il n'est pas possible pour des génériques/l'autoboxing raisons, ou si vous voulez qu'il soit nullable, puis aller pour la wrapper type (type complexe comme vous l'appelez).
Les règles générales que j'ai suivi lors de la création d'une API peuvent être résumées comme suit:
Sur le #2, regarder dehors pour les Npe lorsque l'autoboxing. Si vous avez une méthode définie comme:
Et ensuite appeler comme suit:
Dans le cas où getValue() renvoie null, vous aurez une NPE sans cause évidente.
Depuis Java fait quelque chose appelé auto-boxing et de l'auto-unboxing, vous devez utiliser le type primitif
int
dans la plupart des cas en raison de moins de frais généraux.Le seul moment où vous devez absolument utiliser Entier est dans les génériques.
Ma règle d'or est: utiliser la boîte de primitives uniquement lorsque c'est nécessaire pour obtenir le code à compiler. Les seuls endroits dans votre code où le nom de la primitive classes wrapper devrait apparaître dans les paramètres de type générique et méthodes statiques:
C'est le conseil que je donnerais à de nouveaux programmeurs Java. Comme ils apprennent de plus, elles vous retrouvez dans des situations où ils doivent être plus éclairé, comme lorsque vous traitez avec des Cartes ou des bases de données, mais ils doivent aussi avoir une meilleure compréhension de la différence entre les primitives et encadré primitives.
L'autoboxing tente de nous faire croire
int
etInteger
(par exemple) sont interchangeables, mais c'est un piège. Si vous mélangez les deux sortes de valeur tort et à travers, vous pouvez vous retrouver de la comparaison de deux valeurs entières avec==
ou d'essayer de unbox unnull
sans s'en rendre compte. La résultante des bugs peuvent être intermittents et difficiles à repérer.Il n'aide pas que la comparaison de boîte primitives avec
==
parfois fonctionne comme si c'était de faire une comparaison de la valeur. C'est une illusion causée par le fait que les valeurs à l'intérieur d'une certaine plage sont automatiquement mises en cache dans le processus de l'autoboxing. C'est le même problème que nous avons toujours eu avec les valeurs de Chaîne: les comparant avec==
parfois "œuvres" parce que vous êtes en fait la comparaison de deux références pour le même, objet mis en cache.Lorsque vous traitez avec des cordes, on peut juste dire les n00bs jamais de les comparer avec
==
, comme nous l'avons fait tout au long de. Mais la comparaison entre les primitives avec==
est parfaitement valable; l'astuce (merci à l'autoboxing) est en train d'être sûr que les valeurs sont vraiment primitives. Le compilateur va maintenant nous allons déclarer une variable comme unInteger
et l'utiliser comme s'il s'agissait d'uneint
; cela signifie que nous avons à exercer un plus grand niveau de la discipline et de la traiter comme une erreur quand quelqu'un ne le faire sans une bonne raison.Plutôt que de les appeler "des types complexes", vous seriez mieux servi la pensée Integer, Double, etc. comme "Classes", et int, double, etc. comme "primitives".
Si vous faites n'importe quel type de mathématique sophistiqués, la Classe de base de la représentation numérique comme Entier et Double sera difficile et vous ralentir - de nombreuses opérations de calcul ne peut être fait avec les primitives.
D'autre part, si vous essayez de mettre vos numéros dans des collections comme les Listes et les Cartes, ces collections ne peut contenir que des objets - et donc vous devez utiliser (ou convertir) des classes comme Entier et Double.
Personnellement, j'utilise les primitives dès que je peux sortir avec elle, et de convertir de la Classe de représentations comme Entier quand il est temps de faire une entrée ou une sortie, et le transport a besoin de ces représentations.
Toutefois, si vous ne faites pas tout les maths à tous, et à la place, ce sont juste de passage les valeurs directement par le biais de votre code, vous pouvez vous épargner un peu de mal à en traitant avec la Classe de base des formes (comme Entier) exclusivement.
Je ne pense pas qu'il n'y a aucune règle en tant que telle. Je voudrais choisir les types primitifs (Entier plus int) quand j'écris des signatures de méthode, des Cartes, des collections, des Objets de Données qui se passait autour. En tant que tel que je voudrais encore utiliser Entier au lieu de int à l'intérieur même des méthodes, etc. Mais si vous pensez que c'est trop de problèmes (de type extra "eger"), alors il est normal d'utiliser des entiers pour les variables locales.
Si vous voulez setAttribute de session, vous devez utiliser l'Objet comme Integer,Boolean,String dans les servlets. Si vous souhaitez utiliser la valeur, vous pouvez utiliser les types primitifs. Les objets peuvent être null mais primitives pas. Et si vous voulez comparer les types de primitives d'utilisation == mais des objets d'utilisation .est égal parce que dans l'objet de comparaison == ne regarde pas les valeurs qu'il regarde si ce sont les mêmes objets. Et à l'aide de primitives rend plus rapide le code.
D'un cas dans lequel
Integer
pourrait être préféré, c'est quand vous travaillez avec une base de données où les entrées numériques sont autorisés à être nulle, puisque vous ne seriez pas en mesure de représenter une valeur nulle avec uneint
.Mais bien sûr, si vous faites tout droit de mathématiques, puis
int
serait mieux que d'autres ont mentionné en raison de l'intuitivité et moins de frais généraux.Je pense que c'est un peu tard, mais je voulais ajouter mon avis, juste au cas où.
dans certains scénarios, il est nécessaire d'utiliser les wrappers comme l'absence de valeur est différente de la valeur par défaut.
exemple,
pour un projet j'ai travaillé, il y avait un champ sur l'écran où l'utilisateur peut entrer une valeur double, les exigences de l'entreprise est clairement mentionné que si l'utilisateur entre un 0, le sens est différent de ne pas entrer une valeur et en laissant le champ vide et cette différence va avoir un impact plus tard dans un autre module.
donc, dans ce scénario, nous avons dû utiliser le Double objet, depuis je ne peut pas représenter un manque de valeur à l'aide de la primitive; depuis la primitive par défaut est 0, ce qui était une entrée valide pour le champ.