Kaedah Baru Matematik Java 8

1. Pengenalan

Biasanya, ketika kita memikirkan tentang ciri baru yang disertakan dengan versi 8 Java, pengaturcaraan fungsional dan ekspresi lambda adalah perkara pertama yang terlintas di fikiran.

Walaupun begitu, selain ciri-ciri besar itu ada yang lain, mungkin mempunyai kesan yang lebih kecil tetapi juga menarik dan berkali-kali tidak begitu terkenal atau bahkan diliputi oleh sebarang ulasan.

Dalam tutorial ini, kami akan menghitung dan memberikan sedikit contoh setiap kaedah baru yang ditambahkan pada salah satu kelas teras bahasa: java.lang.Math .

2. Kaedah baru * tepat ()

Pertama, kami mempunyai sekumpulan kaedah baru yang memperluas beberapa operasi aritmetik yang ada dan yang paling biasa.

Seperti yang akan kita lihat, mereka cukup jelas, kerana mereka mempunyai fungsi yang sama persis dengan kaedah yang mereka hasilkan tetapi dengan penambahan pengecualian sekiranya berlaku, nilai yang dihasilkan melampaui nilai maksimum atau min dari jenisnya .

Kita boleh menggunakan kaedah ini dengan bilangan bulat dan panjang sebagai parameter.

2.1. tambahExact ()

Menambah dua parameter, melemparkan ArithmeticException sekiranya berlaku limpahan (yang berlaku untuk semua kaedah * Tepat () ) penambahan:

Math.addExact(100, 50); // returns 150 Math.addExact(Integer.MAX_VALUE, 1); // throws ArithmeticException

2.2. substrakExact ()

Mengurangkan nilai parameter kedua dari yang pertama, melemparkan ArithmeticException sekiranya berlaku limpahan pengurangan:

Math.subtractExact(100, 50); // returns 50 Math.subtractExact(Long.MIN_VALUE, 1); // throws ArithmeticException

2.3. kenaikanExact ()

Menambah parameter satu, melemparkan ArithmeticException sekiranya berlaku limpahan:

Math.incrementExact(100); // returns 101 Math.incrementExact(Integer.MAX_VALUE); // throws ArithmeticException

2.4. penurunanExact ()

Menurunkan parameter satu, melemparkan ArithmeticException sekiranya berlaku limpahan:

Math.decrementExact(100); // returns 99 Math.decrementExact(Long.MIN_VALUE); // throws ArithmeticException

2.5. darabExact ()

Gandakan dua parameter, lemparkan ArithmeticException sekiranya berlaku limpahan produk:

Math.multiplyExact(100, 5); // returns 500 Math.multiplyExact(Long.MAX_VALUE, 2); // throws ArithmeticException

2.6. negateExact ()

Mengubah tanda parameter, membuang ArithmeticException sekiranya berlaku limpahan.

Dalam kes ini, kita harus memikirkan perwakilan dalaman dari nilai dalam memori untuk memahami mengapa ada limpahan, seperti tidak intuitif seperti kaedah "tepat" yang lain:

Math.negateExact(100); // returns -100 Math.negateExact(Integer.MIN_VALUE); // throws ArithmeticException

Contoh kedua memerlukan penjelasan kerana tidak jelas: Limpahan disebabkan oleh Integer.MIN_VALUE menjadi .12.147.483.648, dan di sisi lain Integer.MAX_VALUE menjadi 2.147.483.647 sehingga nilai yang dikembalikan tidak sesuai dengan Integer oleh satu unit.

3. Kaedah Lain

3.1. lantaiDiv ()

Membahagi parameter pertama dengan yang kedua, dan kemudian melakukan operasi lantai () atas hasilnya, mengembalikan Integer yang kurang atau sama dengan hasilnya :

Math.floorDiv(7, 2)); // returns 3 

Hasil tambah tepat ialah 3.5 jadi lantai (3.5) == 3.

Mari lihat contoh lain:

Math.floorDiv(-7, 2)); // returns -4 

Hasil tambah tepat ialah -3.5 jadi lantai (-3.5) == -4.

3.2. modDiv ()

Yang ini serupa dengan kaedah sebelumnya lantaiDiv () , tetapi menerapkan operasi lantai () di atas modulus atau baki bahagian dan bukannya hasilnya:

Math.modDiv(5, 3)); // returns 2 

Seperti yang kita lihat, modDiv () untuk dua nombor positif adalah sama dengan% operator . Mari lihat contoh yang berbeza:

Math.modDiv(-5, 3)); // returns 1 

Ia mengembalikan 1 dan bukan 2 kerana floorDiv (-5, 3) adalah -2 dan bukan -1.

3.3. seterusnyaDown ()

Mengembalikan nilai parameter yang lebih rendah (menyokong parameter float atau double ):

float f = Math.nextDown(3); // returns 2.9999998 double d = Math.nextDown(3); // returns 2.999999761581421

4. Kesimpulan

Dalam artikel ini, kami telah menerangkan secara ringkas fungsi semua kaedah baru yang ditambahkan ke kelas java.lang.Math dalam versi 8 platform Java dan juga melihat beberapa contoh cara menggunakannya.

Seperti biasa, kod sumber penuh tersedia di GitHub.