3 cara untuk mendapatkan angka acak di java

Penulis：Eve Cole Waktu Pembaruan：2025-05-06 04:32:01

Ini terutama memperkenalkan tiga metode untuk mendapatkan angka acak di java, terutama menggunakan fungsi acak () untuk mengimplementasikannya

Metode 1

(Tipe data) (nilai minimum + math.random ()*(nilai maksimum -minimum nilai +1)) Contoh:

 (int) (1+math.random ()*(10-1+1))

Jenis int dari 1 hingga 10

Metode 2

Dapatkan nomor acak

 untuk (int i = 0; i <30; i ++) {System.out.println ((int) (1+math.random ()*10));} (int) (1+math.random ()*10)

Metode acak dari paket java.math mendapatkan jumlah int ac acak 1-10

Rumusnya adalah: Nilai Minimum ---- Jumlah Acak Nilai Maksimum (Integral)

(Ketik) min + math.random () * nilai maksimum

Metode 3

 Acak ra = acak baru (); untuk (int i = 0; i <30; i ++) {System.out.println (ra.nextint (10) +1);}

Gunakan metode NextInt dari kelas acak dalam paket java.util untuk mendapatkan nomor acak int 1-10

Menghasilkan desimal acak antara 0 dan 1:

Untuk menghasilkan desimal acak dalam interval [0, D) dan D adalah desimal positif, Anda hanya perlu melipatgandakan nilai pengembalian metode NextDouble dengan d.

[N1, N2]

Yaitu ra.nextdouble () * (n2-n1)+n1

Beberapa cara untuk menghasilkan angka acak di java

1. Dalam J2SE, kita dapat menggunakan metode matematika.random () untuk menghasilkan nomor acak. Angka acak yang dihasilkan adalah dua kali lipat antara 0-1. Kita dapat melipatgandakannya dengan angka tertentu, misalnya, berlipat ganda dengan 100. Ini adalah acak dalam 100, yang tidak ada dalam J2Me.

2. Dalam paket java.util, kelas acak disediakan. Kita dapat membuat objek acak baru untuk menghasilkan angka acak. Ini dapat menghasilkan bilangan bulat acak, pelampung acak, ganda acak, dan panjang acak. Ini juga merupakan metode mengambil angka acak yang sering kita gunakan dalam program J2ME.

3. Ada metode CurrentTimemillis () di kelas sistem kami. Metode ini mengembalikan nomor milidetik mulai pukul 0:00:00 pada 1 Januari 1970 ke yang saat ini. Jenis pengembaliannya panjang. Kita dapat menggunakannya sebagai nomor acak. Kita dapat menggunakannya untuk memodulo beberapa angka, dan membatasi ke kisaran.

Bahkan, dalam metode konstruksi default acak, metode ketiga di atas digunakan untuk menghasilkan angka acak.

Kelas acak dalam metode dua memiliki deskripsi berikut:

Ada dua cara untuk membangun kelas java.util.random: dengan biji dan tanpa biji

Tidak ada benih:

Metode ini akan mengembalikan angka acak, dan hasilnya akan berbeda untuk setiap proses.

 Public Class RandomTest {public static void main (string [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {System.out.println (r.nextInt ());}}

Dengan biji:

Dengan cara ini, tidak peduli berapa kali program berjalan, hasil pengembalian akan sama

 public static void main (string [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ());}}}

Perbedaan antara kedua metode itu adalah

(1) Pertama, buka java doc, kita akan melihat deskripsi kelas acak:

Contoh kelas ini digunakan untuk menghasilkan aliran bilangan semu-acak, yang menggunakan benih 48-bit yang dapat dimodifikasi menggunakan rumus kongruen linier.

Jika dua instance acak dibuat dengan benih yang sama, urutan panggilan metode yang sama dilakukan untuk setiap instance dan mereka akan menghasilkan dan mengembalikan urutan angka yang sama. Untuk memastikan bahwa fitur ini diimplementasikan, kami menentukan algoritma spesifik untuk kelas acak. Untuk portabilitas penuh kode Java, implementasi Java harus memiliki kelas menggunakan semua algoritma yang ditampilkan di sini. Tetapi subclass dari kelas acak diizinkan untuk menggunakan algoritma lain selama mereka mematuhi perjanjian konvensional dari semua metode.

Java Doc telah menjelaskan kelas acak dengan sangat baik, dan tes kami telah memverifikasi ini.

(2) Jika tidak ada nomor benih yang disediakan, jumlah benih dari instance acak akan menjadi milidetik dari waktu saat ini. Anda dapat memperoleh milidetik dari waktu saat ini melalui System.currentTimemillis (). Buka kode sumber JDK dan kita dapat melihat ini dengan sangat jelas.

 acak publik () {this (system.currentTimeMillis ()); }

Selain itu:

Deskripsi Metode NextInt (), NextInt (int n) dari objek acak:

int nextInt () // Mengembalikan nomor pseudo-random berikutnya, yang merupakan nilai int yang didistribusikan secara merata dalam urutan generator angka acak ini.

int nextInt (int n) // Mengembalikan angka pseudo-random, yang merupakan nilai int yang didistribusikan secara merata antara 0 (termasuk) dan nilai yang ditentukan (tidak termasuk) yang diambil dari urutan generator angka acak ini.

Ringkasan nomor acak java

Angka acak banyak digunakan dalam praktik, seperti menghasilkan string atau angka dengan panjang tetap. Baik kemudian menghasilkan sejumlah panjang yang tidak pasti, atau melakukan seleksi acak yang disimulasikan, dll. Java menyediakan alat paling dasar yang dapat membantu pengembang mencapai semua ini.

1. Cara menghasilkan angka acak java

Di Java, ada tiga konsep umum angka acak.

1. Gunakan System.CurrentTimemillis () untuk mendapatkan jumlah milidetik tipe panjang dalam waktu saat ini.

2. Mengembalikan nilai ganda antara 0 dan 1 melalui matematika.random ().

3. Hasilkan nomor acak melalui kelas acak. Ini adalah kelas alat acak profesional dengan fungsi yang kuat.

2. Deskripsi API Acak

1. Deskripsi API Java

Sebuah contoh dari kelas acak digunakan untuk menghasilkan aliran bilangan pseudo-acak. Kelas ini menggunakan benih 48-bit dan menggunakan rumus kongruen linier untuk memodifikasinya (lihat Seni Pemrograman Komputer Donald Knuth, Volume 2, Bagian 3.2.1).

Banyak aplikasi akan menemukan metode acak di kelas matematika lebih mudah digunakan.

2. Ringkasan Metode

Acak () // Buat generator nomor acak baru.

Acak (biji panjang) // Buat generator nomor acak baru menggunakan satu benih panjang: acak publik (biji panjang) {setseed (seed); } Metode berikutnya menggunakannya untuk menyimpan status generator angka acak.

Int yang Dilindungi Next (int bits): Menghasilkan nomor pseudo-acak berikutnya.

Boolean nextboolean (): Mengembalikan angka pseudo-acak berikutnya, yang merupakan nilai boolean yang didistribusikan secara merata yang diambil dari urutan generator angka acak ini.

void nextbytes (byte [] bytes): Menghasilkan byte acak dan menempatkannya dalam array byte yang disediakan pengguna.

double nextDouble (): Mengembalikan angka pseudo-acak berikutnya, yang merupakan nilai ganda yang didistribusikan secara merata antara 0,0 dan 1.0, diambil dari urutan generator angka acak ini.

Float NextFloat (): Mengembalikan angka pseudo-acak berikutnya, yang merupakan nilai float yang didistribusikan secara merata antara 0,0 dan 1.0 yang diambil dari urutan generator angka acak ini.

Double nextgaussian (): Mengembalikan angka pseudo-acak berikutnya, yang merupakan distribusi Gaussian ("biasanya") yang diambil dari urutan generator angka acak ini, dengan nilai rata-rata 0,0 dan standar deviasi 1,0.

int nextInt (): Mengembalikan angka pseudo-acak berikutnya, yang merupakan nilai int yang didistribusikan secara merata dalam urutan generator angka acak ini.

int nextInt (int n): Mengembalikan nomor pseudo-acak yang merupakan nilai int yang didistribusikan secara seragam yang diambil dari urutan generator angka acak ini dan didistribusikan secara seragam antara 0 (termasuk) dan nilai yang ditentukan (tidak termasuk).

Long NextLong (): Mengembalikan nomor pseudo-acak berikutnya, yang merupakan nilai panjang yang didistribusikan secara seragam yang diambil dari urutan generator angka acak ini.

Void Setseed (Long Seed): Mengatur benih generator bilangan acak ini menggunakan biji panjang tunggal.

3. Instruksi Penggunaan Kelas Acak

1. Perbedaan antara mengambil biji dan tidak mengambil benih. Penggunaan mendasar kelas acak adalah untuk membagi contoh acak dengan biji dan tanpa biji.

Dalam istilah awam, perbedaan antara keduanya adalah: jika biji diproduksi, hasil yang dihasilkan oleh setiap proses adalah sama.

Jika Anda tidak memiliki biji, apa yang Anda hasilkan adalah acak setiap kali Anda berlari, dan tidak ada pola sama sekali.

2. Buat objek acak tanpa biji

 Acak acak = acak baru ();

3. Ada dua cara untuk membuat objek acak tanpa biji:

1) acak acak = acak baru (555L);

2) acak acak = acak baru (); random.setseed (555L);

4. Tes

Gunakan contoh untuk menggambarkan penggunaan di atas

 impor java.util.random; TestRandomnum kelas publik {public static void main (string [] args) {randomTest (); testnoseed (); testseed1 (); testseed2 (); } public static void randomTest () { System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- R1 = CurrentTimemillis (); System.out.println ("r2 =" + r3); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- untuk (int i = 0; i <3; i ++) {System.out.println (random.nextInt ()); }} public static void testseed1 () { System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Hasil Menjalankan:

--------------tes()--------------
R1 = 1227108626582
R3 = 0,5324887850155043
R2 = -368083737
-------------- testnoseed () --------------
809503475
1585541532
-645134204
-------------- testseed1 () --------------
-1367481220
292886146
-1462441651
-------------- testseed2 () --------------
-1367481220
292886146
-1462441651
Proses selesai dengan kode keluar 0

Melalui hasil metode testseed1 () dan testseed2 (), kita dapat melihat bahwa dua hasil cetak adalah sama karena mereka melihat hal yang sama. Jika mereka berlari lagi, hasilnya akan tetap sama. Ini adalah karakteristik bilangan acak dengan biji. Jika Anda tidak memiliki biji, hasil dari setiap proses acak.

V. Aplikasi Komprehensif

Berikut ini adalah kelas alat nomor acak yang baru ditulis untuk menunjukkan penggunaan:

 impor java.util.random; Public Class RandomUtils {public static final string allchar = "0123456789AbcDefgHiJKlMnopQrStuVWxyZabcDefgHijKlMnopqrStuVwxyz"; string final public static letterchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; public static final string numberChar = "0123456789"; Public Static String GenerAteString (panjang int) {StringBuffer SB = New StringBuffer (); Acak acak = acak baru (); untuk (int i = 0; i <panjang; i ++) {sb.append (allchar.charat (random.nextInt (allchar.length ()))); } return sb.toString (); } public static String generAteMixString (int int) {StringBuffer SB = New StringBuffer (); Acak acak = acak baru (); untuk (int i = 0; i <panjang; i ++) {sb.append (allchar.charat (random.nextInt (letterchar.length ()))); } return sb.toString (); } public static string generAteLowerString (int panjang) {return generatemixString (length) .tolowercase (); } public static String generateupperString (int panjang) {return generatemixString (length) .touppercase (); } public static String generateZerOstring (int int) {StringBuffer SB = New StringBuffer (); untuk (int i = 0; i <panjang; i ++) {sb.append ('0'); } return sb.toString (); } public static string tofixdlengthString (num panjang, int fixdlenth) {stringBuffer sb = stringBuffer baru (); String strnum = string.ValueOf (num); if (fixdlenth - strnum.length ()> = 0) {sb.append (generateZerOstring (fixdlenth - strnum.length ())); } else {lempar runtimeException baru ("Convert Number" + num + "Exception terjadi ketika pengecualian dibuat untuk string dengan panjang" + fixdlenth + ");} sb.append (strnum); return sb.toString ();} public string tofixdlengthstring (int int fixdl (); = String.ValueOf (NUM); } SB.Append (strnum); return sb.tostring (); } public static void main (string [] args) {System.out.println (generateString (15)); System.out.println (generatemixString (15)); System.out.println (GenerAteTeLowerString (15)); System.out.println (GenerateupperString (15)); System.out.println (GenerateReZerOstring (15)); System.out.println (tofixdlengthString (123, 15)); System.out.println (tofixdlengthString (123L, 15)); System.out.println (tofixdlengthString (123L, 15)); }}

Hasil Menjalankan:

VWMBPINBZFGCPHG
23hyrahdjkkpwmv
TIGOWETBWKM1NDE
BPZ1KNEJPHB115N
000000000000000000
00000000000000123
00000000000000123
Proses selesai dengan kode keluar 0

6. Ringkasan

1. Angka acak sangat umum digunakan. Ada tiga cara untuk menghasilkannya di Java. Angka acak acak adalah yang paling kompleks.

2. Objek kelas acak memiliki perbedaan antara apakah mereka membawa biji. Selama bijinya sama, mereka berjalan beberapa kali, dan hasil menghasilkan angka acak selalu sama.

3. Ada dua cara untuk membuat objek benih dengan angka acak, dengan efek yang sama. Tapi angka acak dengan biji tampaknya tidak banyak berguna.

4. Fungsi acak mencakup fungsi math.random ().

5. Anda dapat menggunakan angka acak untuk menerapkan data acak yang kompleks seperti string acak.

6. Jangan mempelajari angka acak yang tidak mengulangi, itu tidak terlalu berarti.

Di Java kita dapat menggunakan kelas java.util.random untuk menghasilkan generator angka acak. Ini memiliki dua bentuk konstruktor, yaitu acak () dan acak (biji panjang). Random () menggunakan waktu saat ini, System.currentTimemillis (), sebagai benih generator, dan acak (biji panjang) menggunakan benih yang ditentukan sebagai benih generator.

Setelah objek generator bilangan acak (acak) dihasilkan, berbagai jenis angka acak diperoleh dengan memanggil metode yang berbeda: nextInt (), nextLong (), nextFloat (), nextDouble (), dll.

1> menghasilkan angka acak

 Acak acak = acak baru (); Acak acak = acak baru (100); // Tentukan jumlah biji 100

panggilan acak berbagai metode untuk mendapatkan nomor acak.

Jika 2 objek acak menggunakan benih yang sama (misalnya, keduanya adalah 100) dan fungsi yang sama disebut dalam urutan yang sama, maka nilai pengembaliannya persis sama. Seperti dalam kode berikut, output dari dua objek acak persis sama

 impor java.util.*; kelas testrandom {public static void main (string [] args) {acak acak1 = acak baru (100); System.out.println (acak1.nextInt ()); System.out.println (acak1.nextfloat ()); System.out.println (acak1.nextboolean ()); Acak acak2 = acak baru (100); System.out.println (acak2.nextInt ()); System.out.println (acak2.nextfloat ()); System.out.println (acak2.nextboolean ()); }}

2> Angka acak dalam kisaran yang ditentukan

Angka acak dikendalikan dalam kisaran tertentu, menggunakan % operator modulus

 impor java.util.*; kelas testrandom {public static void main (string [] args) {acak acak = acak baru (); untuk (int i = 0; i <10; i ++) {System.out.println (math.abs (acak.nextInt ())); }}}

Angka acak yang diperoleh positif dan negatif. Gunakan Math.ABS untuk membuat rentang data diambil sebagai angka non-negatif.

3> Dapatkan angka acak yang tidak berulang dalam kisaran yang ditentukan

 impor java.util.*; kelas testrandom {public static void main (string [] args) {int [] intret = new int [6]; intrd = 0; // Penyimpanan Angka acak int hitung = 0; // Catat bendera int acak yang dihasilkan = 0; // apakah bendera telah dihasilkan sementara (hitung <6) {acak rdm = acak baru (System.currentTimeMillis ()); intrd = math.abs (rdm.nextint ()) 2+1; untuk (int i = 0; i <count; i ++) {if (intret [i] == intrd) {flag = 1; merusak; } else {flag = 0; }} if (flag == 0) {intret [count] = intrd; Count ++; }} untuk (int t = 0; t <6; t ++) {System.out.println (t+"->"+intret [t]); }}}

Bisakah nomor acak di java diulang? Dapatkah angka acak yang dihasilkan dalam Java digunakan untuk menghasilkan kunci primer database? Dengan pertanyaan ini dalam pikiran, kami melakukan serangkaian tes.

1. Tes 1: Gunakan konstruktor acak () tanpa parameter

 Public Class RandomTest {public static void main (string [] args) {java.util.random r = new java.util.random (); untuk (int i = 0; i <10; i ++) {System.out.println (r.nextInt ()); }}}

Hasil menjalankan program:

-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157

Jalankan program lagi:

-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608

Dari tes di atas kita dapat melihat bahwa angka acak yang dihasilkan dengan menggunakan konstruktor acak () tanpa parameter tidak akan diulang. Jadi, dalam keadaan apa Java menghasilkan angka acak duplikat? Mari kita lihat tes di bawah ini.

2. Tes 2: Atur jumlah biji untuk acak

 kelas publik randomTest_repeat {public static void main (string [] args) {java.util.random r = new java.util.random (10); untuk (int i = 0; i <10; i ++) {System.out.println (r.nextInt ()); }}}

Tidak peduli berapa kali program berjalan, hasilnya selalu:

-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428

Bahkan jika Anda mengujinya pada mesin yang berbeda, hasil tes tidak akan berubah!

3. Analisis Penyebab:

(1) Pertama, buka java doc, kita akan melihat deskripsi kelas acak:

Contoh kelas ini digunakan untuk menghasilkan aliran bilangan semu-acak, yang menggunakan benih 48-bit yang dapat dimodifikasi menggunakan formula kongruen linier (lihat Seni Pemrograman Komputer Donald Knuth, Volume 2, Bagian 3.2.1).

Java Doc telah menjelaskan kelas acak dengan sangat baik, dan tes kami telah memverifikasi ini.

 acak publik () {this (system.currentTimeMillis ()); }

4. Kesimpulan:

Melalui tes dan analisis di atas, kami akan memiliki pemahaman yang lebih dalam tentang kelas acak. Pada saat yang sama, saya pikir dengan membaca dokumentasi API Java Doc, kemampuan pemrograman Java kami dapat sangat ditingkatkan dan "mengetahui kebenaran" dapat dicapai; Setelah kita mengalami masalah bingung, kita mungkin juga membuka kode sumber Java sehingga kita dapat "mengetahui kebenaran".

Umumnya ada dua jenis angka acak di java, satu adalah metode acak () dalam matematika, dan yang lainnya adalah kelas acak.

1. Math.random ()

Jumlah desimal 0 <x <1 dihasilkan.

Contoh: Bagaimana cara menulis dan menghasilkan secara acak salah satu angka dari 0 hingga 100?

Math.random () hanya mengembalikan desimal dari 0 hingga 1. Jika Anda ingin 50 hingga 100, Anda akan memperbesar 50 kali lebih dulu, yaitu antara 0 dan 50. Di sini masih desimal. Jika Anda menginginkan bilangan bulat, Anda akan menggunakan int, dan kemudian menambahkan 50 hingga 50 hingga 100.

Kode akhir: (int) (math.random ()*50) + 50

2. Kelas acak

 Acak acak = acak baru (); // konstruktor default acak acak = acak baru (1000); // Tentukan nomor benih

Saat melakukan pengacakan, jumlah asal algoritma acak disebut biji, yang melakukan transformasi tertentu berdasarkan pada biji, sehingga menghasilkan angka acak yang diperlukan.
Objek acak dengan jumlah biji yang sama, angka acak yang dihasilkan oleh jumlah kali yang sama persis sama. Dengan kata lain, untuk dua objek acak dengan nomor benih yang sama, angka acak yang dihasilkan untuk pertama kalinya persis sama, dan angka acak yang dihasilkan untuk kedua kalinya persis sama.

2. Metode umum di kelas acak

Metode dalam kelas acak relatif sederhana, dan fungsi masing -masing metode juga mudah dipahami. Perlu dicatat bahwa angka acak yang dihasilkan oleh setiap metode di kelas acak terdistribusi secara seragam, yang berarti bahwa probabilitas generasi numerik dalam interval adalah sama. Berikut adalah pengantar dasar untuk metode ini:

A, boolean publik nextboolean ()

Fungsi metode ini adalah untuk menghasilkan nilai boolean acak, dan probabilitas menghasilkan nilai benar dan salah adalah sama, yaitu, keduanya 50%.

B, double public nextDouble ()

Tujuan dari metode ini adalah untuk menghasilkan nilai ganda acak, nilainya adalah antara [0, 1.0). Di sini, tanda kurung mewakili titik akhir yang berisi interval, dan tanda kurung mewakili titik akhir yang tidak termasuk interval, yaitu, desimal acak antara 0 dan 1, berisi 0 tetapi tidak 1.0.

C, int nextint publik ()

Tujuan dari metode ini adalah untuk menghasilkan nilai int acak, yaitu antara kekuatan ke -31 dari kekuatan -2 dan ke -31 kekuatan -1 dari 2 dari 2.

Jika Anda perlu menghasilkan nilai int untuk interval tertentu, Anda perlu melakukan transformasi matematika tertentu. Untuk detailnya, silakan merujuk ke kode dalam contoh penggunaan di bawah ini.

D, int nextint publik (int n)

Fungsi metode ini adalah untuk menghasilkan nilai int acak, yang berada dalam interval [0, n), yaitu, nilai int acak antara 0 dan n, yang mengandung 0 tetapi tidak n.

Jika Anda ingin menghasilkan nilai int untuk interval tertentu, Anda juga perlu melakukan transformasi matematika tertentu. Untuk detailnya, silakan merujuk ke kode dalam contoh penggunaan di bawah ini.

E, setseed public void (biji panjang)

Tujuan dari metode ini adalah untuk mengatur ulang jumlah benih dalam objek acak. Setelah mengatur jumlah biji, objek acak sama dengan objek acak yang dibuat dengan kata kunci baru.

3. Contoh Penggunaan Kelas Acak

Menggunakan kelas acak, umumnya menghasilkan angka acak untuk interval yang ditentukan. Berikut ini akan memperkenalkan cara menghasilkan angka acak untuk interval yang sesuai satu per satu. Kode berikut yang menghasilkan angka acak dihasilkan menggunakan objek acak berikut r:

 Acak r = acak baru ();

A. Menghasilkan desimal interval [0,1.0)

 Double D1 = R.NextDouble ();

Ini diperoleh secara langsung menggunakan metode NextDouble.

B. Menghasilkan desimal interval [0,5.0)

 double d2 = r.nextdouble () * 5;

Karena interval angka yang dihasilkan oleh metode NextDouble adalah [0, 1.0), memperluas interval dengan 5 kali adalah interval yang diperlukan.

Demikian pula, untuk menghasilkan desimal acak dalam interval [0, d) dan D adalah desimal positif, Anda hanya perlu melipatgandakan nilai pengembalian metode NextDouble dengan d.

C. Menghasilkan angka desimal [N1, N2] dari interval [1, 2.5) [1]

d3 d3 = r.nextdouble () * 1.5 + 1; 【yaitu, r.nextdouble () * (n2-n1) + n1】

Untuk menghasilkan desimal acak dari interval [1, 2.5) Anda hanya perlu terlebih dahulu menghasilkan jumlah acak interval [0, 1.5) dan kemudian tambahkan 1 ke interval bilangan acak yang dihasilkan.

Demikian pula, untuk menghasilkan angka acak dalam kisaran interval desimal [D1, D2) yang tidak dimulai dari 0 (di mana D1 tidak sama dengan 0), Anda hanya perlu menghasilkan angka acak terlebih dahulu dalam interval [0, D2-D1) dan kemudian menambahkan interval angka acak yang dihasilkan ke D1.

D. Menghasilkan bilangan bulat

 int n1 = r.nextInt ();

Cukup gunakan metode NextInt secara langsung.

e. Menghasilkan bilangan bulat dalam interval [0,10)

 int n2 = r.nextInt (10); n2 = math.abs (r.nextint () % 10);

Dua baris kode di atas dapat menghasilkan bilangan bulat dalam interval [0,10).

Implementasi pertama diterapkan secara langsung menggunakan metode NextInt (int n) di kelas acak.

Dalam implementasi kedua, metode panggilan pertama nextInt () untuk menghasilkan nomor int yang sewenang -wenang. Interval yang dihasilkan oleh jumlah jumlah angka 10 adalah (-10,10), karena menurut spesifikasi matematika, nilai absolut sisanya kurang dari pembagi, dan kemudian nilai absolut dari interval dihitung, dan interval yang dihasilkan adalah [0,10).

Demikian pula, untuk menghasilkan bilangan bulat acak dalam interval apa pun [0, n) Anda dapat menggunakan kode berikut:

 int n2 = r.nextint (n); n2 = math.abs (r.nextint () % n);

F. Menghasilkan bilangan bulat dalam interval [0,10]

 int n3 = r.nextInt (11); n3 = math.abs (r.nextint () % 11);

Dibandingkan dengan interval integer, interval [0,10] dan interval [0,11) setara, sehingga integer interval [0,11) dihasilkan.

G. Menghasilkan bilangan bulat dalam interval [-3,15)

 int n4 = r.nextint (18) - 3; // 【yaitu, r.nextint () * (n2 -n1)+n1】 n1 adalah angka negatif n4 = math.abs (r.nextint () % 18) - 3;

Untuk menghasilkan bilangan bulat acak yang tidak dimulai dari 0, Anda dapat merujuk pada deskripsi di atas dari prinsip implementasi interval desimal yang tidak dimulai dari 0.

Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.