Làm cách nào để tạo các số nguyên ngẫu nhiên trong một phạm vi cụ thể trong Java?

Làm cách nào để tạo một intgiá trị ngẫu nhiên trong một phạm vi cụ thể?

Tôi đã thử những cách sau, nhưng những thứ đó không hoạt động:

Nỗ lực 1:

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

Cố gắng 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`.

Trong Java 1.7 trở lên , cách tiêu chuẩn để làm điều này như sau:

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

Xem JavaDoc có liên quan . Cách tiếp cận này có ưu điểm là không cần phải khởi tạo một cách rõ ràng một cá thể java.util.Random , đây có thể là một nguồn gây nhầm lẫn và lỗi nếu được sử dụng không phù hợp.

Tuy nhiên, ngược lại, không có cách nào để thiết lập hạt giống một cách rõ ràng để có thể khó tái tạo kết quả trong các tình huống có ích như kiểm tra hoặc lưu trạng thái trò chơi hoặc tương tự. Trong các tình huống đó, kỹ thuật tiền Java 1.7 được hiển thị bên dưới có thể được sử dụng.

Trước Java 1.7 , cách tiêu chuẩn để làm điều này như sau:

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

Xem JavaDoc có liên quan . Trong thực tế, lớp java.util.Random thường được ưa thích hơn java.lang.Math.random () .

Đặc biệt, không cần phải phát minh lại bánh xe tạo số nguyên ngẫu nhiên khi có API đơn giản trong thư viện chuẩn để hoàn thành nhiệm vụ.

Lưu ý rằng phương pháp này thiên vị hơn và kém hiệu quả hơn nextIntphương pháp, https://stackoverflow.com/a/738651/360211

Một mô hình chuẩn để thực hiện điều này là:

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

Hàm thư viện Java Math Math.random () tạo ra một giá trị kép trong phạm vi[0,1) . Lưu ý phạm vi này không bao gồm 1.

Để có được một phạm vi giá trị cụ thể trước tiên, bạn cần nhân với độ lớn của phạm vi giá trị bạn muốn bảo hiểm.

Math.random() * ( Max - Min )

Điều này trả về một giá trị trong phạm vi [0,Max-Min) , trong đó 'Max-Min' không được bao gồm.

Ví dụ: nếu bạn muốn [5,10), bạn cần bao gồm năm giá trị số nguyên để bạn sử dụng

Math.random() * 5

Điều này sẽ trả về một giá trị trong phạm vi [0,5) , trong đó 5 không được bao gồm.

Bây giờ bạn cần chuyển phạm vi này lên phạm vi mà bạn đang nhắm mục tiêu. Bạn làm điều này bằng cách thêm giá trị Min.

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

Bây giờ bạn sẽ nhận được một giá trị trong phạm vi [Min,Max). Theo ví dụ của chúng tôi, điều đó có nghĩa là [5,10):

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

Nhưng, điều này vẫn không bao gồm Maxvà bạn đang nhận được một giá trị gấp đôi. Để có được Maxgiá trị được bao gồm, bạn cần thêm 1 vào tham số phạm vi của mình (Max - Min)và sau đó cắt phần thập phân bằng cách chuyển sang int. Điều này được thực hiện thông qua:

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

Và bạn có nó rồi đấy! Một giá trị số nguyên ngẫu nhiên trong phạm vi [Min,Max]hoặc theo ví dụ [5,10]:

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

Sử dụng:

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

Số nguyên xbây giờ là số ngẫu nhiên có kết quả có thể là 5-10.

Sử dụng:

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

Với java-8họ đã giới thiệu phương pháp ints(int randomNumberOrigin, int randomNumberBound)trong Randomlớp.

Ví dụ: nếu bạn muốn tạo năm số nguyên ngẫu nhiên (hoặc một số nguyên) trong phạm vi [0, 10], chỉ cần làm:

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

Tham số đầu tiên chỉ ra kích thước của phương thức IntStreamđược tạo (là phương thức quá tải của phương thức tạo ra không giới hạn IntStream).

Nếu bạn cần thực hiện nhiều cuộc gọi riêng biệt, bạn có thể tạo một trình vòng lặp nguyên thủy vô hạn từ luồng:

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

Bạn cũng có thể làm điều đó cho doublevà longcác giá trị. Tôi hy vọng nó sẽ giúp! :)

Bạn có thể chỉnh sửa ví dụ mã thứ hai của mình thành:

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

Chỉ cần một sửa đổi nhỏ của giải pháp đầu tiên của bạn là đủ.

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

Xem thêm ở đây để thực hiện Random

ThreadLocalRandomtương đương với lớp học java.util.Randomcho môi trường đa luồng. Tạo một số ngẫu nhiên được thực hiện cục bộ trong mỗi luồng. Vì vậy, chúng tôi có một hiệu suất tốt hơn bằng cách giảm các xung đột.

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

x, y- khoảng thời gian, ví dụ (1,10)

Các Math.Randomlớp trong Java là 0-based. Vì vậy, nếu bạn viết một cái gì đó như thế này:

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

xsẽ được 0-9bao gồm giữa .

Vì vậy, với mảng các 25mục sau đây , mã để tạo một số ngẫu nhiên nằm giữa 0(cơ sở của mảng) và array.lengthsẽ là:

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

index = rand.nextInt( i.length );

Vì i.lengthsẽ trả về 25, nextInt( i.length )sẽ trả về một số giữa phạm vi 0-24. Tùy chọn khác là đi với Math.Randomcái nào hoạt động theo cùng một cách.

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

Để hiểu rõ hơn, hãy xem bài đăng trên diễn đàn Khoảng thời gian ngẫu nhiên (archive.org) .

Hãy tha thứ cho tôi vì khó tính, nhưng giải pháp được đa số đề xuất, có nghĩa là min + rng.nextInt(max - min + 1)), có vẻ nguy hiểm do thực tế là:

• rng.nextInt(n)không thể đạt được Integer.MAX_VALUE.
• (max - min)có thể gây tràn khi minâm.

Một giải pháp hoàn hảo sẽ trả về kết quả chính xác cho bất kỳ min <= maxtrong [ Integer.MIN_VALUE, Integer.MAX_VALUE]. Hãy xem xét việc thực hiện ngây thơ sau đây:

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

Mặc dù không hiệu quả, lưu ý rằng xác suất thành công trong whilevòng lặp sẽ luôn là 50% hoặc cao hơn.

Nó có thể được thực hiện bằng cách đơn giản là thực hiện tuyên bố:

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

Dưới đây là mã nguồn của nó

Randomizer.java

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

Nó chỉ là sạch sẽ và đơn giản.

Tôi tự hỏi nếu bất kỳ phương pháp tạo số ngẫu nhiên được cung cấp bởi một thư viện Apache Commons Math sẽ phù hợp với dự luật không.

Ví dụ: RandomDataGenerator.nextInthoặcRandomDataGenerator.nextLong

Chúng ta hãy lấy một ví dụ.

Giả sử tôi muốn tạo một số trong khoảng 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);

Hãy để chúng tôi hiểu điều này ...

Khởi tạo max với giá trị cao nhất và min với giá trị thấp nhất.

Bây giờ, chúng ta cần xác định có bao nhiêu giá trị có thể có được. Trong ví dụ này, nó sẽ là:

5, 6, 7, 8, 9, 10

Vì vậy, số lượng này sẽ là tối đa - tối thiểu + 1.

tức là 10 - 5 + 1 = 6

Số ngẫu nhiên sẽ tạo ra một số trong khoảng 0-5 .

tức là 0, 1, 2, 3, 4, 5

Thêm giá trị tối thiểu vào số ngẫu nhiên sẽ tạo ra:

5, 6, 7, 8, 9, 10

Do đó chúng tôi có được phạm vi mong muốn.

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

Tạo một số ngẫu nhiên cho sự khác biệt của min và max bằng cách sử dụng phương thức nextint (n) và sau đó thêm số min vào kết quả:

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

Tôi sử dụng cái này:

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

Bạn có thể sử dụng nó cho một Integer nếu bạn muốn.

Kể từ Java 7, bạn không nên sử dụng nữa Random. Đối với hầu hết các mục đích sử dụng, trình tạo số ngẫu nhiên được lựa chọn hiện nay ThreadLocalRandom.

Đối với ngã ba tham gia nhóm và luồng song song, sử dụng SplittableRandom.

Joshua Bloch. Java hiệu quả. Ấn bản thứ ba.

Bắt đầu từ Java 8

Đối với nhóm tham gia ngã ba và các luồng song song, sử dụng SplittableRandomthường nhanh hơn, có tính độc lập thống nhất và tính đồng nhất tốt hơn so với Random.

Để tạo ngẫu nhiên inttrong phạm vi[0, 1_000]:

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

Để tạo một int[100]mảng giá trị ngẫu nhiên trong phạm vi[0, 1_000]:

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

Để trả về một luồng các giá trị ngẫu nhiên:

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

Chỉ cần sử dụng lớp Ngẫu nhiên :

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

Phương pháp này có thể thuận tiện để sử dụng:

Phương pháp này sẽ trả về một số ngẫu nhiên giữa giá trị tối thiểu và tối đa được cung cấp:

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

và phương thức này sẽ trả về một số ngẫu nhiên từ giá trị tối thiểu và tối đa được cung cấp (vì vậy số được tạo cũng có thể là số tối thiểu hoặc tối đa):

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

    return randomNumber;
}

Trong trường hợp gieo xúc xắc, nó sẽ là số ngẫu nhiên trong khoảng từ 1 đến 6 (không phải từ 0 đến 6), vì vậy:

face = 1 + randomNumbers.nextInt(6);

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

Hoặc hãy xem RandomUtils từ Apache Commons .

Đây là một lớp hữu ích để tạo ngẫu nhiên intstrong một phạm vi với bất kỳ kết hợp giới hạn bao gồm / độc quyền nào:

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

Để tạo một số ngẫu nhiên "ở giữa hai số", hãy sử dụng mã sau:

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

Điều này cung cấp cho bạn một số ngẫu nhiên trong khoảng từ 1 (đã bao gồm) và 11 (độc quyền), vì vậy hãy khởi tạo giá trị UpperBound bằng cách thêm 1. Ví dụ: nếu bạn muốn tạo số ngẫu nhiên trong khoảng từ 1 đến 10 thì hãy khởi tạo số UpperBound bằng 11 thay vì 10.

Bạn có thể đạt được điều đó một cách chính xác trong 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);
}

Một tùy chọn khác là chỉ sử dụng 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);
    // ...
 }

Tôi tìm thấy ví dụ này Tạo số ngẫu nhiên :

Ví dụ này tạo ra các số nguyên ngẫu nhiên trong một phạm vi cụ thể.

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

Một ví dụ chạy của lớp này:

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.

Tốt hơn là sử dụng SecureRandom thay vì chỉ ngẫu nhiên.

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

Đây là một mẫu đơn giản cho thấy cách tạo số ngẫu nhiên từ [min, max]phạm vi đóng , trong khimin <= max is true

Bạn có thể sử dụng lại nó như là trường trong lớp lỗ, cũng có tất cả các Random.classphương thức ở một nơi

Ví dụ kết quả:

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

Nguồn:

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;

Điều này đang làm việc tốt.