Java long to number one

Преобразование long в тип int в Java

В этом руководстве мы увидим, как мы можем преобразовать значение long в тип int в Java. Прежде чем мы начнем программировать, нам нужно указать некоторые подробности об этом типе данных.

Во-первых, в Java длинные значения представлены 64-битными числами со знаком. С другой стороны, значения int представлены 32-битными числами со знаком. Поэтому преобразование более высокого типа данных в более низкий называется сужением приведения типов . В результате этих преобразований некоторые биты будут потеряны, если значения long превышают Integer.MAX_VALUE и Integer.MIN_VALUE .

Кроме того, для каждого варианта преобразования мы покажем, как это работает для длинного значения, равного Integer.MAX_VALUE плюс один.

2. Преобразование данных​

2.1. Приведение значений​

Во-первых, приведение значений в Java является наиболее распространенным способом преобразования типов — это просто:

 public int longToIntCast(long number)    return (int) number;   > 

2.2. Ява 8​

Начиная с Java 8, мы можем использовать еще два способа преобразования типов: с помощью пакета Math или с помощью лямбда-функции. Для пакета Math мы можем использовать метод toIntExact :

 public int longToIntJavaWithMath(long number)    return Math.toIntExact(number);   > 

2.3. Класс-оболочка​

С другой стороны, мы можем использовать класс-оболочку Long , чтобы получить значение int :

 public int longToIntBoxingValues(long number)    return Long.valueOf(number).intValue();   > 

2.4. Использование BigDecimal ​

Более того, мы можем выполнить это преобразование, используя класс BigDecimal :

 public static int longToIntWithBigDecimal(long number)    return new BigDecimal(number).intValueExact();   > 

2.5. Использование гуавы​

Далее мы покажем преобразование типов с помощью класса Google Guava Ints :

 public int longToIntGuava(long number)    return Ints.checkedCast(number);   > 

Кроме того, класс Google Guava Ints предоставляет метод насыщенного преобразования:

 public int longToIntGuavaSaturated(long number)    return Ints.saturatedCast(number);   > 

2.6. Целочисленные верхние и нижние границы​

Наконец, нам нужно учитывать, что целочисленное значение имеет верхнюю и нижнюю границы. Эти ограничения определяются Integer.MAX_VALUE и Integer.MIN_VALUE . Для значений, выходящих за эти пределы, результаты отличаются от одного метода к другому.

В следующем фрагменте кода мы проверим случай, когда значение int не может содержать длинное значение:

 @Test   public void longToIntSafeCast()    long max = Integer.MAX_VALUE + 10L;   int expected = -2147483639;   assertEquals(expected, longToIntCast(max));   assertEquals(expected, longToIntJavaWithLambda(max));   assertEquals(expected, longToIntBoxingValues(max));   > 

Использование прямого приведения, лямбда-выражения или использования значений бокса дает отрицательное значение. В этих случаях длинное значение больше, чем Integer.MAX_VALUE , поэтому результирующее значение заключено в отрицательное число. Если длинное значение меньше Integer.MIN_VALUE , результирующее значение является положительным числом.

С другой стороны, три метода, описанные в этой статье, могут генерировать различные типы исключений:

 @Test   public void longToIntIntegerException()    long max = Integer.MAX_VALUE + 10L;   assertThrows(ArithmeticException.class, () -> ConvertLongToInt.longToIntWithBigDecimal(max));   assertThrows(ArithmeticException.class, () -> ConvertLongToInt.longToIntJavaWithMath(max));   assertThrows(IllegalArgumentException.class, () -> ConvertLongToInt.longToIntGuava(max));   > 

Для первого и второго выдается исключение ArithmeticException . Для последнего выбрасывается исключение IllegalArgumentException . В этом случае Ints.checkedCast проверяет, не выходит ли целое число за пределы допустимого диапазона.

Наконец, из Guava, метод satCast , сначала проверяет целочисленные пределы и возвращает предельное значение, если переданное число больше или меньше, чем целочисленная верхняя и нижняя границы:

 @Test   public void longToIntGuavaSaturated()    long max = Integer.MAX_VALUE + 10L;   int expected = 2147483647;   assertEquals(expected, ConvertLongToInt.longToIntGuavaSaturated(max));   > 

3. Заключение​

В этой статье мы рассмотрели несколько примеров преобразования long в тип int в Java. Использование нативного приведения Java и некоторых библиотек.

Как обычно, все фрагменты, использованные в этой статье, доступны на GitHub .

Источник

How can I convert a long to int in Java?

Java 8 has a helper method that checks for overflow (you get an exception in that case): Solution 2: Here are three ways to do it: All three versions generate almost identical byte code: Solution 3: For non-null values: Solution 4: If you care to check for overflows and have Guava handy, there is : The implementation is dead simple, and throws IllegalArgumentException on overflow: I’ve just begun using java and I can’t convert a long array type to int array.

How can I convert a long to int in Java?

How can I convert a long to int in Java?

Updated, in Java 8:

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:

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

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

Java — Cannot convert from long to int, why can’t I round, It’s better to use round on an argument of type double and convert the result to int than to use float to the conversion unless the best representation of the value to be converted is a float.Given float f=1234567.875f;, the value of round(f*1000.0f) will be 1234567936. The original value was precisely …

Convert Long into Integer

How to convert a Long value into an Integer value in Java?

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

or if you don’t need to worry about null:

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

And in both situations, you might run into overflows (because a Long can store a wider range than an Integer).

Java 8 has a helper method that checks for overflow (you get an exception in that case):

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

Here are three ways to do it:

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

All three versions generate almost identical byte code:

 0 ldc2_w [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] 

Integer intValue = myLong.intValue(); 

If you care to check for overflows and have Guava handy, there is Ints.checkedCast() :

int theInt = Ints.checkedCast(theLong); 

The implementation is dead simple, and throws IllegalArgumentException on overflow:

public static int checkedCast(long value)

Safely casting long to int in Java, 10 Answers. Sorted by: 625. A new method has been added with Java 8 to do just that. import static java.lang.Math.toIntExact; long foo = 10L; int bar = toIntExact (foo); Will throw an ArithmeticException in case of overflow. See: Math.toIntExact (long) Several other overflow safe methods have been added to Java 8.

Converting long to int in Java

I’m using System.currentTimeMillis() for getting seconds since the epoch. This is an example.

 long enable_beacon_timestamp = System.currentTimeMillis()/1000; println(enable_beacon_timestamp); println(int(enable_beacon_timestamp)); enable_beacon(int(enable_beacon_timestamp)); 

So the problem is that there is a mismatch in cast value. What I want is to get the first output the same as the integer.

Can you provide some background why this happen?.

Your cast syntax is incorrect. You need also be aware that long s can be much bigger that the max value for int .

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

Try something like this perhaps.

you could write something such as

Java SE 8

1. To avoid doing the calculations yourself, you can use TimeUnit#convert .
2. To avoid getting undesirable result due to overflow, you can use Math.toIntExact which throws an exception if the value overflows an int .

import java.util.concurrent.TimeUnit; public class Main < public static void main(String[] args) < long seconds = TimeUnit.SECONDS.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS); System.out.println(seconds); try < int secondInt = Math.toIntExact(seconds); System.out.println(secondInt); // . >catch (ArithmeticException e) < System.out.println("Encountered error while casting."); >> > 

Java Program to Convert Char to Int, The method valueOf() of class String can convert various types of values to a String value. It can convert int, char, long, boolean, float, double, object, and char array to String, which can be converted to an int value by using the Integer.parseInt() method. The below program illustrates the use of the …

Convert long array to int array in Java

I’ve just begun using java and I can’t convert a long array type to int array. Can you give a piece of advice what should I do? Thank you!

public class Main < public static void main(String[] args) < long[] numbers; numbers = sorting(new long[]); > public static long[] sorting(long [] numbers) < for (long num : numbers) < long j = 0; for (int i = 0; i < numbers.length - 1; i++) < if (numbers[i] >numbers[i + 1]) < j = numbers[i]; numbers[i] = numbers[i + 1]; numbers[i + 1] = j; >> System.out.println(num + ","); > return (numbers); 

To convert an long[] to int[], you need to iterate over your long[] array, cast each individual number to int and put it to the int[] array.

// Your result long[] numbers = sorting(new long[] ); // Define a new int array with the same length of your result array int[] intNumbers = new int[numbers.length]; // Loop through all the result numbers for(int i = 0; i < numbers.length; i++) < // Cast to int and put it to the int array intNumbers[i] = (int) numbers[i]; >

Or you can also use Java Streams (>= 1.8) for a shorter version:

int[] intArray = Arrays.stream(numbers).mapToInt(i -> (int) i).toArray();

There is a similar question in convert-an-int-array-to-long-array-using-java-8

 long[] longArray = ; int[] intArray = Arrays.stream(longArray).mapToInt(i -> (int) i).toArray(); 

Something else to mention here. If you just cast long to int you risk an integer overflow. So to be safe I would recommend Math#toIntExact function which ensures the conversion is safe. Here is an example:

long[] longs = new long[] ; int[] ints = Arrays.stream(longs).mapToInt(Math::toIntExact).toArray(); 

If longs contains a value that can’t be converted to an int then an ArithmeticException will be thrown e.g.

long[] longs = new long[] ; int[] ints = Arrays.stream(longs).mapToInt(Math::toIntExact).toArray(); // Throws here 

will throw Exception in thread «main» java.lang.ArithmeticException: integer overflow this ensures your code works correctly.

Java — Convert long to two int and vice versa, (long)a

Источник