ב Java תכנות, לעתים קרובות נדרשנו לכך ליצור מספרים אקראיים בזמן שאנו מפתחים אפליקציות. לאפליקציות רבות יש את התכונה ליצור מספרים באופן אקראי , כגון כדי לאמת את המשתמש יישומים רבים משתמשים ב OTP . הדוגמה הטובה ביותר למספרים אקראיים היא קוביות. כי כשאנחנו זורקים אותו, אנחנו מקבלים מספר אקראי בין 1 ל-6.
בחלק זה נלמד מהו א מספר אקראי ו כיצד ליצור מספרים אקראיים ב Java .
מספר אקראי
מספרים אקראיים הם המספרים המשתמשים בקבוצה גדולה של מספרים ובוחרים מספר באמצעות האלגוריתם המתמטי. הוא עונה על שני התנאים הבאים:
- הערכים שנוצרו מחולקים באופן אחיד על פני מרווח מוגדר.
- אי אפשר לנחש את הערך העתידי על סמך ערכים נוכחיים וקודמים.
יצירת מספר אקראי ב-Java
ב-Java, יש שלוש דרכים ליצור מספרים אקראיים באמצעות השיטה והמחלקות.
תכונות של סדרת פנדה
- משתמש ב אַקרַאִי() שיטה
- משתמש ב אַקרַאִי מעמד
- משתמש ב ThreadLocalRandom מעמד
- משתמש ב ints() שיטה (ב-Java 8)
שימוש בשיטת Math.random()
הג'אווה מתמטיקה לכיתה יש שיטות רבות לפעולות מתמטיות שונות. אחד מהם הוא ה אַקרַאִי() שיטה. זה סטָטִי שיטת השיעור במתמטיקה. אנחנו יכולים להפעיל את זה ישירות. זה מייצר רק לְהַכפִּיל הקלד מספר אקראי גדול או שווה ל-0.0 ו פחות מ-1.0 . לפני השימוש בשיטת random(), עלינו לייבא את ה-java.lang.Mathמעמד.
תחביר:
public static double random()
זה לא מקבל שום פרמטר. הוא מחזיר כפול פסאודו אקראי שגדול או שווה ל-0.0 וקטן מ-1.0.
בואו ניצור תוכנית המייצרת מספרים אקראיים בשיטת random() .
RandomNumberExample1.java
import java.lang.Math; public class RandomNumberExample1 { public static void main(String args[]) { // Generating random numbers System.out.println('1st Random Number: ' + Math.random()); System.out.println('2nd Random Number: ' + Math.random()); System.out.println('3rd Random Number: ' + Math.random()); System.out.println('4th Random Number: ' + Math.random()); } } תְפוּקָה:
1st Random Number: 0.17434160924512265 2nd Random Number: 0.4297410090709448 3rd Random Number: 0.4828656381344487 4th Random Number: 0.13267917059488898
זכור: בכל פעם אנו מקבלים פלט אחר כאשר אנו מבצעים את התוכנית. הפלט שלך עשוי להיות שונה מהפלט המוצג לעיל.
נוכל גם להשתמש בנוסחה הבאה אם ברצוננו ליצור מספר אקראי בין טווח מוגדר.
Math.random() * (max - min + 1) + min
בנוסחה שלמעלה, ערך המינימום כולל בעוד שהערך המקסימלי הוא בלעדי.
בואו ניצור תוכנית שמייצרת מספרים אקראיים בין 200 ל-400.
קריאת קובץ csv ב-java
RandomNumberExample2.java
public class RandomNumberExample2 { public static void main( String args[] ) { int min = 200; int max = 400; //Generate random double value from 200 to 400 System.out.println('Random value of type double between '+min+' to '+max+ ':'); double a = Math.random()*(max-min+1)+min; System.out.println(a); //Generate random int value from 200 to 400 System.out.println('Random value of type int between '+min+' to '+max+ ':'); int b = (int)(Math.random()*(max-min+1)+min); System.out.println(b); } } פלט 1:
Random value of type double between 200 to 400: 233.88329802655377 Random value of type int between 200 to 400: 329
פלט 2:
Random value of type double between 200 to 400: 254.8419979875385 Random value of type int between 200 to 400: 284
שימוש בכיתה האקראית
דרך נוספת ליצור מספר אקראי היא להשתמש ב- Java אַקרַאִי מעמד של הjava.utilחֲבִילָה. זה מייצר זרם של מספרים פסאודו אקראיים. אנו יכולים ליצור מספר אקראי מכל סוג נתונים, כגון מספר שלם, צף, כפול, בוליאני, ארוך. אם אתה מתכוון להשתמש במחלקה זו כדי ליצור מספרים אקראיים, בצע את השלבים המפורטים להלן:
- ראשית, ייבא את המחלקהjava.lang.Random.
- ליצור לְהִתְנַגֵד של הכיתה האקראית.
- השתמש בכל אחת מהשיטות הבאות:
כל השיטות שלעיל מחזירות את הערך הפסאודו-אקראי הבא, המופץ בצורה הומוגנית (שיטה מקבילה) מרצף מחולל המספרים האקראיים הזה. ה nextDouble() ו nextFloat() השיטה יוצרת ערך אקראי בין 0.0 ל-1.0.
ה nextInt(int bound) השיטה מקבלת גבול פרמטר (עליון) שחייב להיות חיובי. זה יוצר מספר אקראי בטווח 0 עד bound-1.
בואו ניצור תוכנית המייצרת מספרים אקראיים באמצעות המחלקה Random.
java core java
RandomNumberExample3.java
import java.util.Random; public class RandomNumberExample3 { public static void main(String args[]) { // creating an object of Random class Random random = new Random(); // Generates random integers 0 to 49 int x = random.nextInt(50); // Generates random integers 0 to 999 int y = random.nextInt(1000); // Prints random integer values System.out.println('Randomly Generated Integers Values'); System.out.println(x); System.out.println(y); // Generates Random doubles values double a = random.nextDouble(); double b = random.nextDouble(); // Prints random double values System.out.println('Randomly Generated Double Values'); System.out.println(a); System.out.println(b); // Generates Random float values float f=random.nextFloat(); float i=random.nextFloat(); // Prints random float values System.out.println('Randomly Generated Float Values'); System.out.println(f); System.out.println(i); // Generates Random Long values long p = random.nextLong(); long q = random.nextLong(); // Prints random long values System.out.println('Randomly Generated Long Values'); System.out.println(p); System.out.println(q); // Generates Random boolean values boolean m=random.nextBoolean(); boolean n=random.nextBoolean(); // Prints random boolean values System.out.println('Randomly Generated Boolean Values'); System.out.println(m); System.out.println(n); } } תְפוּקָה:
Randomly Generated Integers Values 23 767 Randomly Generated Double Values 0.37823814494212016 0.998058172671956 Randomly Generated Float Values 0.87804186 0.93880254 Randomly Generated Long Values -4974823544291679198 3650240138416076693 Randomly Generated Boolean Values false true
שימוש במחלקת ThreadLocalRandom
ה ThreadLocalRandom מחלקה מוגדרת בjava.util.concurrentחֲבִילָה. הוא מאותחל עם סיד שנוצר באופן פנימי, זהה למחולל האקראי של הכיתה Math. לא ניתן לשנות אותו. אנו יכולים להשתמש בכיתה זו בצורה הבאה:
ThreadLocalRandom.current().nextX(...)
כאשר X הוא Int, Long וכו'.
הערה: זה בלתי אפשרי לשתף ThreadLocalRandom עם שרשורים מרובים בטעות.
אנו יכולים ליצור מספר אקראי מכל סוג נתונים, כגון מספר שלם, צף, כפול, בוליאני, ארוך. אם אתה מתכוון להשתמש במחלקה זו כדי ליצור מספרים אקראיים, בצע את השלבים המפורטים להלן:
- ראשית, ייבא את המחלקה באמצעותjava.util.concurrent.ThreadLocalRandom.
- הפעל את השיטה המתאימה שעבורה ברצונך ליצור מספרים באופן אקראי.
כל השיטות לעיל עוקפות את השיטה המתאימה של המחלקה Random ומחזירות את הערך המתאים.
השיטות לעיל מנתחות פרמטר כָּרוּך (עליון) זה חייב להיות חִיוּבִי . הוא מחזיר את הערך המקביל שנוצר באקראי בין 0 (כולל) לבין הגבול שצוין (בלעדי). זה זורק חריגה לא חוקית אם הגבול שלילי.
השיטות לעיל מנתחות שני פרמטרים מָקוֹר ו כָּרוּך . המקור מציין את הכי פחות ערך חזר והגבול מציין את גבול עליון . הוא מחזיר ערך מקביל שנוצר באקראי בין המקור שצוין (כולל) לבין bound (בלעדי). כמו כן, זורק חריגה לא חוקית אם המקור גדול או שווה ל-bound.
בואו ניצור תוכנית המייצרת מספרים אקראיים באמצעות ה מחלקה ThreadLocalRandom .
RandomNumberExample4.java
ד כפכף
import java.util.concurrent.ThreadLocalRandom; public class RandomNumberExample4 { public static void main(String args[]) { // Generate random integers between 0 to 999 int a = ThreadLocalRandom.current().nextInt(); int b = ThreadLocalRandom.current().nextInt(); // Print random integer values System.out.println('Randomly Generated Integer Values:'); System.out.println(a); System.out.println(b); // Generate Random double values double c = ThreadLocalRandom.current().nextDouble(); double d = ThreadLocalRandom.current().nextDouble(); // Print random doubles System.out.println('Randomly Generated Double Values:'); System.out.println(c); System.out.println(d); // Generate random boolean values boolean e = ThreadLocalRandom.current().nextBoolean(); boolean f = ThreadLocalRandom.current().nextBoolean(); // Print random Booleans System.out.println('Randomly Generated Boolean Values:'); System.out.println(e); System.out.println(f); } } פלט 1:
Randomly Generated Integer Values: 348534891 -1887936727 Randomly Generated Double Values: 0.15644440033119833 0.5242730752133399 Randomly Generated Boolean Values: true true
פלט 2:
Output 2: Randomly Generated Integer Values: 402755574 295398333 Randomly Generated Double Values: 0.4856461791062565 0.5148677091077654 Randomly Generated Boolean Values: false true
באופן דומה, אנו יכולים להשתמש בשיטות אחרות של ThreadLocalRandomclass .
יצירת מספרים אקראיים ב-Java 8
ב-Java 8, שיטה חדשה ints() נוספה ל- שיעור אקראי . אנחנו חייבים לייבא אתjava.util.Randomלפני השימוש בשיטה.
ints():
ערכי ה-int pseudorandom נוצרו כמו קריאה למתודה nextInt() . זה מחזיר זרם בלתי מוגבל של ערכי אינט פסאודו אקראיים.
ints(long streamSize):
השיטה מנתחת פרמטר streamSize מהסוג ארוך. הוא מציין את מספר הערכים שייווצרו. ערכי ה-int pseudorandom נוצרו כמו קריאה למתודה nextInt() . זה גם מחזיר זרם של ערכי int שנוצרו באופן אקראי. זה זורק חריג טיעון לא חוקי אם גודל הזרם קטן מאפס.
ints(long streamSize, int randomNumberOrigin, int randomNumberBound):
פרמטרים:
הוא מחזיר זרם של ערכי אינט פסאודו אקראיים עם המקור והקשור שצוין. זה זורק חריג טיעון לא חוקי אם:
- stramSize<0< li>
- מקור > = קשור
ints(int randomNumberOrigin, int randomNumberBound):
פרמטרים:
הוא מחזיר זרם בלתי מוגבל של ערכי אינט פסאודו אקראיים עם המקור והקשור שצוין. זה זורק חריג טיעון לא חוקי אם המקור גדול או שווה ל-bound.
מערכים ב-java
באופן דומה, אנו יכולים גם ליצור זרם של סוגים ארוכים וכפולים על ידי שימוש ב- ארוך() ו כפול() שיטה, בהתאמה.
בואו ניצור תוכנית שמייצרת זרם של מספרים שלמים באמצעות ה ints() שיטת המחלקה האקראית.
RandomNumberExample5.java
import java.util.Random; public class RandomNumberExample5 { public static void main(String[] args) { randomInts(5); randomInts(9, 50, 90); //getStreamOfRandomInts(30, 50); } //method that generates a stream of integers having size 5 public static void randomInts(int num) { Random random = new Random(); random.ints(num).forEach(System.out::println); } //method that generates a stream of 9 integers between 50 to 90 public static void randomInts(int num, int origin, int bound) { Random random1 = new Random(); random1.ints(num, origin, bound).forEach(System.out::println); } } פלט 1:
727900357 -1073118456 306279822 370327182 1366265119 65 75 75 88 76 75 56 86 85
פלט 2:
-1338107947 -1698771421 594232770 -1224937976 -1625069815 56 69 67 87 64 52 72 75 76