confronto valore intero

Question

Sono un novizio Java coder e ho appena letto una variabile di una classe intero può essere descritto in tre modi diversi nelle API. Ho il seguente codice:

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

Questo è all'interno di un ciclo e appena uscite out_table.
Il mio obiettivo è quello di capire come vedere se il valore in count > 0 intero.

Mi rendo conto che il count.compare(0) è il modo corretto? o è count.equals(0)?

So che il count == 0 non è corretto. È giusto? Esiste un operatore di confronto il valore in cui il suo solo count=0?

Answer 1

I numeri interi vengono autounboxed, in modo da poter fare solo

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

Answer 2

Per capire se un Integer è maggiore di 0, è possibile:

• controllare se compareTo(O) restituisce un numero positivo:

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

  Ma che sembra abbastanza sciocco, non è vero? Meglio solo ...

• autoboxing < sup> 1 :

  if (count > 0)
      ....
  

  Questo è equivalente a:

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

  E 'importante notare che "==" viene valutato in questo modo, con l'operando Integer unboxed piuttosto che l'operando int inscatolato. In caso contrario, sarebbe tornato count == 0 false quando count è stato inizializzato come new Integer(0) (perché i test "==" per l'uguaglianza di riferimento).

¹ Tecnicamente, il primo esempio utilizza autoboxing (prima di Java 1.5 non si poteva passare un int a compareTo) e il secondo esempio utilizza unboxing . La funzione combinata è spesso chiamato semplicemente "autoboxing" in breve, che spesso è poi esteso a chiamare entrambi i tipi di conversioni "autoboxing". Mi scuso per il mio uso lassista della terminologia.

Answer 3

E 'meglio evitare inutili autoboxing per 2 motivi.

Per prima cosa, è un po 'più lento di int < int, come si è (a volte) la creazione di un oggetto in più;

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

Il problema più grande è che autoboxing nascosta può nascondere eccezioni:

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

La chiamata di questo metodo con null lancerà una NullPointerException.

La ripartizione tra primitive e oggetti wrapper java è sempre stata descritta come un kludge per la velocità. Autoboxing quasi nasconde questo, ma non del tutto - è più pulita solo per tenere traccia del tipo. Quindi, se hai un oggetto Integer, si può chiamare compare() o intValue(), e se hai il primitivo basta controllare direttamente il valore.

Answer 4

È inoltre possibile utilizzare uguale:

 Integer a = 0;

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

che è equivalente a:

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

ed anche:

 if (a == 0) {

 }

(il compilatore Java aggiunge automaticamente intValue ())

Si noti che autoboxing / autounboxing può introdurre un overhead significativo (specialmente loop all'interno).

Answer 5

Anche se si potrebbe certamente utilizzare il metodo compareTo su un'istanza Integer, non è chiaro quando la lettura del codice, quindi probabilmente si dovrebbe evitare di farlo.

Java consente di utilizzare autoboxing (vedi http : //java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html ) per confrontare direttamente con un int, in modo da poter fare:

if (count > 0) { }

E il Integer esempio count viene automaticamente convertita in un int per il confronto.

Se hai difficoltà a capire questo, controllare il link qui sopra, o immagina che sta facendo questo:

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

Answer 6

Una cosa da guardare fuori per è se il secondo valore è stato un altro oggetto Integer al posto di un letterale '0', l'operatore '==' confronta i puntatori all'oggetto e non auto-Unbox.

vale a dire:

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

bene che potrei essere in ritardo su questo, ma vorrei condividere qualcosa:

Dato l'ingresso:     System.out.println (isGreaterThanZero (-1));

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

I ritorni false

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

Restituisce true Quindi penso che in yourcase 'compareTo' sarà più preciso.