يقدم أساسًا ثلاث طرق للحصول على أرقام عشوائية في Java ، وذلك باستخدام الدالة العشوائية () لتنفيذها
الطريقة 1
(نوع البيانات) (الحد الأدنى القيمة + Math.Random ()*(أقصى قيمة -قيمة minimum +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
RANDAY RA = جديد عشوائي () ؛ لـ (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
عدة طرق لتوليد أرقام عشوائية في جافا
1. في J2SE ، يمكننا استخدام طريقة Math.Random () لإنشاء رقم عشوائي. الرقم العشوائي الذي تم إنشاؤه هو مزدوج بين 0-1. يمكننا ضربه برقم معين ، على سبيل المثال ، مضاعفة بمقدار 100. إنه عشوائي خلال 100 ، وهو غير موجود في J2ME.
2. في حزمة java.util ، يتم توفير فئة عشوائية. يمكننا إنشاء كائن عشوائي جديد لإنشاء أرقام عشوائية. يمكن أن يولد أعداد صحيحة عشوائية ، عوامات عشوائية ، زوجي عشوائي ، وطويل عشوائي. هذه أيضًا طريقة لاتخاذ أرقام عشوائية نستخدمها غالبًا في برامج J2ME.
3. هناك طريقة CurrentTimeMillis () في فئة نظامنا. تُرجع هذه الطريقة رقم ميلي ثانية من الساعة 0:00:00 في 1 يناير 1970 إلى الرقم الحالي. نوع العودة طويل. يمكننا استخدامه كرقم عشوائي. يمكننا استخدامه لزيادة بعض الأرقام ، ونقيدها على نطاق.
في الواقع ، في طريقة البناء الافتراضية لـ Random ، يتم استخدام الطريقة الثالثة أعلاه لإنشاء أرقام عشوائية.
الفئة العشوائية في الطريقة الثانية لها الوصف التالي:
هناك طريقتان لبناء فئة java.util.random: مع البذور وبدون البذور
لا بذور:
ستعود هذه الطريقة أرقام عشوائية ، وستكون النتائج مختلفة لكل تشغيل.
الفئة العامة العشوائية {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 ()) مع البذور:
وبهذه الطريقة ، بغض النظر عن عدد المرات التي يعمل فيها البرنامج ، ستكون نتيجة الإرجاع هي نفسها
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 ()) ؛}} الفرق بين الطريقتين
(1) أولاً ، يرجى فتح Java Doc ، سنرى وصف الفئة العشوائية:
يتم استخدام أمثلة من هذه الفئة لإنشاء تدفقات الأرقام العشوائية الزائفة ، والتي تستخدم بذرة 48 بت يمكن تعديلها باستخدام صيغة متطابقة خطية.
إذا تم إنشاء حالتين عشوائيتين بنفس البذور ، فسيتم إجراء نفس تسلسل مكالمات الطريقة لكل حالة وسوف يقومان بإنشاء وتسلف الأرقام نفسها. لضمان تنفيذ هذه الميزة ، نحدد خوارزمية محددة للفئة العشوائية. للحصول على قابلية النقل الكاملة لرمز Java ، يجب أن يكون لدى تطبيقات Java الفئة العشوائية استخدام جميع الخوارزميات الموضحة هنا. ولكن يُسمح للفئات الفرعية للفئة العشوائية باستخدام خوارزميات أخرى طالما أنها تمتثل للاتفاقات التقليدية لجميع الطرق.
أوضحت Java Doc الفئة العشوائية جيدًا ، وقد تحقق اختباراتنا من ذلك.
(2) في حالة عدم توفير رقم بذرة ، سيكون عدد بذور المثيل العشوائي هو المللي ثانية من الوقت الحالي. يمكنك الحصول على مللي ثانية من الوقت الحالي من خلال System.CurrentTimeMillis (). افتح الكود المصدري لـ JDK ويمكننا أن نرى هذا بوضوح شديد.
public Random () {this (System.CurrentTimeMillis ()) ؛ } فضلاً عن ذلك:
وصف طرق NextInt () ، NextInt (int n) من الكائن العشوائي:
int nextint () // إرجاع رقم العشوائي الزائف التالي ، وهو القيمة int الموزعة بالتساوي في تسلسل هذا المولد العشوائي.
int nextint (int n) // إرجاع رقم عشوائي زائف ، وهو قيمة int موزعة بالتساوي بين 0 (بما في ذلك) والقيمة المحددة (باستثناء) مأخوذة من تسلسل مولد الأرقام العشوائية هذا.
جافا ملخص رقم عشوائي
تستخدم الأرقام العشوائية على نطاق واسع في الممارسة ، مثل توليد سلسلة أو رقم ثابت. إما بعد ذلك ، قم بإنشاء عدد من الطول غير المؤكد ، أو قم بإجراء اختيار عشوائي محاكاة ، وما إلى ذلك. توفر Java الأدوات الأساسية التي يمكن أن تساعد المطورين على تحقيق كل هذا.
1. كيفية إنشاء أرقام عشوائية جافا
في جافا ، هناك ثلاثة مفاهيم عامة للأرقام العشوائية.
1. استخدم System.CurrentTimeMillis () للحصول على عدد طويل من المللي ثانية في الوقت الحالي.
2. إرجاع قيمة مزدوجة بين 0 و 1 من خلال Math.Random ().
3. إنشاء رقم عشوائي من خلال الفئة العشوائية. هذا هو فئة الأدوات العشوائية المهنية مع وظائف قوية.
2. وصف API العشوائي
1. وصف API Java
يتم استخدام مثيل للفئة العشوائية لإنشاء دفق الأرقام العشوائية الزائفة. يستخدم هذا الفئة بذور 48 بت وتستخدم صيغة متطابقة خطية لتعديلها (انظر Donald Knuth's The Art of Computer Programming ، المجلد 2 ، القسم 3.2.1).
إذا تم إنشاء حالتين عشوائيتين بنفس البذور ، فسيتم إجراء نفس تسلسل مكالمات الطريقة لكل حالة وسوف يقومان بإنشاء وتسلف الأرقام نفسها. من أجل ضمان تنفيذ السمات ، يتم تحديد خوارزمية معينة للفئة العشوائية.
ستجد العديد من التطبيقات الطريقة العشوائية في فئة الرياضيات أسهل في الاستخدام.
2. ملخص الطريقة
عشوائي () // إنشاء مولد أرقام عشوائية جديدة.
عشوائي (بذرة طويلة) // قم بإنشاء مولد رقم عشوائي جديد باستخدام بذرة طويلة واحدة: عشوائي عام (بذرة طويلة) {setSeed (البذور) ؛ } الطريقة التالية تستخدمها لحفظ حالة مولد الأرقام العشوائية.
محمي int التالي (البتات int): يولد الرقم العشوائي الزائف التالي.
Boolean NextBoolean (): إرجاع رقم العشوائي الزائف التالي ، وهو القيمة المنطقية الموزعة بالتساوي المأخوذة من تسلسل مولد الأرقام العشوائية هذا.
void 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 Nextlong (): إرجاع رقم العشوائي الزائف التالي ، وهو قيمة طويلة موزعة موزعة مأخوذة من تسلسل مولد الأرقام العشوائية هذا.
setseed void (بذرة طويلة): يضع بذرة مولد الأرقام العشوائية باستخدام بذرة طويلة واحدة.
3. تعليمات استخدام الفئة العشوائية
1. الفرق بين أخذ البذور وعدم أخذ البذور. الاستخدام الأساسي للفئة العشوائية هو تقسيم أمثلة العشوائية مع البذور وبدون البذور.
بشروط Layman ، فإن الفرق بين الاثنين هو: إذا تم إنتاج البذور ، فإن النتائج التي تم إنشاؤها بواسطة كل تشغيل هي نفسها.
إذا لم يكن لديك بذور ، فإن ما تنشئه هو عشوائي في كل مرة تقوم فيها بالركض ، ولا يوجد نمط على الإطلاق.
2. قم بإنشاء كائن عشوائي بدون بذور
عشوائي عشوائي = جديد عشوائي () ؛
3. هناك طريقتان لإنشاء كائن عشوائي بدون بذور:
1) عشوائي عشوائي = عشوائي جديد (555L) ؛
2) عشوائي = جديد عشوائي () ؛ عشوائي.
4. اختبار
استخدم مثالًا لتوضيح الاستخدام أعلاه
استيراد java.util.random ؛ الفئة العامة testRandomNum {public static void main (string [] args) {randomtest () ؛ testNoseed () ؛ testseed1 () ؛ testseed2 () ؛ } public static void randomtest () { System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- long R1 = System.CurrentTimeLis () ؛ System.out.println ("R2 =" + R3) ؛ System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------. لـ (int i = 0 ؛ i <3 ؛ i ++) {system.out.println (random.nextint ()) ؛ }} public static void 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
من خلال نتائج طرق testseed1 () و testseed2 () ، يمكننا أن نرى أن نتيجتي الطباعة هما نفسها لأنها ترى نفس الشيء. إذا ركضوا مرة أخرى ، فستظل النتيجة هي نفسها. هذه هي سمة الأرقام العشوائية مع البذور. إذا لم يكن لديك بذور ، فإن نتائج كل تشغيل عشوائية.
خامسا التطبيق الشامل
فيما يلي فئة أدوات الأرقام العشوائية المكتوبة مؤخرًا لإظهار الاستخدام:
استيراد java.util.random ؛ الفئة العامة randomutils {public static Final String allchar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ" ؛ Static Final Final String letterchar = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ" ؛ Static Final Final NumberChar = "0123456789" ؛ السلسلة الثابتة العامة generatestring (طول int) {StringBuffer SB = جديد StringBuffer () ؛ عشوائي عشوائي = جديد عشوائي () ؛ لـ (int i = 0 ؛ i <length ؛ i ++) {sb.append (allchar.charat (random.nextint (allchar.length ())))) ؛ } return sb.toString () ؛ } السلسلة الثابتة العامة generateMixString (int length) {StringBuffer sb = new StringBuffer () ؛ عشوائي عشوائي = جديد عشوائي () ؛ لـ (int i = 0 ؛ i <length ؛ i ++) {sb.append (allchar.charat (random.nextint (letterchar.length ())))) ؛ } return sb.toString () ؛ } السلسلة الثابتة العامة generateLoWerString (int length) {return generateMixString (length) .ToLowerCase () ؛ } السلسلة الثابتة العامة generateuppersstring (طول int) {return generateMixString (length) .ToupperCase () ؛ } السلسلة الثابتة العامة generatezerostring (int length) {StringBuffer SB = new StringBuffer () ؛ لـ (int i = 0 ؛ i <length ؛ i ++) {sb.append ('0') ؛ } return sb.toString () ؛ } السلسلة الثابتة العامة tofixDlengthString (num long ، int fixDlenth) {StringBuffer sb = new StringBuffer () ؛ String strnum = string.valueof (num) ؛ if (fixDlenth - strnum.length ()> = 0) {sb.append (generatezeroString (fixDlenth - strnum.length ())) ؛ } آخر {رمي new runTimeException ("رقم تحويل" + num + "يحدث استثناء عندما يتم إجراء استثناء على سلسلة بطول" + fixDlenth + ") ؛} sb.append (strnum) ؛ return sb.toString () ؛ string.valueof (num) ؛ } sb.append (strnum) ؛ إرجاع sb.tostring () ؛ } public static void main (string [] 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
23hyrahdjkpwmv
tigowetbwkm1nde
BPZ1KNEJPHB115N
000000000000000000
00000000000000123
00000000000000123
انتهت العملية برمز الخروج 0
6. ملخص
1. الأرقام العشوائية شائعة الاستخدام. هناك ثلاث طرق لتوليدها في جافا. الأرقام العشوائية العشوائية هي الأكثر تعقيدًا.
2. كائنات فئة عشوائية لها فرق بين ما إذا كانت تحمل البذور. طالما أن البذور هي نفسها ، فإنها تعمل عدة مرات ، ونتيجة توليد أرقام عشوائية هي نفسها دائمًا.
3. هناك طريقتان لإنشاء كائنات البذور بأرقام عشوائية ، بنفس التأثير. لكن لا يبدو أن الأرقام العشوائية مع البذور مفيدة.
4. وظائف Random تغطي وظائف Math.Random ().
5. يمكنك استخدام أرقام عشوائية لتنفيذ بيانات عشوائية معقدة مثل السلاسل العشوائية.
6. لا تدرس الأرقام العشوائية التي لا تكرر ، فهي ليست ذات معنى كبيرة.
في Java ، يمكننا استخدام فئة java.util.random لإنشاء مولد رقم عشوائي. له شكلان من المنشئين ، وهما عشوائيين () وعشوائي (بذرة طويلة). يستخدم Random () الوقت الحالي ، System.CurrentTimeMillis () ، حيث أن بذرة المولد ، والبذور العشوائية (البذور الطويلة) تستخدم البذور المحددة كبذور المولد.
بعد إنشاء كائن مولد الرقم العشوائي (عشوائي) ، يتم الحصول على أنواع مختلفة من الأرقام العشوائية عن طريق استدعاء الطرق المختلفة: NextInt () ، nextlong () ، nextfloat () ، nextDouble () ، إلخ.
1> إنشاء أرقام عشوائية
عشوائي عشوائي = جديد عشوائي () ؛ عشوائي عشوائي = جديد عشوائي (100) ؛ // حدد عدد البذور 100
مكالمات عشوائية طرق مختلفة للحصول على أرقام عشوائية.
إذا استخدم كائنان عشوائيان نفس البذور (على سبيل المثال ، كلاهما 100) ويتم استدعاء نفس الوظيفة بنفس الترتيب ، فإن قيم الإرجاع الخاصة بهم هي نفسها تمامًا. كما في الكود التالي ، فإن إخراج الكائنين العشوائيين هو نفسه بالضبط
استيراد java.util.*؛ الفئة testrandom {public static void main (string [] args) {random11 = new random (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 {public static void main (string [] args) {random random = new random () ؛ لـ (int i = 0 ؛ i <10 ؛ i ++) {system.out.println (math.abs (random.nextint ())) ؛ }}}الأرقام العشوائية التي تم الحصول عليها إيجابية وسلبية. استخدم Math.ABS لجعل نطاق البيانات يتم استرداده كأرقام غير سالبة.
3> احصل على أرقام عشوائية غير مبتذلة ضمن النطاق المحدد
استيراد java.util.*؛ class testrandom {public static void main (string [] args) {int [] intret = new int [6] ؛ intrd = 0 ؛ // تخزين الأرقام العشوائية int count = 0 ؛ // سجل الأرقام العشوائية التي تم إنشاؤها علامة int = 0 ؛ // ما إذا كان قد تم إنشاء العلم بينما (العد <6) {rdm rdm = new random (system.currentTimeMillis ()) ؛ intrd = math.abs (rdm.nextint ()) 2+1 ؛ لـ (int i = 0 ؛ i <count ؛ i ++) {if (intret [i] == intrd) {flag = 1 ؛ استراحة؛ } آخر {flag = 0 ؛ }} if (flag == 0) {intret [count] = intrd ؛ count ++ ؛ }} لـ (int t = 0 ؛ t <6 ؛ t ++) {system.out.println (t+"->"+intret [t]) ؛ }}} هل يمكن تكرار الأرقام العشوائية في جافا؟ هل يمكن استخدام الأرقام العشوائية التي تم إنشاؤها في Java لإنشاء مفاتيح قاعدة البيانات الأساسية؟ مع وضع هذا السؤال في الاعتبار ، قمنا بسلسلة من الاختبارات.
1. الاختبار 1: استخدم المُنشئ العشوائي () بدون معلمات
الفئة العامة العشوائية {public static void main (string [] args) {java.util.random r = new 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
من الاختبار أعلاه ، يمكننا أن نرى أن الأرقام العشوائية التي تم إنشاؤها باستخدام مُنشئ عشوائي () بدون معلمات لن تتكرر. لذلك ، في أي ظروف تنتج جافا أرقام عشوائية مكررة؟ دعونا نرى الاختبار أدناه.
2. الاختبار 2: اضبط عدد البذور عشوائيًا
الفئة العامة randomtest_repeat {public static void main (string [] args) {java.util.random r = new java.util.random (10) ؛ لـ (int i = 0 ؛ i <10 ؛ i ++) {system.out.println (r.nextint ()) ؛ }}} بغض النظر عن عدد المرات التي يعمل فيها البرنامج ، فإن النتيجة هي دائمًا:
-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428
حتى إذا قمت باختباره على أجهزة مختلفة ، فإن نتائج الاختبار لن تتغير!
3. تحليل السبب:
(1) أولاً ، يرجى فتح Java Doc ، سنرى وصف الفئة العشوائية:
يتم استخدام أمثلة من هذه الفئة لإنشاء تدفقات الأرقام العشوائية الزائفة ، والتي تستخدم بذرة 48 بت يمكن تعديلها باستخدام صيغة متطابقة خطية (انظر Donald Knuth's Art of Computer Programming ، المجلد 2 ، القسم 3.2.1).
إذا تم إنشاء حالتين عشوائيتين بنفس البذور ، فسيتم إجراء نفس تسلسل مكالمات الطريقة لكل حالة وسوف يقومان بإنشاء وتسلف الأرقام نفسها. لضمان تنفيذ هذه الميزة ، نحدد خوارزمية محددة للفئة العشوائية. للحصول على قابلية النقل الكاملة لرمز Java ، يجب أن يكون لدى تطبيقات Java الفئة العشوائية استخدام جميع الخوارزميات الموضحة هنا. ولكن يُسمح للفئات الفرعية للفئة العشوائية باستخدام خوارزميات أخرى طالما أنها تمتثل للاتفاقات التقليدية لجميع الطرق.
أوضحت Java Doc الفئة العشوائية جيدًا ، وقد تحقق اختباراتنا من ذلك.
(2) في حالة عدم توفير رقم بذرة ، سيكون عدد بذور المثيل العشوائي هو المللي ثانية من الوقت الحالي. يمكنك الحصول على مللي ثانية من الوقت الحالي من خلال System.CurrentTimeMillis (). افتح الكود المصدري لـ JDK ويمكننا أن نرى هذا بوضوح شديد.
public Random () {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. فئة عشوائية
عشوائي عشوائي = جديد عشوائي () ؛ // مُنشئ الافتراض عشوائي = جديد عشوائي (1000) ؛ // حدد رقم البذور
عند إجراء التوزيع العشوائي ، يسمى عدد أصل الخوارزمية العشوائية البذور ، والتي تؤدي تحولًا معينًا على أساس البذور ، وبالتالي توليد الأرقام العشوائية المطلوبة.
الكائنات العشوائية مع نفس عدد البذور ، الأرقام العشوائية الناتجة عن نفس عدد المرات هي نفسها بالضبط. بمعنى آخر ، بالنسبة لكائنين عشوائيين مع نفس رقم البذور ، فإن الأرقام العشوائية التي تم إنشاؤها لأول مرة هي نفسها تمامًا ، والأرقام العشوائية التي تم إنشاؤها للمرة الثانية هي نفسها تمامًا.
2. الطرق الشائعة في فئة عشوائية
الطرق في الفئة العشوائية بسيطة نسبيًا ، كما أن وظائف كل طريقة سهلة الفهم أيضًا. تجدر الإشارة إلى أن الأرقام العشوائية التي تم إنشاؤها بواسطة كل طريقة في الفئة العشوائية موزعة بشكل موحد ، مما يعني أن احتمال الجيل العددي داخل الفاصل يساوي. فيما يلي مقدمة أساسية لهذه الطرق:
أ ، المنطقية العامة NextBoolean ()
تتمثل وظيفة هذه الطريقة في إنشاء قيمة منطقية عشوائية ، واحتمال توليد القيم الحقيقية والخطأ متساوية ، أي كلاهما 50 ٪.
ب ، مزدوج النيجا المزدوج العام ()
الغرض من هذه الطريقة هو إنشاء قيمة مزدوجة عشوائية ، والقيمة بين [0 ، 1.0). هنا ، تمثل الأقواس نقاط النهاية التي تحتوي على الفاصل الزمني ، وتمثل الأقواس نقاط النهاية التي لا تتضمن الفاصل الزمني ، أي عشري عشوائي بين 0 و 1 ، يحتوي على 0 ولكن ليس 1.0.
ج ، عام int nextint ()
الغرض من هذه الطريقة هو توليد قيمة عشوائية ، والتي هي بين القوة الحادية والثلاثين من -2 و 31 من القوة -1 من 2 من 2.
إذا كنت بحاجة إلى إنشاء قيمة int لفاصل محدد ، فأنت بحاجة إلى إجراء تحول رياضي معين. للحصول على التفاصيل ، يرجى الرجوع إلى الرمز الموجود في مثال الاستخدام أدناه.
D ، Int Nextint (int n)
تتمثل وظيفة هذه الطريقة في إنشاء قيمة int عشوائية ، والتي تقع ضمن الفاصل الزمني لـ [0 ، n) ، أي قيمة int عشوائية بين 0 و n ، تحتوي على 0 ولكن ليس n.
إذا كنت ترغب في إنشاء قيمة int لفاصل محدد ، فأنت بحاجة أيضًا إلى إجراء تحول رياضي معين. للحصول على التفاصيل ، يرجى الرجوع إلى الرمز الموجود في مثال الاستخدام أدناه.
E ، public void 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.
د. توليد أي عدد صحيح
int n1 = r.nextint () ؛
فقط استخدم طريقة NextInT مباشرة.
ه. توليد الأعداد الصحيحة في الفاصل الزمني [0،10)
int n2 = R.NextInt (10) ؛ n2 = Math.ABS (r.nextint () ٪ 10) ؛
يمكن لخطين أعلاه من الكود إنشاء أعداد صحيحة في الفاصل الزمني [0،10).
يتم تنفيذ التطبيق الأول مباشرة باستخدام طريقة NextInt (int n) في الفئة العشوائية.
في التنفيذ الثاني ، استدعاء First NextInt () لإنشاء رقم int تعسفي. الفاصل الزمني الناتج عن مجموع رقم الرقم 10 هو (-10،10) ، لأنه وفقًا للمواصفات الرياضية ، تكون القيمة المطلقة للباقي أقل من المقسوم ، ثم يتم حساب القيمة المطلقة للفاصل الزمني ، والفاصل الزمني الناتج [0،10).
وبالمثل ، لإنشاء أعداد صحيحة عشوائية في أي فاصل [0 ، ن) يمكنك استخدام الكود التالي:
int n2 = r.nextint (n) ؛ n2 = math.abs (r.nextint () ٪ n) ؛
و. توليد الأعداد الصحيحة في الفاصل الزمني [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 أكثر.