ฉันจะสร้างจำนวนเต็มแบบสุ่มภายในช่วงที่ระบุใน Java ได้อย่างไร

ฉันจะสร้าง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`.

ในJava 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ซึ่งอาจเป็นแหล่งที่มาของความสับสนและข้อผิดพลาดหากใช้อย่างไม่เหมาะสม

อย่างไรก็ตามในทางกลับกันไม่มีวิธีการตั้งค่าเมล็ดพันธุ์อย่างชัดเจนดังนั้นจึงเป็นเรื่องยากที่จะทำซ้ำผลลัพธ์ในสถานการณ์ที่มีประโยชน์เช่นการทดสอบหรือการบันทึกสถานะของเกมหรือคล้ายกัน ในสถานการณ์เหล่านั้นสามารถใช้เทคนิค pre-Java 1.7 ที่แสดงด้านล่าง

ก่อน Java 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 ()

โดยเฉพาะอย่างยิ่งไม่จำเป็นต้องสร้างวงล้อการสร้างจำนวนเต็มแบบสุ่มเมื่อมี API ตรงไปตรงมาภายในไลบรารีมาตรฐานเพื่อให้งานสำเร็จ

โปรดทราบว่าวิธีการนี้มีอคติมากกว่าและมีประสิทธิภาพน้อยกว่าnextIntวิธีหนึ่งhttps://stackoverflow.com/a/738651/360211

หนึ่งรูปแบบมาตรฐานสำหรับการทำสิ่งนี้คือ:

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

Javaคณิตศาสตร์ฟังก์ชั่นห้องสมุด Math.random () สร้างค่า double [0,1)ในช่วง ขอให้สังเกตช่วงนี้ไม่รวมถึง 1

ในการรับช่วงของค่าเฉพาะก่อนคุณต้องคูณด้วยขนาดของช่วงของค่าที่คุณต้องการครอบคลุม

Math.random() * ( Max - Min )

ส่งคืนค่าในช่วง[0,Max-Min)โดยที่ '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;

จำนวนเต็ม x5-10ในขณะนี้คือตัวเลขสุ่มที่มีผลเป็นไปได้ของ

ใช้:

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

กับ Java-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ค่า ฉันหวังว่ามันจะช่วย! :)

คุณสามารถแก้ไขตัวอย่างรหัสที่สองของคุณเป็น:

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

ThreadLocalRandomเทียบเท่าของคลาสjava.util.Randomสำหรับสภาพแวดล้อมแบบมัลติเธรด การสร้างหมายเลขสุ่มจะดำเนินการแบบโลคัลในแต่ละเธรด ดังนั้นเราจึงมีประสิทธิภาพที่ดีขึ้นโดยลดความขัดแย้ง

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

x, y- ช่วงเวลาเช่น (1,10)

Math.Randomชั้นในJavaคือ 0-based ดังนั้นถ้าคุณเขียนอะไรแบบนี้:

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

xจะอยู่ระหว่าง0-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เป็นลบ

โซลูชันที่เข้าใจผิดได้จะส่งคืนผลลัพธ์ที่ถูกต้องสำหรับ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));
    }
}

มันสะอาดและเรียบง่าย

ฉันสงสัยว่าวิธีการสร้างหมายเลขสุ่มใด ๆ ที่จัดทำโดยห้องสมุดคณิตศาสตร์ Apache Commonsจะเหมาะกับการเรียกเก็บเงินหรือไม่

ตัวอย่างเช่น: 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

ดังนั้นจำนวนนี้จะเป็น max - min + 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;

สร้างตัวเลขสุ่มสำหรับความแตกต่างของ min และ max โดยใช้เมธอด nextint (n)จากนั้นเพิ่ม min number เข้ากับผลลัพธ์:

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

คุณสามารถส่งไปที่ Integer ได้หากต้องการ

ในฐานะของ Java 7 Randomคุณควรจะไม่ได้ใช้ ThreadLocalRandomสำหรับการใช้งานส่วนใหญ่เครื่องกำเนิดไฟฟ้าจำนวนสุ่มของทางเลือกอยู่ในขณะนี้ สำหรับการเข้าร่วมส้อมสระว่ายน้ำและลำธารขนานใช้

SplittableRandom

Joshua Bloch Java ที่มีประสิทธิภาพ รุ่นที่สาม

เริ่มต้นจาก Java 8

สำหรับการเข้าร่วมส้อมสระว่ายน้ำและลำธารขนานการใช้งานที่มักจะได้เร็วขึ้นมีสถิติที่ดีกว่าความเป็นอิสระและความสม่ำเสมอคุณสมบัติในการเปรียบเทียบกับSplittableRandomRandom

เพื่อสร้างการสุ่ม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 :

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

วิธีการนี้อาจใช้งานได้สะดวก:

วิธีนี้จะคืนค่าตัวเลขสุ่มระหว่างค่า min และ max ที่ให้มา:

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

และวิธีนี้จะส่งกลับตัวเลขสุ่มจากค่า min และ max ที่ให้ไว้ (ดังนั้นตัวเลขที่สร้างขึ้นอาจเป็น min หรือ max number):

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

หรือลองดูเพื่อ RandomUtils จากApache คอมมอนส์

นี่คือคลาสที่มีประโยชน์ในการสร้างแบบสุ่ม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 (พิเศษ) ดังนั้นเริ่มต้นค่า UpperBound โดยการเพิ่ม 1 ตัวอย่างเช่นถ้าคุณต้องการสร้างตัวเลขสุ่มระหว่าง 1 ถึง 10 จากนั้นเริ่มต้นหมายเลข UpperBound ด้วย 11 แทน 10

คุณสามารถบรรลุเป้าหมายดังกล่าวใน Java 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วิธีการทั้งหมดในที่เดียว

ตัวอย่างผลลัพธ์:

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;

มันใช้งานได้ดี