Pengecoran aman untuk int di Jawa

Apa cara paling idiomatis di Jawa untuk memverifikasi bahwa para pemain dari longke inttidak kehilangan informasi apa pun?

Ini adalah implementasi saya saat ini:

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

Metode baru telah ditambahkan dengan Java 8 untuk melakukan hal itu.

import static java.lang.Math.toIntExact;

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

Akan melempar ArithmeticExceptionjika terjadi luapan.

Lihat: Math.toIntExact(long)

Beberapa metode overflow aman lainnya telah ditambahkan ke Java 8. Mereka berakhir dengan tepat .

Contoh:

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

Saya pikir saya akan melakukannya sesederhana:

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

Saya pikir itu mengekspresikan maksud lebih jelas daripada casting berulang ... tapi itu agak subyektif.

Catatan minat potensial - dalam C # itu hanya akan menjadi:

return checked ((int) l);

Dengan kelas Inva Google Guava , metode Anda dapat diubah menjadi:

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

Dari dokumen tertaut:

checkedCast

public static int checkedCast(long value)

Mengembalikan nilai int yang sama dengan value, jika memungkinkan.

Parameter: value - nilai apa pun dalam kisaran intjenis

Pengembalian: dengan intnilai yang sama denganvalue

Melempar: IllegalArgumentException - jika valuelebih besar dari Integer.MAX_VALUEatau kurang dariInteger.MIN_VALUE

Kebetulan, Anda tidak memerlukan safeLongToIntpembungkus, kecuali Anda ingin membiarkannya di tempat untuk mengubah fungsi tanpa tentu saja refactoring yang luas.

Dengan BigDecimal:

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

berikut ini solusinya, jika Anda tidak peduli dengan nilai jika itu lebih besar dari yang dibutuhkan;)

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

DONT: Ini bukan solusi!

Pendekatan pertama saya adalah:

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

Tapi itu hanya sekedar melemparkan long ke int, berpotensi menciptakan Longinstance baru atau mengambilnya dari Long pool.

Kekurangannya

1. Long.valueOfmembuat Longcontoh baru jika nomor tersebut tidak berada dalam Longkisaran kumpulan [-128, 127].

2. The intValuepelaksanaan tidak apa-apa lebih dari:

   return (int)value;

Jadi ini bisa dianggap lebih buruk daripada hanya melemparkan longke int.

Saya mengklaim bahwa cara yang jelas untuk melihat apakah casting nilai mengubah nilainya adalah dengan melemparkan dan memeriksa hasilnya. Saya akan, bagaimanapun, menghapus pemain yang tidak perlu saat membandingkan. Saya juga tidak terlalu tertarik pada satu nama variabel huruf (pengecualian xdan y, tetapi tidak ketika itu berarti baris dan kolom (kadang-kadang masing-masing)).

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

Namun, sungguh saya ingin menghindari konversi ini jika memungkinkan. Jelas kadang-kadang itu tidak mungkin, tetapi dalam kasus-kasus IllegalArgumentExceptionitu hampir pasti pengecualian yang salah untuk membuang sejauh kode klien yang bersangkutan.

Jenis integer Java direpresentasikan sebagai ditandatangani. Dengan input antara 2 ³¹ dan 2 ³² (atau -2 ³¹ dan -2 ³² ) para pemain akan berhasil tetapi tes Anda akan gagal.

Yang perlu diperiksa adalah apakah semua bit tinggi longsemua sama:

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)

tapi Panjang tidak bisa melebihi maksimum :)

Satu solusi lain dapat:

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

Saya telah mencoba ini untuk kasus-kasus di mana klien melakukan POST dan server DB hanya memahami bilangan bulat sementara klien memiliki panjang.