ส่วนใหญ่จะแนะนำสามวิธีในการรับตัวเลขสุ่มใน Java ส่วนใหญ่ใช้ฟังก์ชันสุ่ม () เพื่อนำไปใช้
วิธีที่ 1
(ประเภทข้อมูล) (ค่าต่ำสุด + math.random ()*(ค่าสูงสุด -minimum value +1)) ตัวอย่าง:
(int) (1+math.random ()*(10-1+1)))
ประเภท int ตั้งแต่ 1 ถึง 10
วิธีที่ 2
รับหมายเลขสุ่ม
สำหรับ (int i = 0; i <30; i ++) {system.out.println ((int) (1+math.random ()*10));} (int) (1+math.random ()*10) วิธีการสุ่มของแพ็คเกจ java.math ได้รับจำนวน int สุ่มจำนวน 1-10
สูตรคือ: ค่าต่ำสุด ---- จำนวนสุ่มของค่าสูงสุด (อินทิกรัล)
(ประเภท) min + math.random () * ค่าสูงสุด
วิธีที่ 3
สุ่ม ra = new random (); สำหรับ (int i = 0; i <30; i ++) {system.out.println (ra.nextint (10) +1);} ใช้วิธี Nextint ของคลาสสุ่มในแพ็คเกจ java.util เพื่อรับจำนวน int สุ่ม 1-10
สร้างทศนิยมแบบสุ่มระหว่าง 0 ถึง 1:
ในการสร้างทศนิยมแบบสุ่มในช่วงเวลา [0, D) และ D เป็นทศนิยมเชิงบวกใด ๆ คุณจะต้องคูณค่าผลตอบแทนของวิธี NextDouble โดย D
[N1, N2]
นั่นคือ ra.nextdouble () * (n2-n1)+n1
หลายวิธีในการสร้างตัวเลขสุ่มใน Java
1. ใน J2SE เราสามารถใช้วิธี Math.Random () เพื่อสร้างหมายเลขสุ่ม หมายเลขสุ่มที่สร้างขึ้นเป็นสองเท่าระหว่าง 0-1 เราสามารถคูณด้วยตัวเลขที่แน่นอนเช่นคูณด้วย 100 มันเป็นการสุ่มภายใน 100 ซึ่งไม่มีอยู่ใน J2ME
2. ในแพ็คเกจ java.util มีการสุ่มคลาส เราสามารถสร้างวัตถุสุ่มใหม่เพื่อสร้างตัวเลขสุ่ม มันสามารถสร้างจำนวนเต็มแบบสุ่มลอยแบบสุ่มคู่แบบสุ่มและแบบสุ่มยาว นี่เป็นวิธีการใช้ตัวเลขสุ่มที่เรามักใช้ในโปรแกรม J2ME
3. มีวิธี CurrentTimeMillis () ในคลาสระบบของเรา วิธีนี้ส่งคืนหมายเลขมิลลิวินาทีตั้งแต่เวลา 0:00:00 น. ของวันที่ 1 มกราคม 1970 ถึงหมายเลขปัจจุบัน ประเภทการส่งคืนนั้นยาว เราสามารถใช้เป็นหมายเลขสุ่ม เราสามารถใช้กับโมดูโลบางหมายเลขและ จำกัด ไว้ในช่วง
ในความเป็นจริงในวิธีการก่อสร้างเริ่มต้นของแบบสุ่มวิธีที่สามด้านบนใช้เพื่อสร้างตัวเลขสุ่ม
คลาสแบบสุ่มในวิธีการที่สองมีคำอธิบายต่อไปนี้:
มีสองวิธีในการสร้าง Java.util.random Class: ด้วยเมล็ดและไม่มีเมล็ด
ไม่มีเมล็ด:
วิธีนี้จะส่งคืนตัวเลขสุ่มและผลลัพธ์จะแตกต่างกันสำหรับการรันแต่ละครั้ง
คลาสสาธารณะแบบสุ่ม {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {java.util.random r = ใหม่ java.util.random (); สำหรับ (int i = 0; i <10; i ++) {system.out.println (r.nextint (); กับเมล็ด:
ด้วยวิธีนี้ไม่ว่าโปรแกรมจะทำงานกี่ครั้งผลตอบแทนจะเท่ากัน
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {java.util.random r = ใหม่ java.util.random (10); สำหรับ (int i = 0; i <10; i ++) {system.out.println (r.nextint ());}}}}}}}}}}}} ความแตกต่างระหว่างสองวิธีคือ
(1) ก่อนอื่นโปรดเปิดเอกสาร Java เราจะเห็นคำอธิบายของคลาสสุ่ม:
ตัวอย่างของคลาสนี้ใช้ในการสร้างสตรีมหมายเลขหลอกแบบหลอกซึ่งใช้เมล็ด 48 บิตที่สามารถแก้ไขได้โดยใช้สูตรสอดคล้องเชิงเส้น
หากมีการสร้างอินสแตนซ์แบบสุ่มสองรายการด้วยเมล็ดเดียวกันการเรียกวิธีการเรียกวิธีการแบบเดียวกันกับแต่ละอินสแตนซ์และพวกเขาจะสร้างและส่งกลับลำดับของตัวเลขเดียวกัน เพื่อให้แน่ใจว่าคุณลักษณะนี้ถูกนำไปใช้เราจึงระบุอัลกอริทึมเฉพาะสำหรับการสุ่มคลาส สำหรับการพกพาเต็มรูปแบบของรหัส Java การใช้งาน Java จะต้องมีคลาสสุ่มใช้อัลกอริทึมทั้งหมดที่แสดงที่นี่ แต่คลาสย่อยของคลาสสุ่มได้รับอนุญาตให้ใช้อัลกอริทึมอื่น ๆ ตราบใดที่พวกเขาปฏิบัติตามข้อตกลงทั่วไปของวิธีการทั้งหมด
Java Doc ได้อธิบายชั้นเรียนแบบสุ่มเป็นอย่างดีและการทดสอบของเราได้ตรวจสอบสิ่งนี้แล้ว
(2) หากไม่มีหมายเลขเมล็ดจำนวนเมล็ดของอินสแตนซ์แบบสุ่มจะเป็นมิลลิวินาทีของเวลาปัจจุบัน คุณสามารถรับมิลลิวินาทีของเวลาปัจจุบันผ่าน System.currenttimemillis () เปิดซอร์สโค้ดของ JDK และเราสามารถเห็นสิ่งนี้ได้อย่างชัดเจน
สุ่มสาธารณะ () {this (system.currenttimeMillis ()); - นอกจากนี้:
คำอธิบายของวิธี Nextint (), NextInt (int n) ของวัตถุสุ่ม:
int nextint () // ส่งคืนหมายเลข pseudo-random ถัดไปซึ่งเป็นค่า int ที่กระจายอย่างสม่ำเสมอในลำดับของเครื่องกำเนิดหมายเลขสุ่มนี้
int nextint (int n) // ส่งคืนหมายเลข pseudo-random ซึ่งเป็นค่า int กระจายอย่างสม่ำเสมอระหว่าง 0 (รวม) และค่าที่ระบุ (ไม่รวม) ที่นำมาจากลำดับของเครื่องกำเนิดตัวเลขสุ่มนี้
สรุปหมายเลขสุ่ม Java
ตัวเลขสุ่มถูกนำมาใช้อย่างกว้างขวางในทางปฏิบัติเช่นการสร้างสตริงหรือตัวเลขที่มีความยาวคงที่ ไม่ว่าจะสร้างความยาวที่ไม่แน่นอนจำนวนหนึ่งหรือทำการเลือกแบบสุ่มแบบจำลอง ฯลฯ Java เป็นเครื่องมือพื้นฐานที่สุดที่สามารถช่วยให้นักพัฒนาบรรลุเป้าหมายทั้งหมดนี้
1. วิธีสร้างตัวเลขสุ่ม Java
ในชวามีสามแนวคิดทั่วไปของตัวเลขสุ่ม
1. ใช้ System.currentTimeMillis () เพื่อรับจำนวนมิลลิวินาทีในเวลายาว ๆ
2. ส่งคืนค่าสองเท่าระหว่าง 0 และ 1 ผ่านทางคณิตศาสตร์ random ()
3. สร้างหมายเลขสุ่มผ่านคลาสสุ่ม นี่คือคลาสเครื่องมือแบบสุ่มแบบมืออาชีพที่มีฟังก์ชั่นที่ทรงพลัง
2. คำอธิบาย API แบบสุ่ม
1. คำอธิบาย Java API
อินสแตนซ์ของคลาสแบบสุ่มใช้เพื่อสร้างสตรีมหมายเลขเทียม คลาสนี้ใช้เมล็ด 48 บิตและใช้สูตรเชิงเส้นสอดคล้องกันเพื่อปรับเปลี่ยน (ดูการเขียนโปรแกรมศิลปะคอมพิวเตอร์ของโดนัลด์ Knuth เล่มที่ 2 ส่วนที่ 3.2.1)
หากมีการสร้างอินสแตนซ์แบบสุ่มสองรายการด้วยเมล็ดเดียวกันการเรียกวิธีการเรียกวิธีการแบบเดียวกันกับแต่ละอินสแตนซ์และพวกเขาจะสร้างและส่งกลับลำดับของตัวเลขเดียวกัน เพื่อให้แน่ใจว่าการใช้แอตทริบิวต์จะมีการระบุอัลกอริทึมเฉพาะสำหรับการสุ่มคลาส
แอปพลิเคชันจำนวนมากจะพบวิธีการสุ่มในคลาสคณิตศาสตร์ใช้งานง่ายขึ้น
2. วิธีการสรุปวิธี
สุ่ม () // สร้างเครื่องกำเนิดหมายเลขสุ่มใหม่
สุ่ม (เมล็ดยาว) // สร้างเครื่องกำเนิดตัวเลขสุ่มใหม่โดยใช้เมล็ดยาวเดี่ยว: สุ่มสาธารณะ (เมล็ดยาว) {setseed (เมล็ด); } วิธีต่อไปใช้เพื่อบันทึกสถานะของเครื่องกำเนิดหมายเลขสุ่ม
ได้รับการป้องกัน int ถัดไป (int bits): สร้างหมายเลขหลอกหลอกถัดไป
บูลีน NextBoolean (): ส่งคืนหมายเลขหลอกหลอกครั้งต่อไปซึ่งเป็นค่าบูลีนแบบกระจายอย่างสม่ำเสมอที่นำมาจากลำดับของเครื่องกำเนิดหมายเลขสุ่มนี้
ถือเป็นโมฆะ nextbytes (ไบต์ [] ไบต์): สร้างไบต์แบบสุ่มและวางไว้ในอาร์เรย์ไบต์ที่ผู้ใช้ให้ไว้
Double NextDouble (): ส่งคืนหมายเลขหลอกหลอกถัดไปซึ่งเป็นค่าสองเท่ากระจายอย่างเท่าเทียมกันระหว่าง 0.0 และ 1.0 นำมาจากลำดับของเครื่องกำเนิดตัวเลขสุ่มนี้
Float NextFloat (): ส่งคืนหมายเลขหลอกหลอกถัดไปซึ่งเป็นค่าลอยตัวอย่างเท่าเทียมกันระหว่าง 0.0 และ 1.0 ที่นำมาจากลำดับของเครื่องกำเนิดตัวเลขสุ่มนี้
Double nextgaussian (): ส่งคืนหมายเลขหลอกหลอกถัดไปซึ่งเป็นการกระจายแบบเกาส์ ("ปกติ") ที่นำมาจากลำดับของเครื่องกำเนิดตัวเลขสุ่มนี้โดยมีค่าเฉลี่ย 0.0 และค่าเบี่ยงเบนมาตรฐาน 1.0
int nextint (): ส่งคืนหมายเลขหลอกหลอกถัดไปซึ่งเป็นค่า int ที่กระจายอย่างสม่ำเสมอในลำดับของเครื่องกำเนิดหมายเลขสุ่มนี้
int nextint (int n): ส่งคืนหมายเลขหลอกหลอกซึ่งเป็นค่า int ที่กระจายอย่างสม่ำเสมอที่นำมาจากลำดับของเครื่องกำเนิดตัวเลขสุ่มนี้และมีการกระจายอย่างสม่ำเสมอระหว่าง 0 (รวม) และค่าที่ระบุ (ยกเว้น)
Long Next Long (): ส่งคืนหมายเลข Pseudo-random ถัดไปซึ่งเป็นค่ายาวที่กระจายอย่างสม่ำเสมอที่นำมาจากลำดับของเครื่องกำเนิดตัวเลขสุ่มนี้
Void Setseed (เมล็ดยาว): ตั้งค่าเมล็ดของเครื่องกำเนิดจำนวนสุ่มนี้โดยใช้เมล็ดยาวเดี่ยว
3. คำแนะนำการใช้งานชั้นเรียนแบบสุ่ม
1. ความแตกต่างระหว่างการรับเมล็ดและไม่ได้รับเมล็ด การใช้พื้นฐานของชั้นเรียนแบบสุ่มคือการแบ่งตัวอย่างของการสุ่มด้วยเมล็ดและไม่มีเมล็ด
ในแง่ของ Layman ความแตกต่างระหว่างทั้งสองคือ: หากมีการผลิตเมล็ดผลลัพธ์ที่เกิดจากการวิ่งแต่ละครั้งจะเหมือนกัน
หากคุณไม่มีเมล็ดสิ่งที่คุณสร้างขึ้นจะสุ่มทุกครั้งที่คุณวิ่งและไม่มีรูปแบบเลย
2. สร้างวัตถุสุ่มโดยไม่มีเมล็ด
สุ่มสุ่ม = ใหม่สุ่ม ();
3. มีสองวิธีในการสร้างวัตถุสุ่มโดยไม่มีเมล็ด:
1) สุ่มสุ่ม = สุ่มใหม่ (555L);
2) สุ่มสุ่ม = ใหม่สุ่ม (); สุ่มตั้งค่า (555L);
4. ทดสอบ
ใช้ตัวอย่างเพื่อแสดงการใช้งานด้านบน
นำเข้า java.util.random; Public Class TestRandomNum {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {randomTest (); testnoseed (); testseed1 (); testseed2 (); } โมฆะแบบคงที่สาธารณะแบบสุ่ม () { System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- r1 = system.currenttimemillis (); System.out.println ("R2 =" + R3); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ สำหรับ (int i = 0; i <3; i ++) {system.out.println (random.nextint ()); }} โมฆะคงที่สาธารณะ testseed1 () { System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - ผลการทำงาน:
--------------ทดสอบ()--------------
R1 = 1227108626582
R3 = 0.5324887850155043
R2 = -368083737
-------------- TestNoseed () ------------------
809503475
1585541532
-645134204
-------------- Testseed1 () -------------------
-1367481220
292886146
-1462441651
-------------- Testseed2 () ------------------
-1367481220
292886146
-1462441651
กระบวนการเสร็จสิ้นด้วยรหัสออก 0
ผ่านผลลัพธ์ของวิธีการทดสอบ 1 () และ testseed2 () เราจะเห็นว่าผลลัพธ์การพิมพ์ทั้งสองนั้นเหมือนกันเพราะเห็นเหมือนกัน หากพวกเขาทำงานอีกครั้งผลลัพธ์จะยังคงเหมือนเดิม นี่คือลักษณะของตัวเลขสุ่มที่มีเมล็ด หากคุณไม่มีเมล็ดผลลัพธ์ของการวิ่งแต่ละครั้งจะสุ่ม
V. แอปพลิเคชันที่ครอบคลุม
ต่อไปนี้เป็นคลาสเครื่องมือหมายเลขสุ่มที่เขียนเมื่อเร็ว ๆ นี้เพื่อแสดงการใช้งาน:
นำเข้า java.util.random; Public Class RandomUtils {สตริงคงสุดท้ายสาธารณะ allchar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"; สาธารณะคงที่สตริงสุดท้าย retingchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; public Static Final String NumberChar = "0123456789"; String String สาธารณะ generatestring (ความยาว int) {StringBuffer SB = new StringBuffer (); สุ่มสุ่ม = ใหม่สุ่ม (); สำหรับ (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (allchar.length ())))); } return sb.toString (); } String String สาธารณะ GenerateMixString (ความยาว int) {StringBuffer SB = new StringBuffer (); สุ่มสุ่ม = ใหม่สุ่ม (); สำหรับ (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (letterchar.length ())))); } return sb.toString (); } สตริงคงที่สาธารณะ generateLowerString (ความยาว int) {return generatemixstring (ความยาว) .toLowerCase (); } สตริงคงที่สาธารณะ generateupperstring (ความยาว int) {return generatemixstring (ความยาว) .touppercase (); } สตริงคงที่สาธารณะ generateZerOstring (ความยาว int) {StringBuffer SB = new StringBuffer (); สำหรับ (int i = 0; i <length; i ++) {sb.append ('0'); } return sb.toString (); } สตริงคงที่สาธารณะ tofixDlengthString (Long num, int fixdlenth) {StringBuffer SB = new StringBuffer (); strnum = string.valueof (num); if (fixdlenth - strnum.length ()> = 0) {sb.append (generatezerostring (fixdlenth - strnum.length ())); } else {โยน runtimeException ใหม่ ("แปลงหมายเลข" + num + "เกิดขึ้นเมื่อมีการยกเว้นกับสตริงที่มีความยาว" + fixdlenth + ");} sb.append (strnum); return sb.toString () {string String sb.toString string.valueof (num); ถ้า (fixdlenth - strnum.length ()> = 0) {sb.append (generatezerostring (fixdlenth - strnum.length ()); } sb.append (strnum); ส่งคืน sb.toString (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {system.out.println (generatestring (15)); System.out.println (GeneratemixString (15)); System.out.println (GenerateLowerString (15)); System.out.println (generateupperstring (15)); System.out.println (generatezerostring (15)); System.out.println (TofixDlengthString (123, 15)); System.out.println (TofixDlengthString (123L, 15)); System.out.println (TofixDlengthString (123L, 15)); -ผลการทำงาน:
VWMBPINBZFGCPHG
23HyraHdjkkpwmv
tigowetbwkm1nde
BPZ1KNEJPHB115N
000000000000000000
00000000000000123
00000000000000123
กระบวนการเสร็จสิ้นด้วยรหัสออก 0
6. สรุป
1. ตัวเลขสุ่มมักใช้กันมาก มีสามวิธีในการสร้างพวกเขาในชวา ตัวเลขสุ่มแบบสุ่มนั้นซับซ้อนที่สุด
2. วัตถุคลาสแบบสุ่มมีความแตกต่างกันว่าพวกเขามีเมล็ดพันธุ์ ตราบใดที่เมล็ดยังคงเหมือนเดิมพวกมันจะทำงานหลายครั้งและผลลัพธ์ของการสร้างตัวเลขแบบสุ่มก็เหมือนกันเสมอ
3. มีสองวิธีในการสร้างวัตถุเมล็ดที่มีตัวเลขสุ่มโดยมีเอฟเฟกต์เดียวกัน แต่ตัวเลขสุ่มที่มีเมล็ดดูเหมือนจะไม่ได้ใช้งานมากนัก
4. ฟังก์ชั่นของแบบสุ่มครอบคลุมฟังก์ชั่นของ Math.random ()
5. คุณสามารถใช้ตัวเลขสุ่มเพื่อใช้ข้อมูลสุ่มที่ซับซ้อนเช่นสตริงแบบสุ่ม
6. อย่าศึกษาตัวเลขสุ่มที่ไม่ทำซ้ำมันไม่ได้มีความหมายมากนัก
ใน Java เราสามารถใช้คลาส java.util.random เพื่อสร้างเครื่องกำเนิดตัวเลขแบบสุ่ม มันมีสองรูปแบบของตัวสร้างคือสุ่ม () และสุ่ม (เมล็ดยาว) Random () ใช้เวลาปัจจุบัน System.currentTimeMillis () เป็นเมล็ดของเครื่องกำเนิดไฟฟ้าและสุ่ม (เมล็ดยาว) ใช้เมล็ดที่ระบุเป็นเมล็ดของเครื่องกำเนิดไฟฟ้า
หลังจากสร้างวัตถุแบบสุ่ม (สุ่ม) ตัวสร้างตัวเลขแบบสุ่มประเภทต่าง ๆ โดยการเรียกใช้วิธีการต่าง ๆ : nextint (), nextlong (), nextfloat (), nextdouble () ฯลฯ
1> สร้างตัวเลขสุ่ม
สุ่มสุ่ม = ใหม่สุ่ม (); สุ่มสุ่ม = ใหม่สุ่ม (100); // ระบุจำนวนเมล็ด 100
การโทรแบบสุ่มวิธีการที่แตกต่างกันเพื่อรับหมายเลขสุ่ม
หากวัตถุสุ่ม 2 ชิ้นใช้เมล็ดเดียวกัน (ตัวอย่างเช่นทั้งคู่คือ 100) และฟังก์ชั่นเดียวกันเรียกว่าในลำดับเดียวกันค่าคืนของพวกเขาจะเหมือนกันทุกประการ ในรหัสต่อไปนี้เอาต์พุตของวัตถุสุ่มทั้งสองจะเหมือนกันทุกประการ
นำเข้า Java.util.*; คลาส testRandom {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {สุ่มสุ่ม 1 = ใหม่สุ่ม (100); System.out.println (random1.nextint ()); System.out.println (random1.nextfloat ()); System.out.println (random1.nextboolean ()); สุ่มสุ่ม 2 = ใหม่สุ่ม (100); System.out.println (random2.nextint ()); System.out.println (random2.nextfloat ()); System.out.println (random2.nextboolean ()); - 2> ตัวเลขสุ่มในช่วงที่ระบุ
ตัวเลขสุ่มจะถูกควบคุมภายในช่วงที่กำหนดโดยใช้ตัวดำเนินการโมดูลัส %
นำเข้า Java.util.*; คลาส testRandom {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {สุ่มสุ่ม = ใหม่สุ่ม (); สำหรับ (int i = 0; i <10; i ++) {system.out.println (math.abs (random.nextint ())); -ตัวเลขสุ่มที่ได้รับเป็นบวกและลบ ใช้ Math.ABS เพื่อให้ช่วงข้อมูลดึงข้อมูลเป็นตัวเลขที่ไม่เป็นลบ
3> รับตัวเลขสุ่มที่ไม่ซ้ำกันภายในช่วงที่ระบุ
นำเข้า Java.util.*; คลาส testRandom {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int [] intret = new int [6]; intrd = 0; // การจัดเก็บตัวเลขสุ่มจำนวน int count = 0; // บันทึกตัวเลขสุ่มที่สร้างขึ้น int flag = 0; // ไม่ว่าจะสร้างธงในขณะที่ (นับ <6) {สุ่ม rdm = ใหม่สุ่ม (System.currentTimeMillis ()); intrd = math.abs (rdm.nextint ()) 2+1; สำหรับ (int i = 0; i <count; i ++) {ถ้า (intret [i] == intrd) {flag = 1; หยุดพัก; } else {flag = 0; }} if (flag == 0) {intret [count] = intrd; นับ ++; }} สำหรับ (int t = 0; t <6; t ++) {system.out.println (t+"->"+intret [t]); - ตัวเลขสุ่มใน Java สามารถทำซ้ำได้หรือไม่? สามารถใช้ตัวเลขสุ่มใน Java เพื่อสร้างคีย์หลักฐานข้อมูลได้หรือไม่? ด้วยคำถามนี้ในใจเราทำการทดสอบหลายชุด
1. ทดสอบ 1: ใช้ตัวสร้างแบบสุ่ม () โดยไม่มีพารามิเตอร์
คลาสสาธารณะแบบสุ่ม {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {java.util.random r = ใหม่ java.util.random (); สำหรับ (int i = 0; i <10; i ++) {system.out.println (r.nextint ()); - โปรแกรมการรันผลลัพธ์:
-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157
เรียกใช้โปรแกรมอีกครั้ง:
-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608
จากการทดสอบข้างต้นเราจะเห็นได้ว่าตัวเลขสุ่มที่สร้างขึ้นโดยใช้ตัวสร้างแบบสุ่ม () ที่ไม่มีพารามิเตอร์จะไม่ถูกทำซ้ำ ดังนั้นในสถานการณ์ใด Java สร้างตัวเลขสุ่มที่ซ้ำกัน? มาดูการทดสอบด้านล่าง
2. ทดสอบ 2: ตั้งจำนวนเมล็ดสำหรับการสุ่ม
คลาสสาธารณะ RandomTest_Repeat {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {java.util.random r = ใหม่ java.util.random (10); สำหรับ (int i = 0; i <10; i ++) {system.out.println (r.nextint ()); - ไม่ว่าโปรแกรมจะทำงานกี่ครั้งผลลัพธ์ก็คือเสมอ:
-1157793070
2466984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428
แม้ว่าคุณจะทดสอบในเครื่องที่แตกต่างกันผลการทดสอบจะไม่เปลี่ยนแปลง!
3. การวิเคราะห์สาเหตุ:
(1) ก่อนอื่นโปรดเปิดเอกสาร Java เราจะเห็นคำอธิบายของคลาสสุ่ม:
ตัวอย่างของคลาสนี้ใช้ในการสร้างสตรีมหมายเลขหลอกแบบหลอกซึ่งใช้เมล็ด 48 บิตที่สามารถแก้ไขได้โดยใช้สูตรเชิงเส้นสอดคล้องกัน (ดูการเขียนโปรแกรมศิลปะคอมพิวเตอร์ของ Donald Knuth เล่มที่ 2 ส่วน 3.2.1)
หากมีการสร้างอินสแตนซ์แบบสุ่มสองรายการด้วยเมล็ดเดียวกันการเรียกวิธีการเรียกวิธีการแบบเดียวกันกับแต่ละอินสแตนซ์และพวกเขาจะสร้างและส่งกลับลำดับของตัวเลขเดียวกัน เพื่อให้แน่ใจว่าคุณลักษณะนี้ถูกนำไปใช้เราจึงระบุอัลกอริทึมเฉพาะสำหรับการสุ่มคลาส สำหรับการพกพาเต็มรูปแบบของรหัส Java การใช้งาน Java จะต้องมีคลาสสุ่มใช้อัลกอริทึมทั้งหมดที่แสดงที่นี่ แต่คลาสย่อยของคลาสสุ่มได้รับอนุญาตให้ใช้อัลกอริทึมอื่น ๆ ตราบใดที่พวกเขาปฏิบัติตามข้อตกลงทั่วไปของวิธีการทั้งหมด
Java Doc ได้อธิบายชั้นเรียนแบบสุ่มเป็นอย่างดีและการทดสอบของเราได้ตรวจสอบสิ่งนี้แล้ว
(2) หากไม่มีการให้หมายเลขเมล็ดจำนวนเมล็ดของอินสแตนซ์แบบสุ่มจะเป็นมิลลิวินาทีของเวลาปัจจุบัน คุณสามารถรับมิลลิวินาทีของเวลาปัจจุบันผ่าน System.currenttimemillis () เปิดซอร์สโค้ดของ JDK และเราสามารถเห็นสิ่งนี้ได้อย่างชัดเจน
สุ่มสาธารณะ () {this (system.currenttimeMillis ()); - 4. บทสรุป:
ผ่านการทดสอบและการวิเคราะห์ข้างต้นเราจะมีความเข้าใจที่ลึกซึ้งยิ่งขึ้นของชั้นเรียนแบบสุ่ม ในเวลาเดียวกันฉันคิดว่าการอ่านเอกสาร Java Doc API ความสามารถในการเขียนโปรแกรม Java ของเราสามารถปรับปรุงได้อย่างมากและ "รู้ความจริง" สามารถทำได้ เมื่อเราพบปัญหาที่ทำให้งงงวยเราอาจเปิดซอร์สโค้ด Java เพื่อให้เราสามารถ "รู้ความจริง"
โดยทั่วไปมีตัวเลขสุ่มสองประเภทใน Java หนึ่งวิธีคือวิธีการสุ่ม () ในคณิตศาสตร์และอีกประเภทหนึ่งคือคลาสสุ่ม
1. Math.Random ()
มีการสร้างจำนวนทศนิยมของ 0 <x <1
ตัวอย่าง: วิธีการเขียนและสร้างหนึ่งในตัวเลขแบบสุ่มตั้งแต่ 0 ถึง 100?
math.random () ส่งคืนเพียงทศนิยมจาก 0 ถึง 1 ถ้าคุณต้องการ 50 ถึง 100 คุณจะซูมใน 50 ครั้งก่อนนั่นคือระหว่าง 0 ถึง 50 ที่นี่ยังคงเป็นทศนิยม หากคุณต้องการจำนวนเต็มคุณจะโยน int แล้วเพิ่ม 50 ถึง 50 ถึง 100
รหัสสุดท้าย: (int) (math.random ()*50) + 50
2. คลาสสุ่ม
Random Random = new Random (); // ค่าเริ่มต้นของ Constructor Random Random = new Random (1000); // ระบุหมายเลขเมล็ด
เมื่อทำการสุ่มจำนวนต้นกำเนิดของอัลกอริทึมแบบสุ่มเรียกว่าเมล็ดซึ่งดำเนินการเปลี่ยนแปลงบางอย่างตามเมล็ดซึ่งจะสร้างตัวเลขสุ่มที่ต้องการ
วัตถุสุ่มที่มีจำนวนเมล็ดเท่ากันตัวเลขสุ่มที่สร้างขึ้นจากจำนวนครั้งเดียวกันนั้นเหมือนกัน กล่าวอีกนัยหนึ่งสำหรับวัตถุสุ่มสองรายการที่มีหมายเลขเมล็ดเดียวกันตัวเลขสุ่มที่สร้างขึ้นเป็นครั้งแรกจะเหมือนกันและตัวเลขสุ่มที่สร้างขึ้นเป็นครั้งที่สองจะเหมือนกัน
2. วิธีการทั่วไปในคลาสสุ่ม
วิธีการในคลาสแบบสุ่มนั้นค่อนข้างง่ายและฟังก์ชั่นของแต่ละวิธีก็เข้าใจได้ง่าย ควรสังเกตว่าตัวเลขสุ่มที่สร้างขึ้นโดยแต่ละวิธีในคลาสสุ่มมีการกระจายอย่างสม่ำเสมอซึ่งหมายความว่าความน่าจะเป็นของการสร้างตัวเลขภายในช่วงเวลาเท่ากัน นี่คือการแนะนำขั้นพื้นฐานเกี่ยวกับวิธีการเหล่านี้:
A, Public Boolean NextBoolean ()
ฟังก์ชั่นของวิธีนี้คือการสร้างค่าบูลีนแบบสุ่มและความน่าจะเป็นของการสร้างค่าที่แท้จริงและเท็จเท่ากับนั่นคือทั้งสองเป็น 50%
B, Public Double NextDouble ()
วัตถุประสงค์ของวิธีนี้คือการสร้างค่าสองครั้งแบบสุ่มค่าอยู่ระหว่าง [0, 1.0) ที่นี่วงเล็บแสดงถึงจุดสิ้นสุดที่มีช่วงเวลาและวงเล็บแสดงถึงจุดสิ้นสุดที่ไม่รวมช่วงเวลานั่นคือทศนิยมแบบสุ่มระหว่าง 0 และ 1 ซึ่งมี 0 แต่ไม่ใช่ 1.0
C, Public Int Nextint ()
วัตถุประสงค์ของวิธีนี้คือการสร้างค่าอินเตอร์แบบสุ่มซึ่งอยู่ระหว่างกำลัง 31 ของพลังงาน -2 และ 31 ที่กำลัง -1st กำลัง 2
หากคุณต้องการสร้างค่า int สำหรับช่วงเวลาที่กำหนดคุณต้องทำการแปลงทางคณิตศาสตร์บางอย่าง สำหรับรายละเอียดโปรดดูรหัสในตัวอย่างการใช้งานด้านล่าง
D, Public Int Nextint (int n)
ฟังก์ชั่นของวิธีนี้คือการสร้างค่า int แบบสุ่มซึ่งอยู่ภายในช่วงเวลาของ [0, n) นั่นคือค่า int แบบสุ่มระหว่าง 0 และ n ที่มี 0 แต่ไม่ใช่ n
หากคุณต้องการสร้างค่า int สำหรับช่วงเวลาที่กำหนดคุณต้องทำการแปลงทางคณิตศาสตร์บางอย่าง สำหรับรายละเอียดโปรดดูรหัสในตัวอย่างการใช้งานด้านล่าง
E, โมฆะสาธารณะ setseed (เมล็ดยาว)
วัตถุประสงค์ของวิธีนี้คือการรีเซ็ตจำนวนเมล็ดในวัตถุสุ่ม หลังจากตั้งค่าจำนวนเมล็ดวัตถุสุ่มจะเหมือนกับวัตถุสุ่มที่สร้างขึ้นด้วยคำหลักใหม่
3. ตัวอย่างการใช้งานแบบสุ่มชั้นเรียน
การใช้คลาสแบบสุ่มโดยทั่วไปจะสร้างตัวเลขสุ่มสำหรับช่วงเวลาที่กำหนด ต่อไปนี้จะแนะนำวิธีการสร้างตัวเลขสุ่มสำหรับช่วงเวลาที่สอดคล้องกันทีละคน รหัสต่อไปนี้ที่สร้างตัวเลขสุ่มถูกสร้างขึ้นโดยใช้วัตถุสุ่มต่อไปนี้ r:
สุ่ม r = ใหม่สุ่ม ();
. สร้างทศนิยมของช่วงเวลา [0,1.0)
double d1 = r.nextdouble ();
ได้รับโดยตรงโดยใช้วิธี NextDouble
ข. สร้างทศนิยมของช่วงเวลา [0,5.0)
double d2 = r.nextdouble () * 5;
เนื่องจากช่วงเวลาตัวเลขที่สร้างขึ้นโดยวิธี NextDouble คือ [0, 1.0) การขยายช่วงเวลา 5 เท่าจึงเป็นช่วงเวลาที่ต้องการ
ในทำนองเดียวกันในการสร้างทศนิยมแบบสุ่มในช่วงเวลา [0, D) และ D เป็นทศนิยมเชิงบวกใด ๆ คุณจะต้องคูณค่าผลตอบแทนของวิธี NextDouble โดย D
ค. สร้างเลขทศนิยม [N1, N2] ของช่วงเวลา [1, 2.5) [1]
double d3 = r.nextdouble () * 1.5 + 1; 【นั่นคือ r.nextdouble () * (n2-n1) + n1 】
ในการสร้างทศนิยมแบบสุ่มของช่วงเวลา [1, 2.5) คุณจะต้องสร้างจำนวนสุ่มของช่วงเวลา [0, 1.5) ก่อนจากนั้นเพิ่ม 1 ในช่วงเวลาสุ่มที่สร้างขึ้น
ในทำนองเดียวกันในการสร้างหมายเลขสุ่มใด ๆ ในช่วงของช่วงเวลาทศนิยม [D1, D2) ที่ไม่ได้เริ่มต้นจาก 0 (โดยที่ D1 ไม่เท่ากับ 0) คุณจะต้องสร้างหมายเลขสุ่มในช่วงเวลา [0, D2-D1) ก่อนจากนั้นเพิ่มช่วงเวลาสุ่มที่สร้างขึ้นเป็น D1
d. สร้างจำนวนเต็มใด ๆ
int n1 = r.nextint ();
เพียงใช้วิธีการ Nextint โดยตรง
ก. สร้างจำนวนเต็มในช่วงเวลา [0,10)
int n2 = r.nextint (10); n2 = math.abs (r.nextint () % 10);
รหัสสองบรรทัดข้างต้นสามารถสร้างจำนวนเต็มในช่วงเวลา [0,10)
การใช้งานครั้งแรกจะถูกนำไปใช้โดยตรงโดยใช้วิธี NextInt (Int N) ในคลาสสุ่ม
ในการใช้งานครั้งที่สองวิธีการโทรครั้งแรก NextInt () เพื่อสร้างหมายเลข int โดยพลการ ช่วงเวลาที่สร้างขึ้นโดยจำนวนผลรวมของหมายเลข 10 คือ (-10,10) เนื่องจากตามข้อกำหนดทางคณิตศาสตร์ค่าสัมบูรณ์ของส่วนที่เหลือจะน้อยกว่าตัวหารและจากนั้นค่าสัมบูรณ์ของช่วงเวลาจะถูกคำนวณและช่วงเวลาที่เกิดขึ้นคือ [0,10)
ในทำนองเดียวกันในการสร้างจำนวนเต็มแบบสุ่มในทุกช่วงเวลา [0, n) คุณสามารถใช้รหัสต่อไปนี้:
int n2 = r.nextint (n); n2 = math.abs (r.nextint () % n);
f. สร้างจำนวนเต็มในช่วงเวลา [0,10]
int n3 = r.nextint (11); n3 = math.abs (r.nextint () % 11);
เมื่อเปรียบเทียบกับช่วงเวลาจำนวนเต็มช่วงเวลา [0,10] และช่วงเวลา [0,11) นั้นเทียบเท่าดังนั้นจึงมีการสร้างจำนวนเต็มของช่วงเวลา [0,11)
กรัม สร้างจำนวนเต็มในช่วงเวลา [-3,15)
int n4 = r.nextint (18) - 3; // 【นั่นคือ r.nextint () * (n2 -n1)+n1 】 n1 เป็นจำนวนลบ n4 = math.abs (r.nextint () % 18) - 3;
ในการสร้างจำนวนเต็มแบบสุ่มที่ไม่ได้เริ่มต้นจาก 0 คุณสามารถอ้างถึงคำอธิบายข้างต้นของหลักการการนำไปปฏิบัติของช่วงเวลาทศนิยมที่ไม่ได้เริ่มจาก 0
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น