How can I convert a long to int in Java?
19 Answers
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
.
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)
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
.
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
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
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
.
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);
if ((lval <= Integer.MAX_VALUE) && (lval >= Integer.MIN_VALUE)) intValue = (int)lval;
– NomadMaker