Comparaison de la valeur entière

Question

Je suis un débutant codeur Java et je viens de lire une variable d'une classe entière peut être décrit trois façons différentes dans l'API. Je le code suivant:

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

Ceci est dans une boucle et produit juste out_table.
Mon objectif est de comprendre comment voir si la valeur count > 0 entier.

Je me rends compte de la count.compare(0) est la bonne façon? ou est-il count.equals(0)?

Je sais que le count == 0 est incorrect. Est-ce correct? Y at-il un opérateur de comparaison de valeur où son juste count=0?

Answer 1

Entiers sont autounboxed, vous pouvez juste faire

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

Answer 2

Pour savoir si un Integer est supérieur à 0, vous pouvez:

• vérifier si compareTo(O) retourne un nombre positif:

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

  Mais cela semble assez stupide, non? Mieux juste ...

• autoboxing < sup> 1 :

  if (count > 0)
      ....
  

  Ceci est équivalent à:

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

  Il est important de noter que « == » est évalué comme, avec l'opérande Integer Unboxed plutôt que l'opérande int boxed. Dans le cas contraire, count == 0 retournerait faux quand count a été initialisé comme new Integer(0) (parce que les tests de "==" pour l'égalité de référence).

¹ Techniquement, le premier exemple, on utilise autoboxing (avant Java 1.5, vous ne pouviez pas passer un int à compareTo) et le second exemple utilise unboxing . La fonction combinée est souvent appelé simplement « autoboxing » pour faire court, ce qui est souvent ensuite étendu en appelant les deux types de conversions « autoboxing ». Je présente mes excuses pour mon usage laxiste de la terminologie.

Answer 3

Il est préférable d'éviter autoboxing inutile pour 2 raisons.

D'une part, il est un peu plus lent que int < int, comme vous (parfois) la création d'un objet supplémentaire;

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

Le plus gros problème est que autoboxing caché peut cacher des exceptions:

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

L'appel de cette méthode avec null va lancer une NullPointerException.

La répartition entre les primitives et les objets wrapper en java a toujours été décrit comme une bidouille pour la vitesse. Autoboxing cache presque, mais pas tout à fait - il est plus propre juste pour garder une trace du type. Donc, si vous avez un objet entier, vous pouvez simplement appeler compare() ou intValue(), et si vous avez la primitive juste vérifier la valeur directement.

Answer 4

Vous pouvez également utiliser égal à:

 Integer a = 0;

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

qui est équivalent à:

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

et aussi:

 if (a == 0) {

 }

(le compilateur Java ajoute automatiquement intValue ())

Notez que autoboxing / autounboxing peut introduire une surcharge significative (en particulier les boucles à l'intérieur).

Answer 5

Bien que vous pouvez certainement utiliser la méthode compareTo sur une instance Integer, ce n'est pas clair lors de la lecture du code, alors vous devriez probablement éviter de le faire.

Java vous permet d'utiliser autoboxing (voir http : //java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html) pour comparer directement avec un entier, de sorte que vous pouvez faire:

if (count > 0) { }

Et le Integer d'instance count est converti automatiquement à un int pour la comparaison.

Si vous éprouvez des difficultés à comprendre cela, consultez le lien ci-dessus, ou imaginez qu'il fait ceci:

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

Answer 6

Une autre chose à surveiller est si la deuxième valeur est un objet entier au lieu d'un littéral « 0 », l'opérateur « == » compare les pointeurs d'objet et ne sera pas automatiquement Unbox.

-à-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

bien que je pourrais être en retard sur cela, mais je voudrais partager quelque chose:

Compte tenu de l'entrée:     System.out.println (isGreaterThanZero (-1));

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

false

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

Retourne true Je pense donc que dans yourcase « compareTo » sera plus précis.