Sicheres Casting von Long zu Int in Java

Was ist die idiomatischste Methode in Java, um zu überprüfen, ob eine Besetzung von longbis intkeine Informationen verliert?

Dies ist meine aktuelle Implementierung:

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;
}

Mit Java 8 wurde eine neue Methode hinzugefügt , um genau das zu tun.

import static java.lang.Math.toIntExact;

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

Wirft einen ArithmeticExceptionim Falle eines Überlaufs.

Sehen: Math.toIntExact(long)

Java 8 wurden mehrere andere überlaufsichere Methoden hinzugefügt. Sie enden mit genau .

Beispiele:

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

Ich denke, ich würde es so einfach machen wie:

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;
}

Ich denke, das drückt die Absicht klarer aus als das wiederholte Casting ... aber es ist etwas subjektiv.

Hinweis von potenziellem Interesse - in C # wäre es nur:

return checked ((int) l);

Mit der Ints- Klasse von Google Guava kann Ihre Methode geändert werden in:

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

Aus den verknüpften Dokumenten:

checkedCast

public static int checkedCast(long value)

Gibt den int-Wert zurück, der nach valueMöglichkeit gleich ist.

Parameter: value - Beliebiger Wert im Bereich des intTyps

Rückgabe: Der intWert, der gleich istvalue

Würfe: IllegalArgumentException - wenn valuegrößer Integer.MAX_VALUEoder kleiner alsInteger.MIN_VALUE

Das brauchst du übrigens nicht safeLongToInt Wrapper nicht, es sei denn, Sie möchten ihn an Ort und Stelle lassen, um die Funktionalität ohne umfangreiches Refactoring zu ändern.

Mit BigDecimal:

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

Hier ist eine Lösung, falls Sie sich nicht für den Wert interessieren, falls er größer ist als benötigt;)

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

NICHT: Dies ist keine Lösung!

Mein erster Ansatz war:

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

Damit wird jedoch nur das Long in ein Int umgewandelt, wodurch möglicherweise neue LongInstanzen erstellt oder aus dem Long-Pool abgerufen werden.

Die Nachteile

1. Long.valueOfErstellt eine neue LongInstanz, wenn die Nummer nicht im LongPoolbereich liegt [-128, 127].

2. Die intValueImplementierung macht nichts weiter als:

   return (int)value;

Das kann also noch schlimmer sein, als nur das longzu werfen int.

Ich behaupte, dass der offensichtliche Weg, um zu sehen, ob das Wirken eines Wertes den Wert verändert hat, darin besteht, das Ergebnis zu wirken und zu überprüfen. Ich würde jedoch die unnötige Besetzung beim Vergleich entfernen. Ich bin auch nicht besonders an Ein-Buchstaben-Variablennamen interessiert (Ausnahme xund y, aber nicht, wenn sie Zeile und Spalte bedeuten (manchmal jeweils)).

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;
}

Eigentlich möchte ich diese Konvertierung aber möglichst vermeiden. Natürlich ist es manchmal nicht möglich, aber in diesen Fällen IllegalArgumentExceptionist es mit ziemlicher Sicherheit die falsche Ausnahme, wenn es um Client-Code geht.

Java-Integer-Typen werden als signiert dargestellt. Mit einem Eingang zwischen 2 ³¹ und 2 ³² (oder -2 ³¹ und -2 ³² ) wäre die Besetzung erfolgreich, aber Ihr Test würde fehlschlagen.

Es ist zu prüfen, ob alle hohen Bits von longgleich sind:

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)

aber Long kann das Maximum nicht überschreiten :)

Eine andere Lösung kann sein:

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

Ich habe dies für Fälle versucht, in denen der Client einen POST ausführt und die Server-DB nur Ganzzahlen versteht, während der Client einen Long hat.