primitivos - tipos de variables en java ejemplos
¿Debo nunca volver a utilizar tipos primitivos? (8)
El uso de los tipos encuadrados tiene problemas de rendimiento y memoria.
Al hacer comparaciones (p. Ej., (i == 10) ), Java debe destrabar el tipo antes de hacer la comparación. Incluso el uso de i.equals(TEN) usa una llamada a método, que es más costosa y (IMO) más fea que la sintaxis ==.
En la memoria Re, el objeto debe almacenarse en el montón (que también tiene un impacto en el rendimiento), así como almacenar el valor en sí mismo.
¿Un ladrón astuto? i.equals(j) cuando i.equals(j) null .
Siempre utilizo las primitivas, excepto cuando puede ser null , pero siempre verifico null antes de la comparación en esos casos.
Mezclar el uso de tipos de datos primitivos y sus respectivas clases contenedoras, en Java, puede provocar muchos errores. El siguiente ejemplo ilustra el problema:
int i = 4;
...
if (i == 10)
doStuff();
Más adelante, supondrá que desea que la variable i esté definida o indefinida, por lo que puede cambiar la instanciación anterior a:
Integer i = null;
Ahora la verificación de igualdad falla.
¿Es buena práctica de Java usar siempre las clases de envoltura primitiva? Obviamente, esto eliminaría algunos errores al principio, pero ¿cuáles son las desventajas de esto? ¿Afecta el rendimiento o la huella de memoria de la aplicación? ¿Hay algún truco furtivo?
En primer lugar, cambiar de usar una primitiva a usar un objeto solo para obtener la habilidad de establecerlo como nulo probablemente sea una mala decisión de diseño. A menudo tengo discusiones con mis compañeros de trabajo sobre si el nulo es un valor centinela, y mi opinión es que no lo es (y por lo tanto no debería estar prohibido como deberían ser los valores centinela), pero en este caso particular vas a ir fuera de tu camino para usarlo como un valor centinela. Por favor no. Cree un booleano que indique si su número entero es válido o cree un nuevo tipo que envuelva el booleano y el entero.
Por lo general, cuando uso versiones más nuevas de Java, me parece que no necesito crear o convertir explícitamente a las versiones de objeto de primitivas debido al soporte de auto-boxing que se agregó en algún momento en 1.5 (tal vez 1.5 en sí).
En su ejemplo, la instrucción if estará bien hasta que pase de 127 (ya que el autoboxing entero guardará en caché valores de hasta 127 y devolverá la misma instancia para cada número hasta este valor)
Entonces es peor de lo que presentas ...
if( i == 10 )
funcionará como antes, pero
if( i == 128 )
fallará. Es por razones como esta que siempre crea objetos explícitamente cuando los necesito, y si es posible, tiendo a adherirme a variables primitivas
Los tipos de Java POD están ahí por una razón. Además de la sobrecarga, no puedes hacer operaciones normales con objetos. Un entero es un objeto que debe asignarse y recolectarse. Un int no es.
Si ese valor puede estar vacío, puede encontrar que en su diseño necesita algo más.
Hay dos posibilidades: o bien el valor son solo datos (el código no actuará de manera diferente si está completado o no), o en realidad indica que tiene dos tipos de objetos diferentes aquí (el código actúa de manera diferente si existe). un valor que un nulo)
Si solo se trata de datos para mostrar / almacenar, puede considerar el uso de una DTO real, que no la tenga como miembro de primera clase. Esos generalmente tendrán una forma de verificar si se ha establecido un valor o no.
Si comprueba el nulo en algún momento, es posible que desee utilizar una subclase, porque cuando hay una diferencia, generalmente hay más. Al menos quieres una mejor manera de indicar tu diferencia que "si primitiveIntValue == null", eso realmente no significa nada.
Sugiero usar primitivos todo el tiempo a menos que realmente tengas el concepto de "nulo".
Sí, la VM hace autoboxing y todo eso ahora, pero puede llevar a casos realmente extraños en los que obtendrá una excepción de puntero nulo en una línea de código que realmente no espera, y debe comenzar a hacer comprobaciones nulas en cada operación matemática. También puede comenzar a obtener comportamientos no obvios si comienza a mezclar tipos y obtiene comportamientos de autoboxing extraños.
Para float / dobles puede tratar a NaN como nulo, pero recuerde que NaN! = NaN, por lo que todavía necesita verificaciones especiales como! Float.isNaN (x).
Sería realmente bueno si hubiera colecciones que soportaran los tipos primitivos en lugar de tener que perder el tiempo / sobrecarga del boxeo.
No cambie a no primitivos solo para obtener esta instalación. Use un booleano para indicar si el valor fue establecido o no. Si no le gusta esa solución y sabe que sus números enteros estarán dentro de un límite razonable (o no le importan las fallas ocasionales), use un valor específico para indicar ''no inicializado'', como Integer.MIN_VALUE. Pero esa es una solución mucho menos segura que la booleana.
Cuando llegaste a ese punto ''Más tarde'', se necesitó un poco más de trabajo durante la refactorización. Use primitivas cuando sea posible. (Período de capital) Luego haga POJO si se necesita más funcionalidad. Las clases de envoltura primitiva, en mi opinión, se utilizan mejor para los datos que necesitan viajar a través del cable, es decir, las aplicaciones en red. Permitir valores nulos como valores aceptables causa dolores de cabeza a medida que un sistema "crece". Hasta mucho código desperdiciado, o perdido, guardando lo que deberían ser comparaciones simples.