comparação valor inteiro

Question

Eu sou um novato programador Java e acabei de ler uma variável de uma classe inteira pode ser descrita de três maneiras diferentes na API. Eu tenho o seguinte código:

if (count.compareTo(0)) { 
            System.out.println(out_table);
            count++;
    }

Este é dentro de um loop e apenas out_table saídas.
Meu objetivo é descobrir como para ver se o valor em count > 0 inteiro.

Eu percebo o count.compare(0) é a maneira correta? ou é count.equals(0)?

Eu sei que o count == 0 está incorreto. Isto está certo? Existe um operador de comparação de valor onde apenas a sua count=0?

Answer 1

Os inteiros são autounboxed, então você pode apenas fazer

if (count > 0) {
    .... 
}

Answer 2

Para descobrir se um Integer é maior que 0, você pode:

• seleção se compareTo(O) retorna um número positivo:

  if (count.compareTo(0) > 0)
       ...
  

  Mas isso parece muito bobo, não é? Melhor só ...

• autoboxing < sup> 1 :

  if (count > 0)
      ....
  

  Isto é equivalente a:

  if (count.intValue() > 0)
      ...
  

  É importante notar que "==" é avaliada como esta, com o Integer operando desemoldurado vez do int operando em caixa. Caso contrário, count == 0 iria retornar false quando count foi inicializado como new Integer(0) (porque "==" testes de igualdade de referência).

¹ Tecnicamente, O primeiro exemplo usa autoboxing (antes de Java 1.5 você não poderia passar um int para compareTo) eo segundo exemplo usa unboxing . O recurso combinado é muitas vezes chamado simplesmente de "autoboxing" para breve, que é muitas vezes seguida, estendido para chamar os dois tipos de conversões "autoboxing". Peço desculpas por meu uso negligente de terminologia.

Answer 3

É melhor evitar autoboxing desnecessária por 2 motivos.

Por um lado, é um pouco mais lento do que int < int, como você está (por vezes) a criação de um objeto extra;

void doSomethingWith(Integer integerObject){ ...
  int i = 1000;
  doSomethingWith(i);//gets compiled into doSomethingWith(Integer.valueOf(i));

O problema maior é que autoboxing escondido pode esconder exceções:

void doSomethingWith (Integer count){
  if (count>0)  // gets compiled into count.intValue()>0

Chamar esse método com null irá lançar um NullPointerException.

A divisão entre primitivos e objetos de mensagens publicitárias em java foi sempre descrito como um remendo para a velocidade. Autoboxing quase esconde isso, mas não completamente - é limpo apenas para manter o controle do tipo. Então, se você tem um objeto Integer, você pode apenas chamar compare() ou intValue(), e se você tem o primitivo basta verificar o valor diretamente.

Answer 4

Você também pode usar iguais:

 Integer a = 0;

 if (a.equals(0)) {
     // a == 0
 }

o que equivale a:

 if (a.intValue() == 0) {
     // a == 0
 }

e também:

 if (a == 0) {

 }

(o compilador Java adiciona automaticamente intValue ())

Note-se que autoboxing / autounboxing pode introduzir uma sobrecarga significativa (especialmente dentro de loops).

Answer 5

Embora você certamente poderia usar o método compareTo em uma instância Integer, não é claro quando a leitura do código, então você provavelmente deve evitar fazê-lo.

Java permite que você use autoboxing (ver http : //java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html ) para comparar diretamente com um int, então você pode fazer:

if (count > 0) { }

E o Integer exemplo count é convertido automaticamente para um int para a comparação.

Se você está tendo dificuldade para entender isso, confira no link acima, ou imaginar que está fazendo isso:

if (count.intValue() > 0) { }

Answer 6

Mais uma coisa a observar é se o segundo valor era outro objeto Integer em vez de um literal '0', o '==' operador compara os ponteiros de objeto e não irá dar auto-unbox.

ou seja:

Integer a = new Integer(0);   
Integer b = new Integer(0);   
int c = 0;

boolean isSame_EqOperator = (a==b); //false!
boolean isSame_EqMethod = (a.equals(b)); //true
boolean isSame_EqAutoUnbox = ((a==c) && (a.equals(c)); //also true, because of auto-unbox

//Note: for initializing a and b, the Integer constructor 
// is called explicitly to avoid integer object caching 
// for the purpose of the example.
// Calling it explicitly ensures each integer is created 
// as a separate object as intended.
// Edited in response to comment by @nolith

Answer 7

Bem, eu poderia ser tarde sobre isso, mas eu gostaria de compartilhar algo:

Dada a entrada: System.out.printlnl (isGreaterThanZero (-1));

public static boolean isGreaterThanZero(Integer value) {
    return value == null?false:value.compareTo(0) > 0;
}

Retorna false

public static boolean isGreaterThanZero(Integer value) {
    return value == null?false:value.intValue() > 0;
}

Retorna true Então eu acho que em yourcase 'compareTo' será mais preciso.