คำอธิบายโดยละเอียดเกี่ยวกับวิธีการสร้างและหลักการของตัวเลขสุ่มใน Java

วิธีการและหลักการของตัวเลขสุ่มใน Java

ตรวจสอบข้อมูลที่เกี่ยวข้องกับตัวเลขสุ่มและจัดระเบียบเป็นพิเศษ

ก่อนอื่นมาพูดคุยกันหลายวิธีในการสร้างตัวเลขสุ่มใน Java

1. ใน J2SE เราสามารถใช้วิธี Math.random () เพื่อสร้างหมายเลขสุ่ม หมายเลขสุ่มที่สร้างขึ้นเป็นสองเท่าระหว่าง 0-1 เราสามารถคูณด้วย 100 มันเป็นหมายเลขสุ่มภายใน 100 สิ่งนี้ไม่สามารถใช้ได้ใน J2ME
2. แพ็คเกจ Java.util มีคลาสแบบสุ่ม เราสามารถสร้างวัตถุสุ่มใหม่เพื่อสร้างตัวเลขสุ่ม มันสามารถผลิตจำนวนเต็มแบบสุ่มลอยแบบสุ่มคู่แบบสุ่มและแบบสุ่มยาว นี่เป็นวิธีการใช้ตัวเลขสุ่มที่เรามักใช้ในโปรแกรม J2ME
3. มีวิธี CurrentTimeMillis () ในคลาสระบบของเรา วิธีนี้ส่งคืนหมายเลขมิลลิวินาทีตั้งแต่เวลา 0:00:00 น. ของวันที่ 1 มกราคม 1970 ถึงหมายเลขปัจจุบัน ประเภทการส่งคืนนั้นยาว เราสามารถใช้เป็นหมายเลขสุ่ม เราสามารถใช้มันกับโมดูโลบางหมายเลขและเราสามารถ จำกัด มันไว้ในช่วง

en. - - ในความเป็นจริงวิธีที่สามข้างต้นใช้เพื่อสร้างตัวเลขสุ่มในวิธีการก่อสร้างเริ่มต้นของสุ่ม

มีสองวิธีในการสร้างคลาสแบบสุ่มในวิธีที่ 2: ด้วยเมล็ดและไม่มีเมล็ด

หากไม่มีเมล็ด: วิธีนี้จะส่งคืนตัวเลขสุ่มและผลลัพธ์ของการวิ่งแต่ละครั้งจะแตกต่างกันซึ่งเทียบเท่ากับการใช้ System.currenttimeMillis () เป็นเมล็ด

ด้วยเมล็ดพันธุ์: ด้วยวิธีนี้ผลตอบแทนจะเหมือนกันไม่ว่าโปรแกรมจะทำงานกี่ครั้ง หากมีการสร้างอินสแตนซ์แบบสุ่มสองรายการด้วยเมล็ดเดียวกันการเรียกวิธีการเรียกวิธีการแบบเดียวกันกับแต่ละอินสแตนซ์และพวกเขาจะสร้างและส่งกลับลำดับของตัวเลขเดียวกัน

หมายเลขเทียม

ตัวเลขสุ่มในคอมพิวเตอร์คือหมายเลขสุ่มหลอก

นี่คือโปรแกรม C เช่นนี้:

 // rand_1.cpp#รวม <stdlib.h> คงที่ int rand_seed ที่ไม่ได้ลงชื่อคงที่; ไม่ได้ลงนาม int สุ่ม (เป็นโมฆะ) {rand_seed = (rand_seed*123+59)%65536; return (rand_seed);} เป็นโมฆะ random_start (void) {int temp [2]; Movingata (0x0040,0x006c, fp_seg (อุณหภูมิ), fp_off (อุณหภูมิ), 4); rand_seed = temp [0];} void main () {int ที่ไม่ได้ลงชื่อ int i, n; RANDOR_START (); สำหรับ (i = 0; i <10; i ++) printf ("#u/t", สุ่ม ()); printf ("/n");}

มันอธิบายกระบวนการสร้างตัวเลขแบบสุ่มอย่างเต็มที่:

อันดับแรก,

Movingata (0x0040,0x006c, fp_seg (อุณหภูมิ), fp_off (อุณหภูมิ), 4);

ฟังก์ชั่นนี้ใช้เพื่อย้ายข้อมูลหน่วยความจำ FP_SEG (ตัวชี้ไปยังเซ็กเมนต์) เป็นฟังก์ชั่นที่ใช้ที่อยู่เซ็กเมนต์ของอาร์เรย์อุณหภูมิ, FP_OFF ​​(ตัวชี้ไกลไปชดเชย) เป็นฟังก์ชันที่ใช้ที่อยู่สัมพัทธ์ของอาร์เรย์อุณหภูมิและฟังก์ชั่น Movedata จะใส่คำสองคำที่อยู่ในหน่วยเก็บข้อมูล 0040: 006ch ด้วยวิธีนี้หมายเลข 16 บิตที่ 0040: 006ch สามารถส่งไปยัง Rand_seed ผ่านอาร์เรย์อุณหภูมิ
ที่สอง,

rand_seed = (rand_seed*123+59)%65536;

มันเป็นวิธีที่ใช้ในการคำนวณตัวเลขสุ่ม วิธีการคำนวณของตัวเลขสุ่มแตกต่างกันในคอมพิวเตอร์ที่แตกต่างกันแม้ในระบบปฏิบัติการที่แตกต่างกันที่ติดตั้งในคอมพิวเตอร์เครื่องเดียวกัน ฉันได้ลองใน Linux และ Windows ตามลำดับ ตัวเลขสุ่มที่สร้างขึ้นโดยเมล็ดสุ่มเดียวกันในระบบปฏิบัติการทั้งสองนี้แตกต่างกันซึ่งหมายความว่าพวกเขามีวิธีการคำนวณที่แตกต่างกัน

แล้ว,

Movingata (0x0040,0x006c, fp_seg (อุณหภูมิ), fp_off (อุณหภูมิ), 4);

เหตุใดจึงต้องเรียกคืนเมล็ดสุ่มที่ 0040: 006ch ในหน่วยความจำ? เก็บอะไรไว้ที่ 0040: 006ch?

ผู้ที่ศึกษาหลักสูตร "หลักการของส่วนประกอบคอมพิวเตอร์และเทคโนโลยีอินเทอร์เฟซ" อาจจำได้ว่าเมื่อรวบรวมโปรแกรมการบริการขัดจังหวะนาฬิกา ROM BIOS จะใช้เวลา/ตัวนับ Intel 8253 การสื่อสารกับ Interrupt Chip Intel 8259 ช่วยให้โปรแกรมการบริการขัดจังหวะสามารถใช้งานได้ การขัดจังหวะ 18.2 ที่สร้างโดยเมนบอร์ดต่อวินาทีนั้นถูกสร้างขึ้นโดยโปรเซสเซอร์จะควบคุมชิปขัดจังหวะตามค่าเวลา/ตัวนับ มีเวลา/เคาน์เตอร์บนเมนบอร์ดของคอมพิวเตอร์ของเราเพื่อคำนวณเวลาระบบปัจจุบัน ตัวนับจะถูกเพิ่มหนึ่งครั้งทุกครั้งที่วงจรสัญญาณนาฬิกาผ่านไป มูลค่าของเคาน์เตอร์นี้เก็บไว้ที่ไหน ถูกต้องอยู่ที่ 0040: 006ch ในหน่วยความจำพื้นที่หน่วยความจำนี้ถูกกำหนดจริงเช่นนี้:

timer_low dw?; ที่อยู่คือ 0040: 006ch
timer_high dw?; ที่อยู่คือ 0040: 006EH
timer_oft db? - ที่อยู่คือ 0040: 0070H

ในโปรแกรมการบริการขัดจังหวะนาฬิกาเมื่อใดก็ตามที่ TIMER_LOW เปิดเต็มตัวนับจะเปลี่ยนเต็มและค่าของตัวนับเป็นศูนย์นั่นคือไบนารี 16 บิตที่ TIMER_LOW เป็นศูนย์และเพิ่ม TIMER_HIGH ใน Rand01.c

Movingata (0x0040,0x006c, fp_seg (อุณหภูมิ), fp_off (อุณหภูมิ), 4);

มันเป็นตัวเลขไบนารี 16 บิตสองตัวสองตัว TIMER_LOW และ TIMER_HIGH ที่วางไว้ในอาร์เรย์อุณหภูมิและส่งไปยัง RAND_SEED จึงได้รับ "เมล็ดสุ่ม"
ตอนนี้สิ่งหนึ่งที่สามารถพิจารณาได้คือเมล็ดสุ่มมาจากนาฬิการะบบหรือค่าบันทึกในหน่วยความจำจากเวลา/เคาน์เตอร์บนเมนบอร์ดคอมพิวเตอร์

en ... ไม่สุดท้าย - LVL--

มาดูรหัสอีกชิ้นหนึ่ง:

 //rand_2.cpp#include <Iostream> #include <Cstdlib> การใช้ namespace std; int main () {srand ((ไม่ได้ลงนาม) เวลา (null)); int ที่ไม่ได้ลงนาม r = rand (); ศาล << "r =" << r << endl; // ตามมาตรฐาน C ++ 98 ฟังก์ชั่นหลักสามารถแนะนำได้โดยไม่ต้องใช้คำสั่ง Return เพื่อส่งคืน 0;}

ที่นี่หากผู้ใช้และโปรแกรมอื่น ๆ ไม่ได้ตั้งค่าเมล็ดสุ่มค่าของเวลา/ตัวนับของระบบจะใช้เป็นเมล็ดสุ่ม ดังนั้นในสภาพแวดล้อมแพลตฟอร์มเดียวกันหลังจากรวบรวมและสร้าง EXE ทุกครั้งที่คุณเรียกใช้หมายเลขสุ่มที่แสดงจะเป็นหมายเลขหลอกเทียมนั่นคือผลลัพธ์ที่แสดงจะแตกต่างกันทุกครั้งที่คุณรัน

สรุป

ตัวเลขสุ่มเป็นค่าที่คำนวณโดยเมล็ดสุ่มตามวิธีการคำนวณบางอย่าง ดังนั้นตราบใดที่วิธีการคำนวณมีความแน่นอนและเมล็ดสุ่มแน่นอนจำนวนสุ่มที่สร้างขึ้นจะไม่เปลี่ยนแปลง ในสภาพแวดล้อมแพลตฟอร์มเดียวกันหลังจากรวบรวมและสร้าง EXE ตัวเลขสุ่มที่แสดงจะเหมือนกันทุกครั้งที่คุณเรียกใช้ นี่เป็นเพราะในสภาพแวดล้อมแพลตฟอร์มการรวบรวมเดียวกันวิธีการคำนวณสำหรับการสร้างตัวเลขสุ่มจากเมล็ดสุ่มจะเหมือนกันและเมล็ดสุ่มเหมือนกันดังนั้นตัวเลขสุ่มที่สร้างขึ้นจะเหมือนกัน

ตราบใดที่ผู้ใช้หรือบุคคลที่สามไม่ได้ตั้งค่าเมล็ดสุ่มดังนั้นโดยค่าเริ่มต้นเมล็ดสุ่มมาจากนาฬิการะบบ (เช่นค่าของเวลา/ตัวนับ)

ขอบคุณสำหรับการอ่านฉันหวังว่ามันจะช่วยคุณได้ ขอบคุณสำหรับการสนับสนุนเว็บไซต์นี้!