Java, comparando los valores de BigInteger

BigInteger bigInteger = ...; 


if(bigInteger.longValue() > 0) { //original code 
    //bigger than 0 
} 

//should I change to this? 
if(bigInteger.compareTo(BigInteger.valueOf(0)) == 1) { 
    //bigger than 0 
}

Necesito comparar algunos valores de BigInteger arbitarios. Me pregunto cuál es el enfoque correcto. Dado el código anterior, ¿cuál debería usarse? El código original está en la parte superior. Estoy pensando en cambiarlo al segundo enfoque.Java, comparando los valores de BigInteger

Fuente

2010-11-04 Rosdi Kasim

El primer enfoque es erróneo si quiere probar si el tiene un valor BigInteger Postive: longValue simplemente devuelve el bajo pedido 64 bits que puede revertir el signo .. . Entonces la prueba podría fallar para un BigInteger positivo.

El segundo enfoque es mejor (ver Bozhos answer para una optimización).

Otra alternativa: BigInteger#signum vuelve 1 si el valor es positivo:

if (bigInteger.signum() == 1) { 
// bigger than 0 
}

Fuente

2010-11-04 08:52:22

gracias por la sugerencia, pero quieres decir 'más grande que 0' verdad? Acabo de criticar ...: p –

+12

@Rosdi - seguro, "que". Somatimas tha 'e' end tha 'a' kay chenga plecas en mi kayboerd ;-) –

Si está utilizando BigInteger, esto supone que necesita números mayores que long puede manejar. Entonces no use longValue(). Use compareTo. Con tu ejemplo es mejor que sea:

if (bigInteger.compareTo(BigInteger.ZERO) > 0) { 

}

Fuente

2010-11-04 08:51:58 Bozho

Verdadero (1), pero la salida de '> 0', no' == 1' (véase mi respuesta) –

@seanizer - acaba de arreglar eso, y 1 a su respuesta para los que. – Bozho

Esto no es una respuesta directa, pero una nota importante sobre el uso de compareTo().

Al verificar el valor de compareTo(), siempre pruebe para x < 0, x > 0 y x == 0.
NO probar x == 1

De los Comparable.compareTo() javadocs:

compara este objeto con el objeto especificado por el orden. Devuelve un entero negativo, cero o un entero positivo ya que este objeto es menor, igual o mayor que el objeto especificado.

Nota:

A negative integer, no -1.
A positive integer, no 1.

Es cierto que la comprobación de ==1 y ==-1 funcionaría para BigInteger. Este es el código BigInteger.compareTo():

public int compareTo(BigInteger val) { 
    if (signum == val.signum) { 
     switch (signum) { 
     case 1: 
      return compareMagnitude(val); 
     case -1: 
      return val.compareMagnitude(this); 
     default: 
      return 0; 
     } 
    } 
    return signum > val.signum ? 1 : -1; 
}

Pero sigue siendo mala práctica, y recomienda explícitamente en contra de la JavaDocs:

compara esta BigInteger con el BigInteger especificado. Este método se proporciona con preferencia a los métodos individuales para cada uno de los seis operadores de comparación booleanos (<, ==,>,> =,! =, < =). El modismo sugerido para realizar estas comparaciones es: (x.compareTo(y) <op> 0), donde <op> es uno de los seis operadores de comparación.

Fuente

2010-11-04 09:09:37

La especificación para 'BigInteger.compareTo()' dice explícitamente '-1, 0 y 1', pero no estoy de acuerdo con' x < 0', 'x == 0',' x> 0' se siente más intuitivo en lugar de 'x == -1',' x == 0', 'x == 1'. –

@Rosdi pero también dice * El modismo sugerido para realizar estas comparaciones es: ('x.compareTo (y) 0'), donde' 'es uno de los seis operadores de comparación. * –

Java, comparando los valores de BigInteger

Respuesta

Cuestiones relacionadas