Welcome to our tutorial where we will explore various methods to convert long to integer in Java. When working with numbers, you might encounter situations where a long value needs to be converted into an integer. This might seem straightforward, but due to the difference in the range and size of the two data types, several techniques have been developed to achieve this conversion accurately and efficiently. In this guide, we will discuss different approaches such as explicit casting, using mathematical methods like rounding, leveraging bitwise operators, and even going through a String conversion process. Each method has its unique aspects, and we will uncover them to give you a better understanding, allowing you to choose the most suitable one for your needs. So, letâ€™s dive in and learn how to convert long to integer in Java!

**Topics we will cover**hide

## Different methods to convert Long to Integer in Java

In this tutorial, we will unravel diverse strategies for achieving this conversion, each with its unique approach and implications. The topics we will explore include:

**Casting**: Explicitly cast the long value to an int. This method truncates the extra bits if the value exceeds the int range.**Using Math.toIntExact(long value)**: Converts a long value to int, throwing an exception if the value overflows an int.**Using**: Calls the intValue() method on a Long object which returns the value of the Long object as an int, truncating extra bits if necessary.`Long.intValue()`

Method**Using Arithmetic Operators**: You can use arithmetic operators like modulo(%) to keep the value within int range, but it modifies the actual value.**Using**: These methods round the long values to the nearest int value, and you would need to cast the result to int.`Math.round()`

,`Math.floor()`

, or`Math.ceil()`

**Using Bitwise Operators**: Applying bitwise operators to manipulate the bits directly, ensuring the value fits within the int range.**By String Conversion**: Convert the long value to a String and then parse it to an int. Be cautious of number format exceptions.

## 1. Using Type Casting

When we want to convert long to integer explicitly, casting can be utilized. By casting, we inform the compiler to treat the long value as an integer. However, if the long value is outside the range of integer values, the extra bits will be truncated, potentially causing data loss or unexpected values.

```
long longValue = 150L;
int intValue = (int) longValue; // Explicitly casting long to integer
System.out.println("Integer Value: " + intValue); // Output: Integer Value: 150
long largeLongValue = 2147483648L; // 1 more than maximum integer value
int truncatedIntValue = (int) largeLongValue; // The extra bits will be truncated
System.out.println("Truncated Integer Value: " + truncatedIntValue); // Output may be unexpected due to truncation
```

## 2. Using `Math.toIntExact(long value)`

The `Math.toIntExact(long value)`

method is another way to convert long to integer. This method tries to convert the long value to an integer precisely. If the conversion is not exact due to overflow (value being outside the range of valid integer values), it throws an ArithmeticException, ensuring that only values within the integer range are converted successfully.

```
long longValue = 100L;
try {
int intValue = Math.toIntExact(longValue); // Trying to convert long to integer precisely
System.out.println("Integer Value: " + intValue); // Output: Integer Value: 100
} catch (ArithmeticException e) {
System.out.println("Conversion failed due to overflow.");
}
long largeLongValue = 2147483648L; // Outside of integer range
try {
int intValue = Math.toIntExact(largeLongValue); // Will throw an ArithmeticException due to overflow
} catch (ArithmeticException e) {
System.out.println("Conversion failed due to overflow."); // Output: Conversion failed due to overflow.
}
```

In the casting method, the conversion happens without any exceptions, but there might be data loss. In contrast, using `Math.toIntExact(long value)`

ensures that any inaccuracy due to overflow is captured as an exception, preventing silent data corruption.

## 3. Using `Long.intValue()`

Method

The `Long.intValue()`

method allows us to convert long to integer directly. When a Long object calls the `intValue()`

method, it returns the value of the Long object as an int. If the long value is outside the range of int values, the method truncates the extra bits, resulting in a value that might not be the same as the original long value due to the loss of high-order bits.

```
Long longValue = 300L;
int intValue = longValue.intValue(); // Convert long to integer using intValue() method
System.out.println("Integer Value: " + intValue); // Output: Integer Value: 300
Long largeLongValue = 2147483648L; // Outside the range of integer values
int truncatedIntValue = largeLongValue.intValue(); // The value will be truncated
System.out.println("Truncated Integer Value: " + truncatedIntValue); // Output may be unexpected due to truncation
```

## 4. Using Arithmetic Operators

Arithmetic operators, such as modulo (%), can also be utilized to convert long to integer, but they modify the actual value to keep it within the int range. By applying the modulo operator, you get the remainder of the division of the long value by the maximum int value plus one, thus ensuring the resulting value is within the range of valid int values.

```
long longValue = 500L;
int intValue = (int) (longValue % (Integer.MAX_VALUE + 1L)); // Convert long to integer using modulo operator
System.out.println("Integer Value: " + intValue); // Output: Integer Value: 500
long largeLongValue = 2147483648L; // Outside the range of integer values
int wrappedIntValue = (int) (largeLongValue % (Integer.MAX_VALUE + 1L)); // Applying modulo to keep value within int range
System.out.println("Modified Integer Value: " + wrappedIntValue); // Output will be within int range, but value is modified
```

In the first method using `Long.intValue()`

, the conversion might lead to data loss due to truncation if the long value is outside the int range. In the second method, using arithmetic operators ensures the value is within the int range but modifies the original value to achieve this.

## 5. Using `Math.round()`

, `Math.floor()`

, or `Math.ceil()`

To convert long to integer in Java, methods such as `Math.round()`

, `Math.floor()`

, and `Math.ceil()`

can be utilized. These methods help in rounding the long values, where `Math.round()`

rounds to the nearest integer, `Math.floor()`

rounds down, and `Math.ceil()`

rounds up. After rounding, you would need to explicitly cast the result to an int type.

```
long longValue = 500L;
// Using Math.round()
int roundedValue = (int) Math.round(longValue);
System.out.println("Rounded Value: " + roundedValue); // Output: Rounded Value: 500
// Using Math.floor()
int flooredValue = (int) Math.floor(longValue);
System.out.println("Floored Value: " + flooredValue); // Output: Floored Value: 500
// Using Math.ceil()
int ceiledValue = (int) Math.ceil(longValue);
System.out.println("Ceiled Value: " + ceiledValue); // Output: Ceiled Value: 500
```

## 6. Using Bitwise Operators

To convert long to integer in Java, bitwise operators can be used to manipulate the bits directly. By applying bitwise operations, we can ensure that the value fits within the int range, effectively truncating the higher bits that are outside the range of integer values.

```
long longValue = 1000L;
int intValue = (int) (longValue & 0xFFFFFFFF); // Applying bitwise AND operator to keep only the lower 32 bits
System.out.println("Integer Value: " + intValue); // Output: Integer Value: 1000
```

## 7. By String Conversion

To convert long to integer in Java, one approach is to convert the long value to a String and then parse the String to an integer. This method requires caution because a NumberFormatException can be thrown if the String representation of the long value is out of the integer range.

```
long longValue = 200L;
String longAsString = Long.toString(longValue); // Converting long to String
try {
int intValue = Integer.parseInt(longAsString); // Parsing String to integer
System.out.println("Integer Value: " + intValue); // Output: Integer Value: 200
} catch (NumberFormatException e) {
System.out.println("Conversion failed due to out of range value.");
}
```

## Summary

In our exploration of how to convert long to integer in Java, we uncovered various methods each with unique attributes and considerations. This conversion is essential due to the different ranges and sizes of the two data types, requiring thoughtful techniques to maintain accuracy and efficiency. Key takeaways include understanding the necessity of handling overflow and truncation, the usage of explicit casting, mathematical methods, bitwise operators, and String conversion techniques to manage the conversion process seamlessly and effectively.

Further Reading: