जावा में निर्दिष्ट सीमा में यादृच्छिक संख्याओं का जनन: ट्यूटोरियल

जावा में यादृच्छिक संख्याएँ: अराजकता से व्यवस्था तक

नमस्ते, भविष्य के जावा डेवलपर! यदि आपने कभी गेम, सिमुलेशन, टेस्ट लिखे हैं या बस अपने प्रोग्राम में आश्चर्य का तत्व जोड़ना चाहा है, तो आपने निश्चित रूप से निर्दिष्ट सीमा में एक यादृच्छिक पूर्णांक प्राप्त करने की आवश्यकता का सामना किया होगा। यह कितना आसान लगता है? लेकिन व्यवहार में, शुरुआती लोगों के मन में अक्सर यह सवाल उठता है: "मुझे 50 से 100 के बजाय 0 से 100 तक की संख्याएँ क्यों मिल रही हैं?" या "मेरा कोड एरर क्यों दे रहा है?"।

आज हम इस विषय को एक बार और हमेशा के लिए समझ लेंगे। आप सीखेंगे कि जावा में किसी भी सीमा में यादृच्छिक संख्या कैसे उत्पन्न करें, तीन मुख्य तरीकों का उपयोग करके। स्पॉइलर: उनमें से एक 90% मामलों के लिए सबसे अच्छा विकल्प है। चलिए शुरू करते हैं!

यह क्यों महत्वपूर्ण है?

यादृच्छिक संख्याओं का जनन एक बुनियादी लेकिन अत्यंत महत्वपूर्ण कार्य है। इसके बिना निम्नलिखित कार्य नहीं हो सकते:

\n
• परीक्षण डेटा बनाना (उदाहरण के लिए, उपयोगकर्ता आईडी)।
\n
• गेम मैकेनिक्स को लागू करना (आइटम ड्रॉप, स्तर जनन)।
\n
• यादृच्छिक प्रक्रियाओं का मॉडलिंग (कतारें, ट्रैफ़िक)।
\n
• सूची से यादृच्छिक तत्व का चयन करना।
\n

इस विषय में महारत हासिल करके, आप कोड में "जादू" से डरना बंद कर देंगे और आत्मविश्वास से यादृच्छिकता को नियंत्रित कर पाएंगे।

विधि संख्या 1: क्लासिक — java.util.Random

यह जावा में सभी जनरेटर का दादा है। क्लास java.util.Random शुरुआती संस्करणों से मौजूद है और आज भी सक्रिय रूप से उपयोग किया जाता है। इसका मुख्य लाभ इसकी बहुमुखी प्रतिभा है।

0 से N तक यादृच्छिक int कैसे प्राप्त करें?

विधि nextInt(int bound) 0 (सम्मिलित) से bound (अनन्य) तक एक यादृच्छिक संख्या लौटाती है। यानी यदि आप nextInt(10) लिखते हैं, तो आपको 0 से 9 तक की संख्या मिलेगी।

import java.util.Random;\n\npublic class RandomExample {\n    public static void main(String[] args) {\n        Random random = new Random();\n        int number = random.nextInt(10); // 0..9\n        System.out.println("यादृच्छिक संख्या: " + number);\n    }\n}

5 से 15 तक कैसे करें?

यहीं पर मुख्य रहस्य छिपा है। एक मनमानी सीमा [min, max] में संख्या प्राप्त करने के लिए, सूत्र का उपयोग करें:

min + random.nextInt(max - min + 1)

आइए इसे एक उदाहरण से समझते हैं: 5 से 15 तक की सीमा।

\n
• max - min + 1 = 15 - 5 + 1 = 11। इसका मतलब है कि nextInt(11) 0 से 10 तक की संख्याएँ देगा।
\n
• min (5) जोड़ें: हमें 5..15 की सीमा मिलती है।
\n

जाँच करें: यदि nextInt(11) ने 0 लौटाया, तो 0+5 = 5। यदि 10 लौटाया, तो 10+5 = 15। बिल्कुल सही!

Random random = new Random();\nint min = 5;\nint max = 15;\nint randomNumber = min + random.nextInt(max - min + 1);\nSystem.out.println("5 से 15 तक यादृच्छिक संख्या: " + randomNumber);

महत्वपूर्ण: +1 मत भूलना! इसके बिना, अधिकतम मान 1 कम होगा।

विधि संख्या 2: आधुनिक दृष्टिकोण — ThreadLocalRandom

Java 7 से शुरू करके, क्लास ThreadLocalRandom आया। यह विशेष रूप से मल्टीथ्रेडेड अनुप्रयोगों के लिए बनाया गया है (लेकिन सिंगल-थ्रेडेड में भी बढ़िया काम करता है)। मुख्य लाभ यह है कि यह Random से तेज़ है और एक अलग ऑब्जेक्ट बनाने की आवश्यकता नहीं है।

सिंगल-थ्रेडेड कोड में उपयोग

इसमें एक सुविधाजनक विधि nextInt(int origin, int bound) है, जो सीधे सीमा की सीमाएँ लेती है! ध्यान दें: origin — सम्मिलित, bound — अनन्य। यदि आपको ऊपरी सीमा को भी शामिल करना है, तो बस +1 जोड़ें।

import java.util.concurrent.ThreadLocalRandom;\n\npublic class ThreadLocalRandomExample {\n    public static void main(String[] args) {\n        // 5 से 15 तक की संख्या (सम्मिलित)\n        int randomNumber = ThreadLocalRandom.current().nextInt(5, 16);\n        System.out.println("यादृच्छिक संख्या: " + randomNumber);\n    }\n}

देखो कितना आसान है? कोई सूत्र नहीं,