Bagaimana cara menghasilkan bilangan bulat acak dalam rentang tertentu di Jawa?

Bagaimana cara menghasilkan intnilai acak dalam rentang tertentu?

Saya sudah mencoba yang berikut ini, tetapi itu tidak berhasil:

Percobaan 1:

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

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

Di Jawa 1.7 atau lebih baru , cara standar untuk melakukan ini adalah sebagai berikut:

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

Lihat JavaDoc yang relevan . Pendekatan ini memiliki keuntungan karena tidak perlu menginisialisasi secara eksplisit contoh java.util.Random , yang dapat menjadi sumber kebingungan dan kesalahan jika digunakan secara tidak tepat.

Namun, sebaliknya tidak ada cara untuk mengatur benih secara eksplisit sehingga sulit untuk mereproduksi hasil dalam situasi di mana itu berguna seperti menguji atau menyimpan status permainan atau serupa. Dalam situasi tersebut, teknik pra-Jawa 1.7 yang ditunjukkan di bawah ini dapat digunakan.

Sebelum Java 1.7 , cara standar untuk melakukan ini adalah sebagai berikut:

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

Lihat JavaDoc yang relevan . Dalam praktiknya, kelas java.util.Random sering lebih disukai daripada java.lang.Math.random () .

Secara khusus, tidak perlu menemukan kembali roda pembangkitan bilangan bulat acak ketika ada API langsung dalam pustaka standar untuk menyelesaikan tugas.

Perhatikan bahwa pendekatan ini lebih bias dan kurang efisien daripada nextIntpendekatan, https://stackoverflow.com/a/738651/360211

Satu pola standar untuk mencapai ini adalah:

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

The Java Math fungsi library Math.random () menghasilkan nilai ganda dalam kisaran[0,1) . Perhatikan kisaran ini tidak termasuk 1.

Untuk mendapatkan rentang nilai tertentu terlebih dahulu, Anda perlu mengalikan dengan besarnya rentang nilai yang ingin Anda liput.

Math.random() * ( Max - Min )

Ini mengembalikan nilai dalam rentang [0,Max-Min) , di mana 'Max-Min' tidak termasuk.

Misalnya, jika Anda ingin [5,10), Anda harus mencakup lima nilai integer sehingga Anda gunakan

Math.random() * 5

Ini akan mengembalikan nilai dalam rentang [0,5) , di mana 5 tidak termasuk.

Sekarang Anda perlu menggeser rentang ini ke kisaran yang Anda targetkan. Anda melakukan ini dengan menambahkan nilai Min.

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

Anda sekarang akan mendapatkan nilai dalam rentang tersebut [Min,Max). Mengikuti contoh kita, itu berarti [5,10):

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

Tapi, ini masih belum termasuk Maxdan Anda mendapatkan nilai ganda. Untuk Maxmemasukkan nilai, Anda perlu menambahkan 1 ke rentang parameter Anda (Max - Min)dan kemudian memotong bagian desimal dengan melakukan casting ke int. Ini dicapai melalui:

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

Dan begitulah. Nilai integer acak dalam rentang [Min,Max], atau per contoh [5,10]:

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

Menggunakan:

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

Bilangan bulat xsekarang adalah angka acak yang memiliki kemungkinan hasil 5-10.

Menggunakan:

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

Dengan java-8mereka memperkenalkan metode ints(int randomNumberOrigin, int randomNumberBound)di Randomkelas.

Misalnya jika Anda ingin menghasilkan lima bilangan bulat acak (atau satu) di kisaran [0, 10], lakukan saja:

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

Parameter pertama menunjukkan hanya ukuran yang IntStreamdihasilkan (yang merupakan metode kelebihan yang menghasilkan tidak terbatas IntStream).

Jika Anda perlu melakukan beberapa panggilan terpisah, Anda dapat membuat iterator primitif tak terbatas dari aliran:

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

Anda juga dapat melakukannya untuk doubledan longmenghargai. Saya harap ini membantu! :)

Anda dapat mengedit contoh kode kedua Anda ke:

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

Cukup modifikasi kecil dari solusi pertama Anda sudah cukup.

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

Lihat lebih lanjut di sini untuk implementasi Random

ThreadLocalRandomsetara dengan kelas java.util.Randomuntuk lingkungan multithreaded. Menghasilkan nomor acak dilakukan secara lokal di masing-masing utas. Jadi kami memiliki kinerja yang lebih baik dengan mengurangi konflik.

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

x, y- interval misalnya (1,10)

The Math.Randomkelas dalam Java adalah 0 berbasis. Jadi, jika Anda menulis sesuatu seperti ini:

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

xakan berada di antara 0-9inklusif.

Jadi, mengingat 25item array berikut , kode untuk menghasilkan angka acak antara 0(basis array) dan array.lengthakan menjadi:

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

index = rand.nextInt( i.length );

Karena i.lengthakan kembali 25, nextInt( i.length )akan mengembalikan angka di antara kisaran 0-24. Pilihan lainnya adalah Math.Randomyang bekerja dengan cara yang sama.

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

Untuk pemahaman yang lebih baik, lihat posting forum Interval Acak (archive.org) .

Maafkan saya karena teliti, tetapi solusi yang disarankan oleh mayoritas, yaitu min + rng.nextInt(max - min + 1)), tampaknya berbahaya karena fakta bahwa:

• rng.nextInt(n) tidak dapat dicapai Integer.MAX_VALUE .
• (max - min)dapat menyebabkan kelebihan ketika minnegatif.

Solusi yang sangat mudah akan memberikan hasil yang benar untuk semua yang ada min <= maxdalam [ Integer.MIN_VALUE, Integer.MAX_VALUE]. Pertimbangkan implementasi naif berikut:

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

Meskipun tidak efisien, perhatikan bahwa probabilitas keberhasilan dalam whileloop akan selalu 50% atau lebih tinggi.

Itu bisa dilakukan dengan hanya melakukan pernyataan:

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

Di bawah ini adalah kode sumbernya

Randomizer.java

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

Itu bersih dan sederhana.

Saya bertanya-tanya apakah ada salah satu metode menghasilkan angka acak yang disediakan oleh perpustakaan Apache Commons Math akan sesuai dengan tagihan.

Misalnya: RandomDataGenerator.nextIntatauRandomDataGenerator.nextLong

Mari kita ambil contoh.

Misalkan saya ingin menghasilkan angka antara 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);

Mari kita pahami ini ...

Inisialisasi maks dengan nilai tertinggi dan min dengan nilai terendah.

Sekarang, kita perlu menentukan berapa banyak nilai yang mungkin dapat diperoleh. Untuk contoh ini, itu akan menjadi:

5, 6, 7, 8, 9, 10

Jadi, hitungan ini akan menjadi maksimum - min + 1.

yaitu 10 - 5 + 1 = 6

Angka acak akan menghasilkan angka antara 0-5 .

yaitu 0, 1, 2, 3, 4, 5

Menambahkan nilai min ke angka acak akan menghasilkan:

5, 6, 7, 8, 9, 10

Karenanya kami memperoleh kisaran yang diinginkan.

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

Hasilkan angka acak untuk perbedaan min dan maks dengan menggunakan metode nextint (n) dan kemudian tambahkan angka min ke hasilnya:

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

Saya menggunakan ini:

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

Anda bisa melemparkannya ke Integer jika mau.

Pada Java 7, Anda tidak boleh lagi menggunakan Random. Untuk sebagian besar kegunaan, generator nomor acak pilihan sekarang ThreadLocalRandom.

Untuk garpu bergabung dengan kolam dan aliran paralel, gunakan SplittableRandom.

Joshua Bloch. Jawa yang efektif. Edisi ketiga.

Mulai dari Jawa 8

Untuk cabang gabungan garpu dan aliran paralel, gunakan SplittableRandomyang biasanya lebih cepat, memiliki kemandirian statistik yang lebih baik dan sifat keseragaman dibandingkan dengan Random.

Untuk menghasilkan acak intdalam kisaran[0, 1_000]:

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

Untuk menghasilkan int[100]array nilai acak dalam rentang[0, 1_000]:

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

Untuk mengembalikan Stream nilai acak:

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

Cukup gunakan kelas Acak :

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

Metode ini mungkin nyaman digunakan:

Metode ini akan mengembalikan angka acak antara nilai minimum dan maksimum yang disediakan:

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

dan metode ini akan mengembalikan angka acak dari nilai min dan max yang disediakan (sehingga angka yang dihasilkan juga bisa berupa angka min atau max):

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

    return randomNumber;
}

Dalam hal menggulirkan dadu itu akan menjadi angka acak antara 1 hingga 6 (bukan 0 hingga 6), jadi:

face = 1 + randomNumbers.nextInt(6);

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

Atau lihat RandomUtils dari Apache Commons .

Berikut adalah kelas yang membantu untuk menghasilkan acak intsdalam kisaran dengan kombinasi batas inklusif / eksklusif:

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

Untuk menghasilkan angka acak "di antara dua angka", gunakan kode berikut:

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

Ini memberi Anda angka acak di antara 1 (inklusif) dan 11 (eksklusif), jadi inisialisasi nilai upperBound dengan menambahkan 1. Misalnya, jika Anda ingin menghasilkan angka acak antara 1 hingga 10 maka inisialisasi angka upperBound dengan 11 alih-alih 10.

Anda dapat mencapainya secara ringkas di 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);
}

Opsi lain hanya menggunakan 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);
    // ...
 }

Saya menemukan contoh ini Menghasilkan angka acak :

Contoh ini menghasilkan bilangan bulat acak dalam rentang tertentu.

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

Contoh menjalankan kelas ini:

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.

Lebih baik menggunakan SecureRandom daripada hanya Acak.

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

Berikut adalah contoh sederhana yang menunjukkan cara menghasilkan angka acak dari [min, max]rentang tertutup , sementaramin <= max is true

Anda dapat menggunakannya kembali sebagai bidang dalam kelas lubang, juga memiliki semua Random.classmetode di satu tempat

Contoh hasil:

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

Sumber:

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;

Ini bekerja dengan baik.