How can I convert a long to int in Java?

How can I convert a long to int in Java?

Updated, in Java 8:

Math.toIntExact(value);

Original Answer:

Simple type casting should do it:

long l = 100000;
int i = (int) l;

Note, however, that large numbers (usually larger than 2147483647 and smaller than -2147483648) will lose some of the bits and would be represented incorrectly.

For instance, 2147483648 would be represented as -2147483648.

Long x = 100L;
int y = x.intValue();

For small values, casting is enough:

long l = 42;
int i = (int) l;

However, a long can hold more information than an int, so it's not possible to perfectly convert from long to int, in the general case. If the long holds a number less than or equal to Integer.MAX_VALUE you can convert it by casting without losing any information.

For example, the following sample code:

System.out.println( "largest long is " + Long.MAX_VALUE );
System.out.println( "largest int is " + Integer.MAX_VALUE );

long x = (long)Integer.MAX_VALUE;
x++;
System.out.println("long x=" + x);

int y = (int) x;
System.out.println("int y=" + y);

produces the following output on my machine:

largest long is 9223372036854775807
largest int is 2147483647
long x=2147483648
int y=-2147483648

Notice the negative sign on y. Because x held a value one larger than Integer.MAX_VALUE, int y was unable to hold it. In this case, it wrapped around to the negative numbers.

If you wanted to handle this case yourself, you might do something like:

if ( x > (long)Integer.MAX_VALUE ) {
    // x is too big to convert, throw an exception or something useful
}
else {
    y = (int)x;
}

All of this assumes positive numbers. For negative numbers, use MIN_VALUE instead of MAX_VALUE.

Since Java 8 you can use: Math.toIntExact(long value)

See JavaDoc: Math.toIntExact

> Returns the value of the long argument; throwing an exception if the value overflows an int.

Source code of Math.toIntExact in JDK 8:

public static int toIntExact(long value) {
    if ((int)value != value) {
        throw new ArithmeticException("integer overflow");
    }
    return (int)value;
}

If using Guava library, there are methods Ints.checkedCast(long) and Ints.saturatedCast(long) for converting long to int.

long x = 3;
int y = (int) x;

but that assumes that the long can be represented as an int, you do know the difference between the two?

You can use the Long wrapper instead of long primitive and call

Long.intValue()

Java7 intValue() docs

It rounds/truncate the long value accordingly to fit in an int.

Shortest, most safe and easiest solution is:

long myValue=...;
int asInt = Long.valueOf(myValue).intValue();

Do note, the behavior of Long.valueOf is as such:

Using this code:

System.out.println("Long max: " + Long.MAX_VALUE);
System.out.println("Int max: " + Integer.MAX_VALUE);        
long maxIntValue = Integer.MAX_VALUE;
System.out.println("Long maxIntValue to int: " + Long.valueOf(maxIntValue).intValue());
long maxIntValuePlusOne = Integer.MAX_VALUE + 1;
System.out.println("Long maxIntValuePlusOne to int: " + Long.valueOf(maxIntValuePlusOne).intValue());
System.out.println("Long max to int: " + Long.valueOf(Long.MAX_VALUE).intValue());

Results into:

Long max: 9223372036854775807
Int max: 2147483647
Long max to int: -1
Long maxIntValue to int: 2147483647
Long maxIntValuePlusOne to int: -2147483648

If direct casting shows error you can do it like this:

Long id = 100;
int int_id = (int) (id % 100000);

In Java, a long is a signed 64 bits number, which means you can store numbers between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807 (inclusive).

A int, on the other hand, is signed 32 bits number, which means you can store number between -2,147,483,648 and 2,147,483,647 (inclusive).

So if your long is outside of the values permitted for an int, you will not get a valuable conversion.

Details about sizes of primitive Java types here:

http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

In Java 8 I do in following way

long l = 100L;
int i = Math.toIntExact(l);

This method throws ArithmaticException if long value exceed range of int. Thus I am safe from data loss.

Manual typecasting can be done here:

long x1 = 1234567891;
int y1 = (int) x1;
System.out.println("in value is " + y1);

If you want to make a safe conversion and enjoy the use of Java8 with Lambda expression You can use it like:

val -> Optional.ofNullable(val).map(Long::intValue).orElse(null)

long x;
int y;
y = (int) x

You can cast a long to int so long as the number is less than 2147483647 without an error.

I'm adding few key details.

Basically what Java does is truncate long after 32 bits, so simple typecasting will do the trick:

    long l=100000000000000000l;
    System.out.println(Long.toString(l,2));
    int t=(int)l;
    System.out.println(Integer.toString(t,2));

Which outputs:

101100011010001010111100001011101100010100000000000000000
                          1011101100010100000000000000000

for l=1000000043634760000l it outputs:

110111100000101101101011110111010000001110011001100101000000
                             -101111110001100110011011000000

If we convert this -101111110001100110011011000000 in proper two's compliment we will get the exact 32-bit signed truncated from the long.

I Also Faced This Problem. To Solve This I have first converted my long to String then to int.

int i = Integer.parseInt(String.valueOf(long));

long x = 3120L; //take any long value int z = x.intValue(); //you can convert double to int also in the same way

if you needto covert directly then

longvalue.intvalue();

Long l = 100;
int i = Math.round(l);

In Spring, there is a rigorous way to convert a long to int

not only lnog can convert into int,any type of class extends Number can convert to other Number type in general,here I will show you how to convert a long to int,other type vice versa.

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