Transmitir de forma segura long to int en Java

¿Cuál es la forma más idiomática en Java para verificar que un envío desde longa intno pierda ninguna información?

Esta es mi implementación actual:

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

Se ha agregado un nuevo método con Java 8 para hacer precisamente eso.

import static java.lang.Math.toIntExact;

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

Lanzará un ArithmeticExceptionen caso de desbordamiento.

Ver: Math.toIntExact(long)

Se han agregado varios otros métodos seguros de desbordamiento a Java 8. Terminan con exacto .

Ejemplos:

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

Creo que lo haría tan simple como:

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

Creo que eso expresa la intención más claramente que el casting repetido ... pero es algo subjetivo.

Nota de interés potencial: en C # solo sería:

return checked ((int) l);

Con la clase Ints de Google Guava , su método se puede cambiar a:

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

De los documentos vinculados:

chequeado

public static int checkedCast(long value)

Devuelve el valor int que es igual a value, si es posible.

Parámetros: value - cualquier valor en el rango del inttipo

Devuelve: el intvalor que equivale avalue

Lanza: IllegalArgumentException si valuees mayor Integer.MAX_VALUEo menor queInteger.MIN_VALUE

Por cierto, no necesita el safeLongToIntcontenedor, a menos que desee dejarlo en su lugar para cambiar la funcionalidad sin una refactorización extensa, por supuesto.

Con BigDecimal:

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

Aquí hay una solución, en caso de que no le importe el valor en caso de que sea más grande de lo necesario;)

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

NO: ¡Esto no es una solución!

Mi primer acercamiento fue:

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

Pero eso simplemente convierte el largo en un int, potencialmente creando nuevas Longinstancias o recuperándolas del grupo Long.

Los inconvenientes

1. Long.valueOfcrea una nueva Longinstancia si el número no está dentro Longdel rango del grupo [-128, 127].

2. La intValueimplementación no hace más que:

   return (int)value;

Por lo tanto, esto puede considerarse incluso peor que simplemente lanzarlo longa int.

Afirmo que la forma obvia de ver si la conversión de un valor cambió el valor sería lanzar y verificar el resultado. Sin embargo, eliminaría el yeso innecesario al comparar. Tampoco me interesan los nombres de variables de una letra (excepción xy y, pero no cuando significan fila y columna (a veces, respectivamente)).

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

Sin embargo, realmente me gustaría evitar esta conversión si es posible. Obviamente, a veces no es posible, pero en esos casos IllegalArgumentExceptiones casi seguro que la excepción equivocada es lanzar en lo que respecta al código del cliente.

Los tipos enteros de Java se representan con signo. Con una entrada entre 2 ³¹ y 2 ³² (o -2 ³¹ y -2 ³² ), el lanzamiento tendrá éxito pero su prueba fallará.

Lo que debe verificar es si todos los bits altos de la longson todos iguales:

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)

pero Long no puede superar el máximo :)

Otra solución puede ser:

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

He intentado esto para los casos en que el cliente está haciendo una POST y el servidor DB solo entiende números enteros mientras el cliente tiene un Long.