Casting sicuro da lungo a int in Java

Qual è il modo più idiomatico in Java per verificare che un cast da longa intnon perda alcuna informazione?

Questa è la mia attuale implementazione:

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

Un nuovo metodo è stato aggiunto con Java 8 per fare proprio questo.

import static java.lang.Math.toIntExact;

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

Lancerà un ArithmeticExceptioncaso di overflow.

Vedere: Math.toIntExact(long)

Diversi altri metodi sicuri di overflow sono stati aggiunti a Java 8. Finiscono con esatto .

Esempi:

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

Penso che lo farei semplicemente come:

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

Penso che esprima l'intento più chiaramente del casting ripetuto ... ma è in qualche modo soggettivo.

Nota di potenziale interesse - in C # sarebbe solo:

return checked ((int) l);

Con la classe Ints di Google Guava , il tuo metodo può essere modificato in:

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

Dai documenti collegati:

checkedCast

public static int checkedCast(long value)

Restituisce il valore int uguale a value, se possibile.

Parametri: value - qualsiasi valore nell'intervallo del inttipo

Restituisce: il intvalore che è ugualevalue

Genera: IllegalArgumentException - se valueè maggiore Integer.MAX_VALUEo minore diInteger.MIN_VALUE

Per inciso, non è necessario il safeLongToIntwrapper, a meno che non si desideri lasciarlo in posizione per cambiare la funzionalità senza ovviamente un ampio refactoring.

Con BigDecimal:

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

ecco una soluzione, nel caso in cui non ti interessi del valore nel caso sia più grande del necessario;)

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

NON: Questa non è una soluzione!

Il mio primo approccio è stato:

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

Ma questo semplicemente lancia il long a un int, potenzialmente creando nuove Longistanze o recuperandole dal pool Long.

Gli svantaggi

1. Long.valueOfcrea una nuova Longistanza se il numero non rientra Longnell'intervallo del pool [-128, 127].

2. L' intValueimplementazione non fa altro che:

   return (int)value;

Quindi questo può essere considerato anche peggio del semplice lancio longdi int.

Sostengo che il modo ovvio per vedere se il cast di un valore è cambiato il valore sarebbe quello di lanciare e verificare il risultato. Vorrei, tuttavia, rimuovere il cast non necessario durante il confronto. Inoltre non sono troppo appassionato di nomi di variabili di una lettera (eccezione xe y, ma non quando significano riga e colonna (a volte rispettivamente)).

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

Tuttavia, vorrei davvero evitare questa conversione, se possibile. Ovviamente a volte non è possibile, ma in quei casi IllegalArgumentExceptionè quasi certamente l'eccezione sbagliata da lanciare per quanto riguarda il codice client.

I tipi interi Java sono rappresentati come firmati. Con un input compreso tra 2 ³¹ e 2 ³² (o -2 ³¹ e -2 ³² ) il cast avrebbe esito positivo ma il test non avrebbe avuto esito positivo.

Cosa controllare è se tutti i bit alti longsono tutti uguali:

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)

ma Long non può superare il massimo :)

Un'altra soluzione può essere:

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

Ho provato questo per i casi in cui il client sta eseguendo un POST e il DB del server comprende solo numeri interi mentre il client ha un valore Long.