Qual deles usar, int ou inteiro

StackOverflow https://stackoverflow.com/questions/423704

Pergunta

Preciso criar um objeto de transferência de dados, que usarei para armazenar os registros recuperados do banco de dados. Neste objeto de transferência de dados, preciso declarar um campo numérico. Para o que é melhor - int ou Inteiro

Se eu estiver definindo o campo como inteiro, haverá algum impacto de desempenho por causa do tipo 'inteiro' se eu vou recuperar mais de 2000 registros do banco de dados!?

Desde já, obrigado.

Foi útil?

Solução

Integer é uma opção melhor, pois pode lidar null; por int, null se tornaria 0, silenciosamente, se resultSet.getInt(..) é usado. Caso contrário, pode fazer alguma exceção, algo como "Incapaz de definir null para uma propriedade primitiva ".

O desempenho é pouca preocupação aqui.

  • Se você escolher int, você acabará adicionando código de manuseio extra; E isso não te beneficiaria muito. Seu código não será limpo e direto, muito código de placa da caldeira, e você nem sequer ganharia desempenho.
  • Deixe -me deixar claro, para bancos de dados, NULL não é o mesmo que zero. Às vezes você está entrando 0, Onde null foi pretendido. Imagine o caso em que o usuário enviou um formulário e não fornece nenhum valor para int. Você vai acabar recebendo 0 por padrão. Faz sentido, ou isso realmente, quando esse campo é not null no banco de dados.

Outras dicas

Você realmente deve tomar sua decisão com base- o que você precisa para fazer, em vez dos custos de desempenho. Decidir com base no desempenho deve ser feito, uma vez que uma questão de velocidade for identificada com um perfil - a raiz de todo o mal e tudo mais.

Veja alguns dos recursos de ambos e use isso para sua decisão, por exemplo,

  • Integer pode ser null, int não podes. O mesmo é o int no DB uma Nullable campo?
  • Você precisa de acesso ao Integer Métodos de classe?
  • Você está fazendo aritmética?

Pessoalmente, sempre opto pelo primitivo sobre o invólucro. Mas isso é apenas uma coisa de preferência, e não com base em qualquer mérito técnico.

Na minha opinião, a escolha entre declarar algo como int ou inteiro simplesmente se resume a se Null é um valor válido para ele ou não. O AutoBoxing (e o AutounBoxing) cuidarão de qualquer problema de conversão em que o número simplesmente deve ser um tipo ou outro. O desempenho (como foi apontado) também é improvável que seja notável em quase todos os casos.

Além disso, o INT deve ser a escolha natural e provavelmente será o mais desempenho, caso seja um problema de qualquer maneira. Se você precisa ser capaz de armazenar nulos, então você tenho Para usar o número inteiro (e também garantir que nenhuma referência nula seja unida automaticamente para um método que leva simplesmente o INTS, pois isso resultará em uma NullPointerException).

Integer é teoricamente mais lento do que int, no entanto, o impacto do desempenho deve ser mínimo, a menos que você esteja analisando números. Além disso, as otimizações do JIT reduzirão a perda de desempenho.

Use aquele que se adapta melhor à sua situação em termos de tipo primitivo ou de referência.

int é 10x mais rápido que o número inteiro

Testamos este código com a biblioteca de desempenho do 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());

e os resultados:
Teste: Objetos 10.184
Teste: Primitives 1.151

Para dar uma idéia, 2000 inteiro adicionaria cerca de 0,5 ms à sua consulta. Se você precisar serializar esses dados, ele poderá adicionar um pouco mais.

No entanto, a correção deve vir em primeiro lugar. Não faz sentido ser muito rápido, mas errado. Você deve considerar valores nulos e como lida com eles. (A menos que a coluna não seja nula), você pode usar o valor inteiro. ___ ou pode usar um grandes campo em vez de int e use long.min_value para nulo. Embora seja maior que o INT, ainda seria muitas vezes menor e mais eficiente que o número inteiro.

Eu acho que depende, entre outras coisas, do que você está usando para acessar o banco de dados. Com JDBC antigo e simples que você poderia fazer com ints, enquanto um ORM poderia convertê -los silenciosamente para Integers de qualquer forma. E o número inteiro permitiria que você lide nulas.

int é usado pelo Java para a maioria dos cálculos. Integer é usado em todas as formas de coleções, exceto por matrizes primitivas.

Usando muitos números inteiros temporários com o coletor de lixo e use CPU não desenvolvida em segundo plano que causará desacelerações gerais em tudo. Muitos temporários sendo destruídos por segundo farão com que o CG entre em emergência "Preciso de memória agora", que possa causar barracas em aplicações críticas de latência (ou seja: gráficos interativos em tempo real, controladores de dispositivos físicos ou comunicações)

Então, para mim, se eu tiver muitas chamadas aninhadas que não fazem matemática, mas acessem muitas coleções, como o uso de teclas para mapas, uso o número inteiro para evitar toneladas de boxe automático quando os argumentos são passados.

Se as operações forem intensivas em matemática ou usadas como contadores de loop ou outras operações orientadas para a matemática e não são armazenadas em coleções (além de matrizes primitivas), uso o primitivo. O mesmo vale para todas as outras primitivas, exceto a string, que é um objeto completo.

int não pode ser lançado para o String com o uso do toString ou (String).

Integer pode ser lançado para String com toString ou (String) E pode lidar null.

Se você quiser verificar se um null valor então Integer é o melhor, mas se você deseja comparar o número inteiro, o int pode ser melhor. No exemplo seguinte, estou usando o número inteiro C = 1000 e D = 1000 e compare -o retornar false, mas no caso de int, retornarão verdadeiros.

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");
        }
    }
}

Um cenário a ser coberto seria a validação.

Imagine que temos a seguinte aula:

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

Se o usuário não fornecer um valor para val No pedido, teremos um desagradável NumberFormatException.

Se int é substituído por Integer, podemos usar @NotNull e resolva esse problema de maneira mais graciosa.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top