java - subir - ¿Cómo convertir un doble a largo sin lanzar?

google play developer console

Question

¿Cuál es la mejor manera de convertir un doble a un largo sin lanzar?

Por ejemplo:

double d = 394.000;
long l = (new Double(d)).longValue();
System.out.println("double=" + d + ", long=" + l);

Answer 1

¿Quieres tener una conversión binaria como

double result = Double.longBitsToDouble(394.000d);

Answer 2

... Y aquí está el camino de redondeo que no trunca. Me apresuré a buscarlo en el Java API Manual:

double d = 1234.56;
long x = Math.round(d);

Answer 3

El enfoque preferido debería ser:

Double.valueOf(d).longValue()

De la documentación de Double (Java Platform SE 7) :

Double.valueOf(d)

Devuelve una instancia Double representa el valor double especificado. Si no se requiere una nueva instancia Double , este método generalmente se debe usar con preferencia al constructor Double(double) , ya que es probable que este método produzca un mejor rendimiento de espacio y tiempo al almacenar en caché los valores frecuentemente solicitados.

Answer 4

En pocas palabras, el casting es más eficiente que crear un objeto Double.

Answer 5

La biblioteca Guava Math tiene un método especialmente diseñado para convertir un doble en un largo:

long DoubleMath.roundToLong(double x, RoundingMode mode)

Puede usar java.math.RoundingMode para especificar el comportamiento de redondeo.

Answer 6

Si tiene una fuerte sospecha de que el DOBLE es realmente LARGO, y desea

1) obtener un control sobre su valor EXACTO como una LARGA

2) arrojar un error cuando no es LARGO

puedes probar algo como esto:

public class NumberUtils {

    /**
    * Convert a {@link Double} to a {@link Long}.
    * Method is for {@link Double}s that are actually {@link Long}s and we just
    * want to get a handle on it as one.
    */
    public static long getDoubleAsLong(double specifiedNumber) {
        Assert.isTrue(NumberUtils.isWhole(specifiedNumber));
        Assert.isTrue(specifiedNumber <= Long.MAX_VALUE && specifiedNumber >= Long.MIN_VALUE);
        // we already know its whole and in the Long range
        return Double.valueOf(specifiedNumber).longValue();
    }

    public static boolean isWhole(double specifiedNumber) {
        // http://.com/questions/15963895/how-to-check-if-a-double-value-has-no-decimal-part
        return (specifiedNumber % 1 == 0);
    }
}

Long es un subconjunto de Double, por lo que puede obtener algunos resultados extraños si, sin saberlo, intenta convertir un Double que está fuera del rango de Long:

@Test
public void test() throws Exception {
    // Confirm that LONG is a subset of DOUBLE, so numbers outside of the range can be problematic
    Assert.isTrue(Long.MAX_VALUE < Double.MAX_VALUE);
    Assert.isTrue(Long.MIN_VALUE > -Double.MAX_VALUE); // Not Double.MIN_VALUE => read the Javadocs, Double.MIN_VALUE is the smallest POSITIVE double, not the bottom of the range of values that Double can possible be

    // Double.longValue() failure due to being out of range => results are the same even though I minus ten
    System.out.println("Double.valueOf(Double.MAX_VALUE).longValue(): " + Double.valueOf(Double.MAX_VALUE).longValue());
    System.out.println("Double.valueOf(Double.MAX_VALUE - 10).longValue(): " + Double.valueOf(Double.MAX_VALUE - 10).longValue());

    // casting failure due to being out of range => results are the same even though I minus ten
    System.out.println("(long) Double.valueOf(Double.MAX_VALUE): " + (long) Double.valueOf(Double.MAX_VALUE).doubleValue());
    System.out.println("(long) Double.valueOf(Double.MAX_VALUE - 10).longValue(): " + (long) Double.valueOf(Double.MAX_VALUE - 10).doubleValue());
}

Answer 7

Suponiendo que estés contento con truncar hacia cero, solo lanza:

double d = 1234.56;
long x = (long) d; // x = 1234

Esto será más rápido que ir a través de las clases contenedoras y, lo que es más importante, es más legible. Ahora, si necesita un redondeo que no sea "siempre hacia cero", necesitará un código un poco más complicado.

Answer 8

(new Double(d)).longValue() internamente solo hace un molde, por lo que no hay motivo para crear un objeto Double.