How to Safely Convert a long to an int in Java: `toIntExact` vs Explicit Checking?

Avoiding Truncation Errors When Casting long to int

When converting a long value to an int in Java, it's crucial to ensure that the conversion doesn't lead to loss of information. One way to achieve this is through explicit checking, as demonstrated in the given implementation:

<code class="java">public static int safeLongToInt(long l) {
    int i = (int)l;
    if ((long)i != l) {
        throw new IllegalArgumentException(l + " cannot be cast to int without changing its value.");
    }
    return i;
}</code>

However, since Java 8, a more idiomatic solution has been introduced:

Math.toIntExact()

This method allows for safe long-to-int conversion by throwing an ArithmeticException when overflow occurs:

<code class="java">import java.lang.Math;
...
long foo = 10L;
int bar = Math.toIntExact(foo);</code>

Java 8 also includes similar "exact" methods for various arithmetic operations, ensuring accuracy and avoiding unexpected loss of precision:

• Math.incrementExact(long)
• Math.subtractExact(long, long)
• Math.decrementExact(long)
• Math.negateExact(long)
• Math.subtractExact(int, int)

By utilizing these methods, developers can confidently cast long values to int without the risk of data loss or runtime exceptions due to overflow.

The above is the detailed content of How to Safely Convert a long to an int in Java: `toIntExact` vs Explicit Checking?. For more information, please follow other related articles on the PHP Chinese website!