Pregunta

Necesito crear un objeto de transferencia de datos, que usaré para almacenar los registros recuperados de la base de datos. En este objeto de transferencia de datos, necesito declarar un campo numérico. Para eso, uno es mejor: int o Ingeniero

Si estoy definiendo el campo como Integer, ¿habrá algún impacto en el rendimiento debido al tipo 'Integer' si voy a recuperar más de 2000 registros de DB ??

Gracias de antemano.

¿Fue útil?

Solución

Integer es una mejor opción, ya que puede manejar null ; para int , null se convertiría en 0 , silenciosamente, si se utiliza resultSet.getInt (..) . De lo contrario, podría lanzar alguna excepción, como por ejemplo, " No se puede establecer null en una propiedad primitiva " ;.

El rendimiento es de poca importancia aquí.

  • si elige int , terminará agregando un código de manejo adicional; y eso no te beneficiaría mucho. Su código no será limpio y directo, gran cantidad de código de placa de caldera, y ni siquiera obtendría el rendimiento.
  • déjame aclararlo, para las bases de datos, null no es lo mismo que cero. A veces terminas ingresando 0 , donde estaba destinado null . Imagine el caso en que el usuario envió un formulario y no proporciona ningún valor para int . Terminará obteniendo 0 de forma predeterminada. Tiene sentido, o lo hace de verdad, cuando ese campo está no nulo en la base de datos.

Otros consejos

Realmente debería tomar su decisión basándose en lo que necesita que haga su objeto, en lugar de los costos de rendimiento. Se debe tomar una decisión basada en el rendimiento, una vez que se haya identificado un problema de velocidad con un generador de perfiles: la raíz de todo mal y todo eso.

Observe algunas de las características de ambas y utilícelas para su decisión, por ejemplo,

  • Integer puede ser null , int no puede. Entonces, ¿el int en el DB es un campo Nullable ?
  • ¿Necesita acceso a los métodos de clase Integer ?
  • ¿Estás haciendo aritmética?

Personalmente, siempre opto por la primitiva sobre la envoltura. Pero eso es solo una cuestión de preferencia, en lugar de estar basado en cualquier mérito técnico.

En mi opinión, la elección entre declarar algo como int o Integer simplemente se reduce a si nulo es un valor válido para ello o no. Autoboxing (y autounboxing) se ocupará de cualquier problema de conversión donde el número simplemente debe ser de un tipo u otro. Es poco probable que el rendimiento (como se ha señalado) sea notable en casi todos los casos.

Además, int debería ser la elección natural, y es probable que tenga el mejor rendimiento si ese es un problema de todos modos. Si necesita poder almacenar valores nulos, debe utilizar Integer (y también asegurarse de que no haya referencias nulas autocontenidas para un método que se ejecuta simplemente, ya que esto dará lugar a una excepción NullPointerException) .

Integer es teóricamente más lento que int , sin embargo, el impacto en el rendimiento debería ser mínimo, a menos que esté procesando números. Además, las optimizaciones JIT reducirán la pérdida de rendimiento.

Utilice el que mejor se adapte a su situación en términos de tipo primitivo o de referencia.

int es 10 veces más rápido que un entero

probamos este código con la biblioteca de rendimiento de jetm 

int n;
EtmPoint point1 = etmMonitor.createPoint("test:objects");
for (n = 0; n < 1000000; n++) {
    Integer t = 0;
    t = 10;
    t = 11;
}

point1.collect();
EtmPoint point = etmMonitor.createPoint("test:primitives");
for (n = 0; n < 1000000; n++) {
    int t = 0;
    t = 10;
    t = 11;
}
point.collect();

etmMonitor.render(new SimpleTextRenderer());

y los resultados:
prueba: objetos 10.184
prueba: primitivas 1.151

Para darle una idea, 2000 Integer agregaría aproximadamente 0,5 ms a su consulta. Si tiene que serializar estos datos, podría agregar un poco más.

Sin embargo, la corrección debe ser lo primero. No tiene sentido ser muy rápido sino equivocado. Tienes que tener en cuenta los valores nulos y cómo manejarlos. (A menos que la columna NO sea NULA) Puede usar Integer.MIN ___ VALUE o puede usar un campo largo en lugar de int y usar Long.MIN_VALUE para nulo. Aunque es más grande que int, todavía sería mucho más pequeño y más eficiente que Integer.

Supongo que depende, entre otras cosas, de lo que esté usando para acceder a la base de datos. Con el antiguo JDBC, podría hacer con int s, mientras que un ORM podría convertirlos de forma silenciosa en enteros de todos modos. Y Integer le permitiría manejar nulos .

int es utilizado por java para la mayoría de los cálculos. Integer se utiliza en todas las formas de colecciones, excepto para matrices primitivas.

Usando muchos enteros temporales con Thrash el recolector de basura y el uso de CPU no funcional en segundo plano que causará una desaceleración general en todo. Demasiados temporarios destruidos por segundo causarán que el CG entre en emergencia " Necesito memoria ahora " Modo que puede causar bloqueos en aplicaciones críticas de latencia (por ejemplo: gráficos interactivos en tiempo real, controladores de dispositivos físicos o comunicaciones)

Entonces, para mí, si tengo muchas llamadas anidadas que no hacen cálculos matemáticos pero que acceden a muchas colecciones, como el uso de teclas para mapas, uso Integer para evitar toneladas de boxeo automático cuando se pasan los argumentos.

Si las operaciones son intensivas en matemáticas o se usan como contadores de bucle u otras operaciones orientadas a las matemáticas y no se almacenan en colecciones (que no sean matrices primitivas), uso la primitiva. Lo mismo se aplica a todas las demás primitivas, excepto a String, que es un objeto de pleno derecho.

int no se puede convertir al String con el uso de toString o (String) .

Integer se puede convertir a String con toString o (String) y puede manejar null .

Si desea verificar un valor de null , entonces lo mejor es Integer , pero si desea comparar el número entero, int puede ser mejor. En el siguiente ejemplo, estoy usando el entero c = 1000 y d = 1000 y lo comparo, devuelve false pero en caso de int, devolverá true. 

public class IntegerCompare {

    public static void main(String[] args) {
        int a = 1000;
        int b = 1000;

        Integer c = 1000;
        Integer d = 1000;

        if (a == b) {
            System.out.println("int Value Equals");

        }
        if (c == d) {
            System.out.println("Integer value Equals");

        } else {

            System.out.println("Integer Value Not Equals");
        }
    }
}

Un escenario a cubrir sería la validación.

Imagina que tenemos la siguiente clase: 

class Foo{
    @Min(value = 10)
    int val;
}

Si el usuario no proporciona un valor para val en la solicitud, obtendremos una desagradable NumberFormatException .

Si int se reemplaza por Integer , podemos usar @NotNull y resolver este problema con más gracia.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top