La práctica estándar es ir con los primitivos, a menos que se trate de genéricos (¡asegúrese de conocer el autoboxing y unboxing !).
Hay varias buenas razones para seguir la convención:
1. Evitas errores simples:
Hay algunos casos sutiles, no intuitivos, que a menudo atrapan a los principiantes. Incluso los codificadores experimentados se equivocan y cometen estos errores a veces (¡espero que esto sea seguido de juramentos cuando depuran el código y encuentran el error!).
El error más común es usar en a == blugar de a.equals(b). La gente está acostumbrada a las a == bprimitivas, por lo que se hace fácilmente cuando se usan los contenedores de objetos.
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. Legibilidad:
Considere los siguientes dos ejemplos. La mayoría de la gente diría que el segundo es más legible.
Integer a = 2;
Integer b = 2;
if (!a.equals(b)) {
// ...
}
int c = 2;
int d = 2;
if (c != d) {
// ...
}
3. Rendimiento:
El hecho es que es más lento usar los contenedores de objetos para primitivas que solo usar las primitivas. Está agregando el costo de la creación de instancias de objetos, llamadas a métodos, etc. a cosas que usa en todo el lugar .
La cita de Knuth "... digamos alrededor del 97% del tiempo: la optimización prematura es la raíz de todo mal", en realidad no se aplica aquí. Estaba hablando de optimizaciones que hacen que el código (o sistema) sea más complicado: si está de acuerdo con el punto 2, ¡esta es una optimización que hace que el código sea menos complicado!
4. Es la convención:
Si realiza diferentes elecciones estilísticas para el 99% de los otros programadores de Java, hay 2 desventajas:
- Encontrará que el código de otras personas es más difícil de leer. El 99% de los ejemplos / tutoriales / etc. por ahí usarán primitivas. Cada vez que lea uno, tendrá la sobrecarga cognitiva adicional de pensar en cómo se vería en el estilo al que está acostumbrado.
- Otras personas encontrarán su código más difícil de leer. Siempre que haga preguntas sobre Stack Overflow, tendrá que examinar las respuestas / comentarios preguntando "¿por qué no está usando primitivas?". Si no me crees, solo mira las batallas que la gente tiene sobre cosas como la colocación de corchetes, ¡que ni siquiera afecta el código generado!
Normalmente, enumeraría algunos contrapuntos, pero honestamente no puedo pensar en ninguna buena razón para no ir con la convención aquí.