ජාවා හි නිශ්චිත පරාසයක් තුළ අහඹු සංඛ්‍යා පූර්ණ ජනනය කරන්නේ කෙසේද?

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`.

දී ජාවා 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);

අදාළ ජාවාඩොක් බලන්න . මෙම ප්‍රවේශයට java.util.Random නිදසුනක් පැහැදිලිවම ආරම්භ කිරීමට අවශ්‍ය නොවීමේ වාසිය ඇත , එය නුසුදුසු ලෙස භාවිතා කරන්නේ නම් ව්‍යාකූලත්වයට හා දෝෂයකට හේතු විය හැක.

කෙසේ වෙතත්, අනෙක් අතට බීජ පැහැදිලිව සැකසීමට ක්‍රමයක් නොමැති බැවින් ක්‍රීඩා තත්වයන් පරීක්ෂා කිරීම හෝ සුරැකීම හෝ ඒ හා සමාන ප්‍රයෝජනවත් අවස්ථාවන්හි ප්‍රති results ල ප්‍රතිනිෂ්පාදනය කිරීම දුෂ්කර විය හැකිය. එවැනි අවස්ථාවන්හිදී, පහත පෙන්වා ඇති පූර්ව ජාවා 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;
}

අදාළ ජාවාඩොක් බලන්න . ප්රායෝගිකව, java.util.Random පන්තිය බොහෝ විට java.lang.Math.random () ට වඩා යෝග්ය වේ .

කාර්යය ඉටු කිරීම සඳහා සම්මත පුස්තකාලය තුළ API ජු API එකක් ඇති විට, අහඹු පූර්ණ සංඛ්‍යා උත්පාදක රෝදය ප්‍රතිනිර්මාණය කිරීමේ අවශ්‍යතාවයක් නොමැත.

මෙම ප්‍රවේශය ප්‍රවේශයකට වඩා පක්ෂග්‍රාහී හා කාර්යක්ෂම නොවන බව සලකන්න 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)අතර ඉන් පසුව int ට වාත්තු කිරීමෙන් දශම කොටස කපා දැමිය යුතුය . මෙය සිදු කරන්නේ:

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

එහි ඔබට එය තිබේ. පරාසය තුළ අහඹු පූර්ණ සංඛ්‍යාවක් [Min,Max], හෝ උදාහරණයක් ලෙස [5,10]:

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

භාවිත:

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

නිඛිලය xදැන් අහඹු අංකයක් විය හැකි ප්‍රති out ල 5-10ඇත.

භාවිත:

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

සමඟ java-8ඔවුන් ක්රමය හඳුන්වා ints(int randomNumberOrigin, int randomNumberBound)දී Randomපන්ති.

උදාහරණයක් ලෙස ඔබට [0, 10] පරාසය තුළ අහඹු සංඛ්‍යා 5 ක් (හෝ තනි එකක්) උත්පාදනය කිරීමට අවශ්‍ය නම්, එසේ කරන්න:

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අගයන් සඳහාද කළ හැකිය . එය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි! :)

ඔබගේ දෙවන කේත උදාහරණය ඔබට සංස්කරණය කළ හැකිය:

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

ඔබගේ පළමු විසඳුමේ සුළු වෙනස් කිරීමක් පමණක් ප්‍රමාණවත් වේ.

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

ක්‍රියාත්මක කිරීම සඳහා වැඩි විස්තර මෙතැනින් බලන්න Random

ThreadLocalRandomjava.util.Randomබහු තෙරපුම් පරිසරය සඳහා පන්තියට සමාන වේ . අහඹු අංකයක් ජනනය කිරීම එක් එක් නූල් තුළ දේශීයව සිදු කෙරේ. එබැවින් ගැටුම් අවම කිරීමෙන් අපට වඩා හොඳ කාර්ය සාධනයක් ඇත.

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

x, y- අන්තරයන් උදා (1,10)

ජාවා හි 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);

වඩා හොඳ අවබෝධයක් සඳහා, සසම්භාවී අන්තරයන් (archive.org) සංසදය බලන්න .

නිරාහාරව සිටීම ගැන මට සමාව දෙන්න, නමුත් බහුතරය විසින් යෝජනා කරන ලද විසඳුම, එනම්, min + rng.nextInt(max - min + 1))අනතුරුදායක බව පෙනෙන්නේ:

• rng.nextInt(n)ළඟා විය නොහැක Integer.MAX_VALUE.
• (max - min).ණාත්මක වන විට පිටාර ගැලීමට හේතු විය හැක min.

මෝඩ විසඳුමක් මගින් ඕනෑම කෙනෙකුට නිවැරදි ප්‍රති results ල ලබා දෙනු 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% හෝ ඊට වැඩි වනු ඇති බව සලකන්න .

හුදෙක් ප්‍රකාශය කිරීමෙන් එය කළ හැකිය:

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));
    }
}

එය පිරිසිදු හා සරල ය.

අපාචේ කොමන්ස් ගණිත පුස්තකාලයක් මඟින් සසම්භාවී සංඛ්‍යා උත්පාදනය කිරීමේ ක්‍රමවේදයක් බිල්පතට ගැලපේදැයි මම කල්පනා කරමි .

උදාහරණයක් ලෙස: RandomDataGenerator.nextIntහෝRandomDataGenerator.nextLong

අපි උදාහරණයක් ගනිමු.

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

එබැවින් අපි අපේක්ෂිත පරාසය ලබා ගනිමු.

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

මීලඟ (n) ක්‍රමය භාවිතා කරමින් මිනි සහ උපරිම වෙනස සඳහා අහඹු අංකයක් ජනනය කර ප්‍රති result ලයට මිනි අංකය එක් කරන්න:

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

මම මෙය භාවිතා කරමි:

 /**
   * @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;
 }

ඔබට අවශ්‍ය නම් එය පූර්ණ සංඛ්‍යාවක් වෙත දැමිය හැකිය.

ජාවා 7 වන විට, ඔබ තවදුරටත් භාවිතා නොකළ යුතුය Random. බොහෝ භාවිතයන් සඳහා, අහඹු සංඛ්‍යා උත්පාදක යන්ත්‍රය දැන් තෝරාගෙන ඇත ThreadLocalRandom.

දෙබලක සම්බන්ධ වන තටාක සහ සමාන්තර ධාරාවන් සඳහා, භාවිතා කරන්න SplittableRandom.

ජෝෂුවා බ්ලොච්. Java ලදායී ජාවා. තෙවන සංස්කරණය.

ජාවා 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);

සසම්භාවී පන්තිය භාවිතා කරන්න :

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

මෙම ක්‍රම භාවිතා කිරීමට පහසු විය හැකිය:

මෙම ක්‍රමය අහඹු අංකයක් ලබා දෙනු ඇත සපයා ඇති මිනි සහ උපරිම අගය අතරලබා දෙනු ඇත:

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;
}

ඩයිස් රෝල් කරන විට එය අහඹු අංක 1 සිට 6 දක්වා (0 සිට 6 දක්වා නොවේ), එබැවින්:

face = 1 + randomNumbers.nextInt(6);

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

නැතහොත් Apache Commons වෙතින් RandomUtils වෙත බලන්න .

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;
    }
}

අහඹු අංකයක් "සංඛ්‍යා දෙකක් අතර" ජනනය කිරීමට, පහත කේතය භාවිතා කරන්න:

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

මෙය ඔබට 1 (ඇතුළත්) සහ 11 (සුවිශේෂී) අතර අහඹු අංකයක් ලබා දෙයි, එබැවින් 1 එකතු කිරීමෙන් ඉහළ මායිම් අගය ආරම්භ කරන්න. 10.

ඔබට එය ජාවා 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);

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);
}

තවත් විකල්පයක් වන්නේ Apache Commons භාවිතා කිරීම පමණි :

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);
    // ...
 }

මට මෙම උදාහරණය හමු විය අහඹු සංඛ්‍යා ජනනය කරන්න :

මෙම උදාහරණය අහඹු සංඛ්‍යා පූර්ණ පරාසයක ජනනය කරයි.

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.

සසම්භාවී ලෙසට වඩා SecureRandom භාවිතා කිරීම වඩා හොඳය .

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;
}

සංවෘත සිට අහඹු අංකයක් ජනනය කරන්නේ කෙසේදැයි පෙන්වන සරල නියැදියක් මෙන්න [min, max] පරාසයකින්min <= max is true

ඔබට එය සිදුරු පන්තියේ ක්ෂේත්‍රයක් ලෙස නැවත භාවිතා කළ හැකිය Random.class එක් තැනක ක්රම

ප්‍රති Results ල උදාහරණය:

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;
    }
}

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

මෙය හොඳින් ක්‍රියාත්මක වේ.