Truyền an toàn dài đến int trong Java

Cách thức thành ngữ nhất trong Java để xác minh rằng việc truyền từ longđến intkhông mất bất kỳ thông tin nào?

Đây là triển khai hiện tại của tôi:

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

Một phương thức mới đã được thêm vào với Java 8 để làm việc đó.

import static java.lang.Math.toIntExact;

long foo = 10L;
int bar = toIntExact(foo);

Sẽ ném một ArithmeticExceptiontrong trường hợp tràn.

Xem: Math.toIntExact(long)

Một số phương thức an toàn tràn khác đã được thêm vào Java 8. Chúng kết thúc chính xác .

Ví dụ:

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

Tôi nghĩ rằng tôi sẽ làm điều đó đơn giản như:

public static int safeLongToInt(long l) {
    if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
        throw new IllegalArgumentException
            (l + " cannot be cast to int without changing its value.");
    }
    return (int) l;
}

Tôi nghĩ rằng điều đó thể hiện ý định rõ ràng hơn so với việc lặp đi lặp lại ... nhưng nó hơi chủ quan.

Lưu ý về mối quan tâm tiềm năng - trong C #, nó sẽ chỉ là:

return checked ((int) l);

Với lớp Ints của Google Guava , phương thức của bạn có thể được thay đổi thành:

public static int safeLongToInt(long l) {
    return Ints.checkedCast(l);
}

Từ các tài liệu được liên kết:

đã kiểm tra

public static int checkedCast(long value)

Trả về giá trị int bằng value, nếu có thể.

Tham số: value - bất kỳ giá trị nào trong phạm vi của intloại

Returns: các intgiá trị mà bình đẳngvalue

Ném: IllegalArgumentException - nếu valuelớn hơn Integer.MAX_VALUEhoặc nhỏ hơnInteger.MIN_VALUE

Ngẫu nhiên, bạn không cần safeLongToInttrình bao bọc, trừ khi bạn muốn để nó thay thế chức năng mà không cần tái cấu trúc rộng rãi.

Với BigDecimal:

long aLong = ...;
int anInt = new BigDecimal(aLong).intValueExact(); // throws ArithmeticException
                                                   // if outside bounds

Đây là một giải pháp, trong trường hợp bạn không quan tâm đến giá trị trong trường hợp nó lớn hơn thì cần thiết;)

public static int safeLongToInt(long l) {
    return (int) Math.max(Math.min(Integer.MAX_VALUE, l), Integer.MIN_VALUE);
}

ĐỪNG: Đây không phải là một giải pháp!

Cách tiếp cận đầu tiên của tôi là:

public int longToInt(long theLongOne) {
  return Long.valueOf(theLongOne).intValue();
}

Nhưng điều đó chỉ đơn thuần là chuyển từ dài sang int, có khả năng tạo ra các Longthể hiện mới hoặc truy xuất chúng từ nhóm Long.

Hạn chế

1. Long.valueOftạo một thể hiện mới Longnếu số đó không nằm trong Longphạm vi nhóm [-128, 127].

2. Việc intValuethực hiện không có gì hơn:

   return (int)value;

Vì vậy, đây có thể được coi thậm chí còn tồi tệ hơn chỉ đúc các longđến int.

Tôi khẳng định rằng cách rõ ràng để xem việc truyền giá trị có thay đổi giá trị hay không sẽ là truyền và kiểm tra kết quả. Tôi sẽ, tuy nhiên, loại bỏ các diễn viên không cần thiết khi so sánh. Tôi cũng không quá quan tâm đến tên biến một chữ cái (ngoại lệ xvà y, nhưng không phải khi chúng có nghĩa là hàng và cột (đôi khi tương ứng)).

public static int intValue(long value) {
    int valueInt = (int)value;
    if (valueInt != value) {
        throw new IllegalArgumentException(
            "The long value "+value+" is not within range of the int type"
        );
    }
    return valueInt;
}

Tuy nhiên, thực sự tôi muốn tránh chuyển đổi này nếu có thể. Rõ ràng đôi khi điều đó là không thể, nhưng trong những trường hợp đó IllegalArgumentExceptiongần như chắc chắn là ngoại lệ sai khi ném liên quan đến mã khách hàng.

Các kiểu số nguyên Java được biểu diễn dưới dạng đã ký. Với đầu vào giữa 2 ³¹ và 2 ³² (hoặc -2 ³¹ và -2 ³² ), diễn viên sẽ thành công nhưng thử nghiệm của bạn sẽ thất bại.

Điều cần kiểm tra là liệu tất cả các bit cao của longtất cả có giống nhau không:

public static final long LONG_HIGH_BITS = 0xFFFFFFFF80000000L;
public static int safeLongToInt(long l) {
    if ((l & LONG_HIGH_BITS) == 0 || (l & LONG_HIGH_BITS) == LONG_HIGH_BITS) {
        return (int) l;
    } else {
        throw new IllegalArgumentException("...");
    }
}

(int) (longType + 0)

nhưng Long không thể vượt quá mức tối đa :)

Một giải pháp khác có thể là:

public int longToInt(Long longVariable)
{
    try { 
            return Integer.valueOf(longVariable.toString()); 
        } catch(IllegalArgumentException e) { 
               Log.e(e.printstackstrace()); 
        }
}

Tôi đã thử điều này trong trường hợp máy khách đang thực hiện POST và máy chủ DB chỉ hiểu các số nguyên trong khi máy khách có Long.