Convertir largo en entero

¿Cómo convertir un Longvalor en un Integervalor en Java?

Integer i = theLong != null ? theLong.intValue() : null;

o si no necesita preocuparse por nulo:

// auto-unboxing does not go from Long to int directly, so
Integer i = (int) (long) theLong;

Y en ambas situaciones, puede encontrarse con desbordamientos (porque un Long puede almacenar un rango más amplio que un Integer).

Java 8 tiene un método auxiliar que verifica el desbordamiento (en ese caso, se obtiene una excepción):

Integer i = theLong == null ? null : Math.toIntExact(theLong);

Aquí hay tres formas de hacerlo:

Long l = 123L;
Integer correctButComplicated = Integer.valueOf(l.intValue());
Integer withBoxing = l.intValue();
Integer terrible = (int) (long) l;

Las tres versiones generan un código de bytes casi idéntico:

 0  ldc2_w <Long 123> [17]
 3  invokestatic java.lang.Long.valueOf(long) : java.lang.Long [19]
 6  astore_1 [l]
 // first
 7  aload_1 [l]
 8  invokevirtual java.lang.Long.intValue() : int [25]
11  invokestatic java.lang.Integer.valueOf(int) : java.lang.Integer [29]
14  astore_2 [correctButComplicated]
// second
15  aload_1 [l]
16  invokevirtual java.lang.Long.intValue() : int [25]
19  invokestatic java.lang.Integer.valueOf(int) : java.lang.Integer [29]
22  astore_3 [withBoxing]
// third
23  aload_1 [l]
// here's the difference:
24  invokevirtual java.lang.Long.longValue() : long [34]
27  l2i
28  invokestatic java.lang.Integer.valueOf(int) : java.lang.Integer [29]
31  astore 4 [terrible]

Para valores no nulos:

Integer intValue = myLong.intValue();

Si le interesa verificar si hay desbordamientos y tiene guayaba a mano, hay Ints.checkedCast():

int theInt = Ints.checkedCast(theLong);

La implementación es muy simple y arroja IllegalArgumentException en caso de desbordamiento:

public static int checkedCast(long value) {
  int result = (int) value;
  checkArgument(result == value, "Out of range: %s", value);
  return result;
}

Tendrás que escribir cast it.

long i = 100L;
int k = (int) i;

Tenga en cuenta que un largo tiene un rango mayor que un int, por lo que podría perder datos.

Si está hablando de los tipos encuadrados, lea la documentación .

Si está utilizando Java 8, hágalo de la siguiente manera

    import static java.lang.Math.toIntExact;

    public class DateFormatSampleCode {
        public static void main(String[] args) {
            long longValue = 1223321L;
            int longTointValue = toIntExact(longValue);
            System.out.println(longTointValue);

        }
}

La mejor manera simple de hacerlo es:

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

En Java 8 puedes usar toIntExact. Si desea manejar nullvalores, use:

Integer intVal = longVal == null ? null : Math.toIntExact(longVal);

Lo bueno de este método es que arroja un ArithmeticExceptionsi el argumento ( long) desborda un int.

Suponiendo que no sea nulo longVal

Integer intVal = ((Number)longVal).intValue();

Funciona, por ejemplo, y obtienes un Objeto que puede ser un Entero o un Largo. Sé que es feo, pero sucede ...

El uso de toIntExact (valor largo) devuelve el valor del argumento largo, arrojando una excepción si el valor desborda un int. solo funcionará con el nivel de API 24 o superior.

int id = Math.toIntExact(longId);

visitantes largos = 1000;

int convVisitors = (int) visitantes;

En java, hay una forma rigurosa de convertir un largo a int

no solo lnog se puede convertir en int, cualquier tipo de clase se extiende El número se puede convertir a otro tipo de Número en general, aquí le mostraré cómo convertir un largo a int, otro tipo viceversa.

Long l = 1234567L;
int i = org.springframework.util.NumberUtils.convertNumberToTargetClass(l, Integer.class);