Bezpieczne przesyłanie do int w Javie

Jaki jest najbardziej idiomatyczny sposób w Javie, aby zweryfikować, czy rzutowanie z longna intnie traci żadnych informacji?

To jest moja obecna implementacja:

public static int safeLongToInt(long l) {
    int i = (int)l;
    if ((long)i != l) {
        throw new IllegalArgumentException(l + " cannot be cast to int without changing its value.");
    }
    return i;
}

W tym celu dodano nową metodę do Java 8 .

import static java.lang.Math.toIntExact;

long foo = 10L;
int bar = toIntExact(foo);

Rzuci ArithmeticExceptionw przypadku przepełnienia.

Widzieć: Math.toIntExact(long)

Kilka innych bezpiecznych metod przelewu zostało dodanych do Java 8. Kończą się dokładnie .

Przykłady:

• Math.incrementExact(long)
• Math.subtractExact(long, long)
• Math.decrementExact(long)
• Math.negateExact(long),
• Math.subtractExact(int, int)

Myślę, że zrobiłbym to tak prosto jak:

public static int safeLongToInt(long l) {
    if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
        throw new IllegalArgumentException
            (l + " cannot be cast to int without changing its value.");
    }
    return (int) l;
}

Myślę, że to wyraźniej wyraża intencję niż powtarzające się castowanie ... ale jest to nieco subiektywne.

Uwaga potencjalnego zainteresowania - w języku C # byłoby to po prostu:

return checked ((int) l);

Dzięki klasie Ints Google Guava możesz zmienić metodę na:

public static int safeLongToInt(long l) {
    return Ints.checkedCast(l);
}

Z powiązanych dokumentów:

CheckCast

public static int checkedCast(long value)

Zwraca wartość int, która jest równa value, jeśli to możliwe.

Parametry: value - dowolna wartość z zakresu inttypu

Powroty:int wartość zgodnąvalue

Rzuty: IllegalArgumentException - jeśli valuejest większy Integer.MAX_VALUElub mniejszy niżInteger.MIN_VALUE

Nawiasem mówiąc, nie potrzebujesz safeLongToIntotoki, chyba że chcesz zostawić ją na miejscu w celu zmiany funkcjonalności bez obszernego refaktoryzacji.

Z BigDecimal:

long aLong = ...;
int anInt = new BigDecimal(aLong).intValueExact(); // throws ArithmeticException
                                                   // if outside bounds

oto rozwiązanie, na wypadek gdybyś nie dbał o wartość, gdyby była większa niż potrzebna;)

public static int safeLongToInt(long l) {
    return (int) Math.max(Math.min(Integer.MAX_VALUE, l), Integer.MIN_VALUE);
}

DONT: To nie jest rozwiązanie!

Moje pierwsze podejście było:

public int longToInt(long theLongOne) {
  return Long.valueOf(theLongOne).intValue();
}

Ale to tylko rzuca long na int, potencjalnie tworząc nowe Longinstancje lub odzyskując je z puli Long.

Wady

1. Long.valueOftworzy nową Longinstancję, jeśli liczba nie mieści się w Longzakresie puli [-128, 127].

2. intValueRealizacja nie robi nic więcej niż:

   return (int)value;

Można to uznać za jeszcze gorsze niż zwykłe przesłanie longdo int.

Twierdzę, że oczywistym sposobem sprawdzenia, czy rzutowanie wartości zmieniło wartość, byłoby rzutowanie i sprawdzenie wyniku. Chciałbym jednak usunąć niepotrzebną obsadę podczas porównywania. Nie przepadam też za nazwami zmiennych o jednej literze (wyjątek xi y, ale nie kiedy oznaczają one wiersz i kolumnę (czasami odpowiednio)).

public static int intValue(long value) {
    int valueInt = (int)value;
    if (valueInt != value) {
        throw new IllegalArgumentException(
            "The long value "+value+" is not within range of the int type"
        );
    }
    return valueInt;
}

Jednak naprawdę chciałbym uniknąć tej konwersji, jeśli to w ogóle możliwe. Oczywiście czasami nie jest to możliwe, ale w takich przypadkach IllegalArgumentExceptionprawie na pewno jest to zły wyjątek, jeśli chodzi o podanie kodu klienta.

Typy całkowite Java są reprezentowane jako podpisane. Przy wartości wejściowej między 2 ³¹ a 2 ³² (lub -2 ³¹ i -2 ³² ) rzutowanie się powiedzie, ale test się nie powiedzie.

Należy sprawdzić, czy wszystkie wysokie bity longsą takie same:

public static final long LONG_HIGH_BITS = 0xFFFFFFFF80000000L;
public static int safeLongToInt(long l) {
    if ((l & LONG_HIGH_BITS) == 0 || (l & LONG_HIGH_BITS) == LONG_HIGH_BITS) {
        return (int) l;
    } else {
        throw new IllegalArgumentException("...");
    }
}

(int) (longType + 0)

ale Long nie może przekroczyć maksimum :)

Innym rozwiązaniem może być:

public int longToInt(Long longVariable)
{
    try { 
            return Integer.valueOf(longVariable.toString()); 
        } catch(IllegalArgumentException e) { 
               Log.e(e.printstackstrace()); 
        }
}

Próbowałem tego w przypadkach, w których klient wykonuje test POST, a serwer DB rozumie tylko liczby całkowite, podczas gdy klient ma wartość Long.