मैं जावा में एक विशिष्ट सीमा के भीतर यादृच्छिक पूर्णांक कैसे उत्पन्न करूं?

Question

मैं intकिसी विशिष्ट श्रेणी में यादृच्छिक मान कैसे उत्पन्न करूं ?

मैंने निम्नलिखित कोशिश की है, लेकिन वे काम नहीं करते हैं:

प्रयास 1:

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

प्रयास 2:

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.

Comments

जब आपको बहुत अधिक यादृच्छिक संख्याओं की आवश्यकता होती है, तो मैं एपीआई में रैंडम वर्ग की सिफारिश नहीं करता हूं। इसकी अभी बहुत छोटी अवधि है। बजाय Mersenne ट्विस्टर की कोशिश करो । नहीं है एक जावा कार्यान्वयन ।

— raupach

नया उत्तर पोस्ट करने से पहले, विचार करें कि इस प्रश्न के लिए पहले से ही 65+ उत्तर हैं। कृपया, सुनिश्चित करें कि आपका उत्तर उन सूचनाओं का योगदान करता है जो मौजूदा उत्तरों में नहीं हैं।

— janniks

Answer 1

में जावा 1.7 या बाद में , यह करने के लिए मानक तरीका इस प्रकार है:

import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

प्रासंगिक JavaDoc देखें । इस दृष्टिकोण को स्पष्ट रूप से java.util.Random उदाहरण को स्पष्ट रूप से आरंभ करने की आवश्यकता नहीं है , जो अनुचित तरीके से उपयोग किए जाने पर भ्रम और त्रुटि का स्रोत हो सकता है।

हालांकि, इसके विपरीत, बीज को स्पष्ट रूप से निर्धारित करने का कोई तरीका नहीं है, इसलिए उन स्थितियों में परिणामों को पुन: पेश करना मुश्किल हो सकता है जहां यह परीक्षण या गेम स्टेट्स या इसी तरह की बचत के रूप में उपयोगी है। उन स्थितियों में, नीचे दिखाए गए पूर्व-जावा 1.7 तकनीक का उपयोग किया जा सकता है।

जावा 1.7 से पहले , ऐसा करने का मानक तरीका इस प्रकार है:

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

प्रासंगिक JavaDoc देखें । व्यवहार में, java.util.Random वर्ग अक्सर java.lang.Math.random () के लिए बेहतर है ।

विशेष रूप से, कार्य को पूरा करने के लिए मानक पुस्तकालय के भीतर एक सीधा एपीआई होने पर यादृच्छिक पूर्णांक पीढ़ी के पहिये को सुदृढ़ करने की आवश्यकता नहीं है।

Comments

उन कॉलों के लिए जहां maxमान Integer.MAX_VALUEहोना अतिप्रवाह है, परिणामस्वरूप a java.lang.IllegalArgumentException। आप के साथ कोशिश कर सकते हैं randInt(0, Integer.MAX_VALUE):। इसके अलावा, अगर nextInt((max-min) + 1)सबसे अधिक मूल्य (काफी दुर्लभ, मुझे लगता है) यह फिर से अतिप्रवाह नहीं होगा (न्यूनतम और अधिकतम उच्च मान हैं)? इस तरह की परिस्थितियों से कैसे निपटें?

— डैनियल

@MoisheLipsker यह होना चाहिए कि नेक्स्ट लॉन्ग नेक्स्ट के रूप में एक बाउंड नहीं लिया है

— एमएमएम

ThreadLocalRandomयह प्रश्न पहली बार पूछे जाने के बाद @leventov को जावा 2 1/2 साल में जोड़ा गया था। मैं हमेशा इस बात पर दृढ़ रहा हूं कि रैंडम उदाहरण का प्रबंधन प्रश्न के दायरे से बाहर है।

— ग्रेग केस

एंड्रॉइड रैंडम रैंड में = नया रैंडम ();

— वेबसर्विस

इस उदाहरण में टिप्पणियों में संबोधित किया गया है। लघु संस्करण - आपको फ़ंक्शन के प्रत्येक कॉल के लिए = नया रैंडम () नहीं होना चाहिए, या आपके परिणाम कई मामलों के लिए पर्याप्त रूप से यादृच्छिक नहीं होंगे।

— ग्रेग केस

Answer 2

ध्यान दें कि यह दृष्टिकोण एक दृष्टिकोण से अधिक पक्षपाती और कम कुशल है nextInt, https://stackoverflow.com/a/738651/360211

इसे पूरा करने के लिए एक मानक पैटर्न है:

Min + (int)(Math.random() * ((Max - Min) + 1))

जावा मठ पुस्तकालय समारोह math.random () रेंज में एक डबल मूल्य उत्पन्न करता है [0,1)। ध्यान दें कि इस श्रेणी में 1 शामिल नहीं है।

पहले मानों की एक विशिष्ट श्रेणी प्राप्त करने के लिए, आपको उन मानों की श्रेणी के परिमाण से गुणा करना होगा जिन्हें आप कवर करना चाहते हैं।

Math.random() * ( Max - Min )

यह उस श्रेणी में एक मान लौटाता है [0,Max-Min), जहाँ 'मैक्स-मिन' शामिल नहीं है।

उदाहरण के लिए, यदि आप चाहें [5,10), तो आपको पाँच पूर्णांक मानों को कवर करने की आवश्यकता है ताकि आप उपयोग करें

Math.random() * 5

यह उस श्रेणी में मान लौटाएगा [0,5), जहां 5 शामिल नहीं है।

अब आपको इस सीमा को उस सीमा तक स्थानांतरित करना होगा जिसे आप लक्षित कर रहे हैं। आप मिन वैल्यू को जोड़कर ऐसा करते हैं।

Min + (Math.random() * (Max - Min))

अब आपको रेंज में एक मूल्य मिलेगा [Min,Max)। हमारे उदाहरण के बाद, इसका मतलब है कि [5,10):

5 + (Math.random() * (10 - 5))

लेकिन, इसमें अभी भी शामिल नहीं है Maxऔर आपको एक डबल मूल्य मिल रहा है। Maxमूल्य शामिल करने के लिए , आपको अपने रेंज पैरामीटर में 1 जोड़ने की जरूरत है (Max - Min)और फिर एक इंट से कास्टिंग करके दशमलव भाग को छोटा करना है। इसके माध्यम से पूरा किया जाता है:

Min + (int)(Math.random() * ((Max - Min) + 1))

आखिर तुमने इसे हासिल कर ही लिया है। सीमा [Min,Max]में या उदाहरण के अनुसार एक यादृच्छिक पूर्णांक मान [5,10]:

5 + (int)(Math.random() * ((10 - 5) + 1))

Comments

सन डॉक्यूमेंटेशन स्पष्ट रूप से कहता है कि आपको Math.random () के बजाय एक int (रैंडम) का बेहतर उपयोग करना चाहिए।

— लिलियन ए। मोरारू

यह वास्तव में अगले iInt तरीकों stackoverflow.com/a/738651/360211

— वेस्टन

इस मामले में "बायस्ड" का मतलब है कि 2 ^ 53 निष्पादन के बाद, कुछ संख्याओं में औसतन एक अतिरिक्त कमी होगी।

— सेफेलोपॉड

Answer 3

उपयोग:

Random ran = new Random();
int x = ran.nextInt(6) + 5;

पूर्णांक xअब यादृच्छिक संख्या है जिसका संभावित परिणाम है 5-10।

Answer 4

उपयोग:

minimum + rn.nextInt(maxValue - minvalue + 1)

Answer 5

साथ में जावा-8उन्होंने कक्षा ints(int randomNumberOrigin, int randomNumberBound)में विधि पेश की Random।

उदाहरण के लिए यदि आप रेंज में पाँच यादृच्छिक पूर्णांक (या एक एकल) उत्पन्न करना चाहते हैं [0, 10], बस करें:

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

पहला पैरामीटर केवल IntStreamउत्पन्न के आकार को इंगित करता है (जो कि असीमित उत्पादन करने वाले की अतिभारित विधि है IntStream)।

यदि आपको कई अलग-अलग कॉल करने की आवश्यकता है, तो आप स्ट्रीम से एक अनंत आदिम पुनरावृत्त बना सकते हैं:

public final class IntRandomNumberGenerator {

    private PrimitiveIterator.OfInt randomIterator;

    /**
     * Initialize a new random number generator that generates
     * random numbers in the range [min, max]
     * @param min - the min value (inclusive)
     * @param max - the max value (inclusive)
     */
    public IntRandomNumberGenerator(int min, int max) {
        randomIterator = new Random().ints(min, max + 1).iterator();
    }

    /**
     * Returns a random number in the range (min, max)
     * @return a random number in the range (min, max)
     */
    public int nextInt() {
        return randomIterator.nextInt();
    }
}

आप इसे मूल्यों doubleऔर longमूल्यों के लिए भी कर सकते हैं । मुझे उम्मीद है यह मदद करेगा! :)

Comments

मैं आपको सुझाव दूंगा कि आप केवल एक बार ही randomIterator को इंस्टेंट करें। देखें ग्रेग केस की टिप्पणी उनके ही जवाब पर।

— Naxos84

यदि आप कर सकते हैं, तो आप बता सकते हैं कि इसका क्या महत्व है streamSize- इस पद्धति का पहला परम streamSize !=0। यदि streamSize1/2 / n दिया जाता है तो क्या अंतर है?

— इरफान अहमद

Answer 6

आप अपने दूसरे कोड उदाहरण को संपादित कर सकते हैं:

Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;

Answer 7

आपके पहले समाधान का बस एक छोटा संशोधन पर्याप्त होगा।

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

---

के कार्यान्वयन के लिए यहाँ और अधिक देखें Random

Comments

न्यूनतम <= मान के लिए <अधिकतम, मैंने मठ के साथ भी ऐसा ही किया: randomNum = न्यूनतम + (int) (Math.random () * (अधिकतम-न्यूनतम)); लेकिन कास्टिंग वास्तव में देखने के लिए अच्छा नहीं है;)

— AxelH

कम से कम 7 साल देर से डुप्लिकेट जवाब।

— मार्टन बॉड्यूज

Answer 8

ThreadLocalRandomjava.util.Randomबहुमूत्र पर्यावरण के लिए कक्षा के बराबर । प्रत्येक थ्रेड में एक यादृच्छिक संख्या उत्पन्न करना स्थानीय रूप से किया जाता है। इसलिए संघर्षों को कम करके हमारा बेहतर प्रदर्शन है।

int rand = ThreadLocalRandom.current().nextInt(x,y);

x, y- अंतराल जैसे (1,10)

Answer 9

Math.Randomमें कक्षा जावा 0-आधारित है। तो, अगर आप ऐसा कुछ लिखते हैं:

Random rand = new Random();
int x = rand.nextInt(10);

x0-9समावेशी के बीच होगा ।

तो, 25वस्तुओं के निम्नलिखित सरणी को देखते हुए , कोड 0(सरणी के आधार) के बीच एक यादृच्छिक संख्या उत्पन्न करने के लिए कोड array.lengthहोगा और होगा:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

चूंकि i.lengthवापस आएगा 25, nextInt( i.length )सीमा के बीच एक नंबर लौटाएगा 0-24। दूसरा विकल्प Math.Randomउसी के साथ काम कर रहा है ।

index = (int) Math.floor(Math.random() * i.length);

एक बेहतर समझ के लिए, फोरम पोस्ट रैंडम इंटरवल (आर्काइव.ऑर्ग) देखें ।

Comments

+1 forBackMachine आर्काइव स्क्रीनशॉट लिंक और आपका उत्तर अभी भी "यादृच्छिक" ints w / को एक सीमा में प्राप्त करने के लिए उपयोगी संदर्भ है।

— तपेर 7

यह मुझे

— चकित करता है

@CodeConfident indexचर यादृच्छिक संख्या के परिणाम को प्रभावित नहीं करेगा। आप इसे बदलने के बारे में चिंता किए बिना किसी भी तरह से इसे शुरू करने का विकल्प चुन सकते हैं। उम्मीद है की यह मदद करेगा।

— मैट आर

बिल्कुल सही ... यह पूरी तरह से अप्रयुक्त है। मैं इसे सीधे रैंड के लिए शुरू करूंगा:int index = rand.nextInt(i.Length);

— AjahnCharles

या बिल्कुल नहीं। int index; \n index = rand...यदि कोई विभिन्न लाइनों पर घोषणाओं और असाइनमेंट का शौकीन है। कुछ कोडिंग मानक दूसरों की तुलना में अधिक कठोर (और स्पष्ट उद्देश्य के बिना) हैं।

— मार्क स्टॉपर

Answer 10

मुझे उपवास करने के लिए क्षमा करें, लेकिन बहुमत द्वारा सुझाए गए समाधान, यानी, min + rng.nextInt(max - min + 1))इस तथ्य के कारण खतरनाक लगता है:

• rng.nextInt(n)नहीं पहुंच सकता Integer.MAX_VALUE।
• (max - min)minनकारात्मक होने पर अतिप्रवाह हो सकता है।

एक मूर्खतापूर्ण समाधान किसी भी min <= max[ Integer.MIN_VALUE, Integer.MAX_VALUE] के लिए सही परिणाम लौटाएगा । निम्नलिखित भोले कार्यान्वयन पर विचार करें:

int nextIntInRange(int min, int max, Random rng) {
   if (min > max) {
      throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
   }
   int diff = max - min;
   if (diff >= 0 && diff != Integer.MAX_VALUE) {
      return (min + rng.nextInt(diff + 1));
   }
   int i;
   do {
      i = rng.nextInt();
   } while (i < min || i > max);
   return i;
}

हालांकि अक्षम है, ध्यान दें कि whileलूप में सफलता की संभावना हमेशा 50% या अधिक होगी।

Comments

जब अंतर = Integer.MAX_VALUE हो तो एक IllegalArgumentException को क्यों नहीं फेंकना चाहिए? फिर आपको लूप की आवश्यकता नहीं है।

— एमपी कोरस्टंज

@mpkorstanje यह कार्यान्वयन न्यूनतम <= अधिकतम के किसी भी मान के साथ काम करने के लिए डिज़ाइन किया गया है, तब भी जब उनका अंतर MAX_VALUE के बराबर या उससे भी बड़ा हो। इस मामले में जब तक सफलता नहीं मिलती है, तब तक एक लूप चलाना एक समान वितरण की गारंटी देता है (यदि यादृच्छिकता का अंतर्निहित स्रोत एक समान है)। Random.nextInt (int) इसे आंतरिक रूप से करता है जब तर्क 2 की शक्ति नहीं होती है

— ईसाई सेमरा

Answer 11

यह केवल कथन कर के किया जा सकता है:

Randomizer.generate(0,10); //min of zero, max of ten

नीचे इसका स्रोत-कोड है

Randomizer.java

public class Randomizer {
    public static int generate(int min,int max) {
        return min + (int)(Math.random() * ((max - min) + 1));
    }
}

यह सिर्फ साफ और सरल है।

Comments

यह दूसरे उदाहरण का एक संपादन हो सकता था, अब यह प्रतिष्ठा के लिए केवल एक प्रतिरूप है। "सबसे अधिक वोटों के साथ उत्तर" को इंगित करना भी बहुत प्रत्यक्ष नहीं है, यह बदल सकता है।

— मार्टन बोडेवेस

यह सही है @MaartenBodewes। जब मैंने यह उत्तर लिखा था, तब भी सबसे अधिक वोटों के साथ उत्तर को एल्गोरिथम जैसा हल लिखा गया था। अब, ऊपर का समाधान बहुत बदल गया है और अब यह जवाब कॉपी-कैट की तरह लग रहा है।

— हाबिल कैलेजो

मुझे वास्तव में यह पता नहीं है कि इस तरह के मौलिक बिट्स जावा मानक पुस्तकालयों का हिस्सा क्यों नहीं हैं। मुझे इसे क्यों लागू करना है?

— लीवी एल

Answer 12

मुझे आश्चर्य है कि यदि कोई अपाचे कॉमन्स मैथ लाइब्रेरी द्वारा प्रदान की गई यादृच्छिक संख्या उत्पन्न करने वाले तरीके बिल को फिट करेंगे।

उदाहरण के लिए: RandomDataGenerator.nextIntयाRandomDataGenerator.nextLong

Answer 13

एक उदाहरण लेते हैं।

मान लीजिए कि मैं 5-10 के बीच एक संख्या उत्पन्न करना चाहता हूं :

int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);

आइए हम इसे समझते हैं ...

अधिकतम मूल्य के साथ अधिकतम को न्यूनतम करें और न्यूनतम मूल्य के साथ न्यूनतम करें।

अब, हमें यह निर्धारित करने की आवश्यकता है कि कितने संभावित मूल्य प्राप्त किए जा सकते हैं। इस उदाहरण के लिए, यह होगा:

5, 6, 7, 8, 9, 10

तो, इस की गणना अधिकतम - न्यूनतम + 1 होगी।

यानी 10 - 5 + 1 = 6

यादृच्छिक संख्या 0-5 के बीच एक संख्या उत्पन्न करेगी ।

यानी 0, 1, 2, 3, 4, 5

यादृच्छिक संख्या में न्यूनतम मान जोड़ना होगा:

5, 6, 7, 8, 9, 10

इसलिए हम वांछित सीमा प्राप्त करते हैं।

Answer 14

 rand.nextInt((max+1) - min) + min;

Answer 15

अगली (n) विधि का उपयोग करके न्यूनतम और अधिकतम के अंतर के लिए एक यादृच्छिक संख्या उत्पन्न करें और फिर परिणाम में न्यूनतम संख्या जोड़ें:

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

Answer 16

मैं इसका उपयोग करता हूं:

 /**
   * @param min - The minimum.
   * @param max - The maximum.
   * @return A random double between these numbers (inclusive the minimum and maximum).
   */
 public static double getRandom(double min, double max) {
   return (Math.random() * (max + 1 - min)) + min;
 }

आप चाहें तो इसे इंटेगर में डाल सकते हैं।

Comments

यह फ़ंक्शन बार-बार एक ही नंबर का उत्पादन करता है। मेरे मामले में यह था:

— २१४48४3३६४ case

विफल: आपके पास एक फ़ंक्शन है जिसमें एक डबल की आवश्यकता होती है और फिर + 1 प्रदर्शन करते हैं? यह निश्चित रूप से कम से कम आश्चर्य के सिद्धांत के खिलाफ जाता है। यदि आप मिनट = 0.1 और अधिकतम = 0.2 का उपयोग करते हैं तो क्या होगा?

— Maarten Bodewes

@sokras विधि कॉल new Random(JavaDoc की जाँच करें): "एक नया यादृच्छिक संख्या जनरेटर बनाता है। यह निर्माता यादृच्छिक संख्या जनरेटर के बीज को इस निर्माता के किसी भी अन्य आह्वान से अलग होने की संभावना के लिए निर्धारित करता है।" वर्तमान में बीज के रूप में वर्तमान समय का उपयोग करने की बहुत संभावना है। यदि वह समय मिलीसेकंड का उपयोग करता है तो वर्तमान कंप्यूटर समान संख्या उत्पन्न करने के लिए पर्याप्त तेज़ हैं। लेकिन इसके अलावा 2147483647 है Integer.MAX_VALUE; आउटपुट स्पष्ट रूप से इनपुट पर निर्भर करता है, जिसे आपने निर्दिष्ट नहीं किया है।

— मार्टन बोडेवेस

अंत में वह पाया गया जो वास्तव में काम करता है

— Jency

Answer 17

जावा 7 के रूप में, आपको अब उपयोग नहीं करना चाहिए Random। अधिकांश उपयोगों के लिए, पसंद का यादृच्छिक संख्या जनरेटर अब है ThreadLocalRandom।

कांटा पूल और समानांतर धाराओं में शामिल होने के लिए उपयोग करें SplittableRandom।

जोशुआ बलोच। प्रभावी जावा। तीसरा संस्करण।

जावा 8 से शुरू

कांटा पूल और समानांतर धाराओं में शामिल हो जाता है, SplittableRandomजो आमतौर पर तेज होता है, की तुलना में बेहतर सांख्यिकीय स्वतंत्रता और एकरूपता गुण होते हैं Random।

intरेंज में एक यादृच्छिक उत्पन्न करने के लिए[0, 1_000]:

int n = new SplittableRandom().nextInt(0, 1_001);

int[100]रेंज में मूल्यों की एक यादृच्छिक सरणी उत्पन्न करने के लिए[0, 1_000]:

int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

यादृच्छिक मानों की स्ट्रीम वापस करने के लिए:

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

Comments

क्या कोई कारण है कि उदाहरण में ए शामिल है .parallel()? मुझे ऐसा लगता है कि 100 यादृच्छिक संख्याओं को उत्पन्न करना भी वारंट समानता के लिए बहुत मामूली होगा।

— जॉनबोट

@ जॉनबॉट टिप्पणी के लिए धन्यवाद, आप सही हैं। लेकिन, मुख्य कारण एक एपीआई दिखाना था (बेशक, parallelप्रसंस्करण का उपयोग करने से पहले प्रदर्शन को मापने के लिए स्मार्ट पथ है )। वैसे, 1_000_000तत्वों की सरणी के लिए , parallelसंस्करण क्रमिक की तुलना में मेरी मशीन पर 2 गुना तेज था।

— ऑलेक्ज़ेंडर प्य्रोहोव

Answer 18

बस यादृच्छिक वर्ग का उपयोग करें :

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);

Comments

मुझे यहाँ कुछ भी नया नहीं दिख रहा है जो पहले के अनगिनत पोस्ट में पोस्ट नहीं किया गया था।

— मार्टन बोडेवेस

Answer 19

इस तरीके का उपयोग करने के लिए सुविधाजनक हो सकता है:

यह विधि प्रदान की गई न्यूनतम और अधिकतम मूल्य के बीच एक यादृच्छिक संख्या लौटाएगी:

public static int getRandomNumberBetween(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt(max - min) + min;
    if (randomNumber == min) {
        // Since the random number is between the min and max values, simply add 1
        return min + 1;
    } else {
        return randomNumber;
    }
}

और यह विधि प्रदान की गई न्यूनतम और अधिकतम मूल्य से एक यादृच्छिक संख्या वापस कर देगी (इसलिए उत्पन्न संख्या भी न्यूनतम या अधिकतम संख्या हो सकती है):

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

Comments

// Since the random number is between the min and max values, simply add 1। क्यों? मिन गिनती नहीं है? आमतौर पर सीमा [मिनट, अधिकतम) है जहां न्यूनतम शामिल है और अधिकतम को बाहर रखा गया है। गलत जवाब, वोट दिया।

— Maarten Bodewes

@MaartenBodewes +1 इसलिए जोड़ा गया है क्योंकि getRandomNumberBetween प्रदान किए गए समापन बिंदुओं का एक यादृच्छिक संख्या अनन्य बनाता है।

— ल्यूक टेलर

नंबर min + 1दो बार के रूप में अन्य संख्या की तुलना में होने की संभावना का नतीजा हो सकता है getRandomNumberBetween!

— लीई

Answer 20

एक पासा को रोल करने के मामले में यह 1 से 6 के बीच यादृच्छिक संख्या होगी (0 से 6 नहीं), इसलिए:

face = 1 + randomNumbers.nextInt(6);

Answer 21

int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

या फिर Apache Commons से RandomUtils पर एक नज़र डालें ।

Comments

यह उपयोगी है, लेकिन एक छोटी सी खराबी से सावधान रहें: विधि के हस्ताक्षर इस प्रकार हैं: अगलाडबल (डबल स्टार्टइन्क्लूसिव, डबल एंडइन्क्लूसिव), लेकिन यदि आप विधियों के अंदर देखते हैं, तो एंडइनक्लूसिव वास्तव में एंडएक्सक्लूसिव होना चाहिए।

— जक्कम

Double.valueOf(Math.random()*(maximum-minimun)).intValue()कहने के लिए एक बहुत ही अव्यवस्थित (और अक्षम) तरीका है (int)(Math.random()*(maximum-minimun))...

— होल्गर

न्यूनतम वापसी के लिए वर्तनी बेमेल न्यूनतम + Double.valueOf (Math.random () * (अधिकतम - न्यूनतम))। IntValue ();

— हृषिकेश मिश्रा

Answer 22

यहाँ intsसमावेशी / अनन्य सीमा के संयोजन के साथ एक श्रेणी में यादृच्छिक उत्पन्न करने के लिए एक सहायक वर्ग है :

import java.util.Random;

public class RandomRange extends Random {
    public int nextIncInc(int min, int max) {
        return nextInt(max - min + 1) + min;
    }

    public int nextExcInc(int min, int max) {
        return nextInt(max - min) + 1 + min;
    }

    public int nextExcExc(int min, int max) {
        return nextInt(max - min - 1) + 1 + min;
    }

    public int nextIncExc(int min, int max) {
        return nextInt(max - min) + min;
    }
}

Answer 23

"दो नंबरों के बीच" एक यादृच्छिक संख्या उत्पन्न करने के लिए, निम्नलिखित कोड का उपयोग करें:

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

यह आपको 1 (समावेशी) और 11 (अनन्य) के बीच एक यादृच्छिक संख्या देता है, इसलिए ऊपरी जोड़ मूल्य को 1 से प्रारंभ करें। उदाहरण के लिए, यदि आप 1 से 10 के बीच यादृच्छिक संख्या उत्पन्न करना चाहते हैं, तो 11 के बजाय ऊपरी संख्या को प्रारंभ करें। 10।

Answer 24

आप इसे जावा 8 में संक्षिप्त रूप से प्राप्त कर सकते हैं:

Random random = new Random();

int max = 10;
int min = 5;
int totalNumber = 10;

IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);

Answer 25

public static Random RANDOM = new Random(System.nanoTime());

public static final float random(final float pMin, final float pMax) {
    return pMin + RANDOM.nextFloat() * (pMax - pMin);
}

Answer 26

एक और विकल्प सिर्फ अपाचे कॉमन्स का उपयोग कर रहा है :

import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;

public void method() {
    RandomData randomData = new RandomDataImpl();
    int number = randomData.nextInt(5, 10);
    // ...
 }

Answer 27

मुझे यह उदाहरण मिला कि यादृच्छिक संख्या उत्पन्न करें :

---

यह उदाहरण एक विशिष्ट श्रेणी में यादृच्छिक पूर्णांक बनाता है।

import java.util.Random;

/** Generate random integers in a certain range. */
public final class RandomRange {

  public static final void main(String... aArgs){
    log("Generating random integers in the range 1..10.");

    int START = 1;
    int END = 10;
    Random random = new Random();
    for (int idx = 1; idx <= 10; ++idx){
      showRandomInteger(START, END, random);
    }

    log("Done.");
  }

  private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
    if ( aStart > aEnd ) {
      throw new IllegalArgumentException("Start cannot exceed End.");
    }
    //get the range, casting to long to avoid overflow problems
    long range = (long)aEnd - (long)aStart + 1;
    // compute a fraction of the range, 0 <= frac < range
    long fraction = (long)(range * aRandom.nextDouble());
    int randomNumber =  (int)(fraction + aStart);    
    log("Generated : " + randomNumber);
  }

  private static void log(String aMessage){
    System.out.println(aMessage);
  }
} 

इस वर्ग का एक उदाहरण रन:

Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.

Answer 28

केवल रैंडम के बजाय सिक्योर रैंडम का उपयोग करना बेहतर है ।

public static int generateRandomInteger(int min, int max) {
    SecureRandom rand = new SecureRandom();
    rand.setSeed(new Date().getTime());
    int randomNum = rand.nextInt((max - min) + 1) + min;
    return randomNum;
}

Comments

यह उतना अच्छा नहीं है, क्योंकि यदि इसे एक ही मिली सेकंड में निष्पादित किया जाता है तो आपको एक ही नंबर मिलेगा, आपको रैंड इनिशियलाइज़ेशन और सेटसेट को विधि के बाहर रखना होगा।

— 19

आपको बीज की आवश्यकता है, हाँ, लेकिन SecureRandom का उपयोग करके।

— grep

मुझे क्षमा करें, लेकिन जो परिवर्तन अनुरोध को अस्वीकार कर दिया गया है, उसके पास जावा प्रोग्रामिंग का कोई सुराग नहीं है यह एक अच्छा सुझाव है, लेकिन जैसा कि यह गलत है क्योंकि यदि एक ही मिली सेकंड में निष्पादित किया जाता है तो यह एक ही नंबर देगा, यादृच्छिक नहीं।

— मार्का

सही समाधान कहीं भी नहीं पाया जा सकता है, न कि बहुत से लोग स्टेटिक इनिशियलाइज़र ब्लॉक को जानते हैं ... जो कि आपको बीज को सेट करने के लिए उपयोग करना चाहिए: 1: private static int SecureRandom rand = new SecureRandom();2: static {3: rand.setSeed(...);4:}

— maraca

बीज की बिलकुल जरूरत नहीं है SecureRandom, यह सिस्टम द्वारा बोया जाएगा। सीधे कॉल setSeedकरना बहुत खतरनाक है, यह तारीख के साथ (वास्तव में यादृच्छिक) बीज को बदल सकता है। और यह निश्चित रूप से एक परिणाम नहीं होगा SecureRandom, क्योंकि कोई भी समय का अनुमान लगा सकता है और SecureRandomउस जानकारी के साथ अपने स्वयं के उदाहरण को आज़मा सकता है।

— मार्टन बोडेवेस

Answer 29

यहां एक सरल नमूना है जो दिखाता है कि बंद [min, max]सीमा से यादृच्छिक संख्या कैसे उत्पन्न की जाए, जबकिmin <= max is true

आप इसे होल क्लास में फ़ील्ड के रूप में पुनः उपयोग कर सकते हैं, जिसमें Random.classएक ही स्थान पर सभी विधियाँ होती हैं

परिणाम उदाहरण:

RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert

सूत्रों का कहना है:

import junit.framework.Assert;
import java.util.Random;

public class RandomUtils extends Random {

    /**
     * @param min generated value. Can't be > then max
     * @param max generated value
     * @return values in closed range [min, max].
     */
    public int nextInt(int min, int max) {
        Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
        if (min == max) {
            return max;
        }

        return nextInt(max - min + 1) + min;
    }
}

Answer 30

rand.nextInt((max+1) - min) + min;

यह ठीक काम कर रहा है।