Bagaimana saya menghasilkan bilangan bulat acak dalam rentang tertentu di pulau Jawa?

Di 1.7 Jawa atau yang 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 relevan JavaDoc. Pendekatan ini memiliki keuntungan tidak perlu secara eksplisit menginisialisasi jawa.util.Random misalnya, yang dapat menjadi sumber kebingungan dan kesalahan jika digunakan secara tidak tepat.

Namun, sebaliknya tidak ada cara untuk secara eksplisit mengatur benih sehingga dapat menjadi sulit untuk mereproduksi hasil dalam situasi di mana yang berguna seperti pengujian atau menyelamatkan negara permainan atau serupa. Dalam situasi tersebut, pra-Jawa 1.7 teknik 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 relevan JavaDoc. Dalam prakteknya, jawa.util.Random kelas ini sering lebih baik untuk jawa.lang.Matematika.random().

Secara khusus, ada tidak perlu untuk menemukan kembali random integer generasi roda ketika ada API sederhana dalam standar perpustakaan untuk menyelesaikan tugas.

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

Salah satu pola standar untuk mencapai ini adalah:

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

The Jawa perpustakaan Matematika fungsi Matematika.random() menghasilkan nilai ganda dalam kisaran [0,1). Pemberitahuan kisaran ini tidak termasuk 1.

Dalam rangka untuk mendapatkan kisaran tertentu dari nilai pertama, anda perlu untuk berkembang biak oleh besarnya kisaran nilai-nilai yang anda inginkan tertutup.

Math.random() * ( Max - Min )

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

Misalnya, jika anda ingin [5,10), anda perlu untuk menutupi lima nilai integer agar anda gunakan

Math.random() * 5

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

Sekarang anda perlu untuk pergeseran ini berkisar hingga kisaran yang anda targetkan. Anda melakukan ini dengan menambahkan nilai Min.

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

Anda sekarang akan mendapatkan nilai di kisaran [Min,Max). Berikut contoh kita, yang berarti [5,10):

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

Tapi, ini masih doesn't seperti Max dan anda mendapatkan nilai ganda. Dalam rangka untuk mendapatkan Max nilai disertakan, anda perlu menambahkan 1 ke kisaran parameter (Max - Min) dan kemudian memotong desimal bagian dengan pengecoran ke int. Hal ini dicapai melalui:

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

Dan di sana anda memilikinya. Acak nilai integer dalam range [Min,Max], atau per contoh [5,10]:

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

Gunakan:

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

Integer x sekarang nomor acak yang memiliki hasil yang mungkin dari 5-10.

Gunakan:

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

Dengan [tag:jawa-8] mereka memperkenalkan metode int(int randomNumberOrigin, int randomNumberBound) di Random kelas.

Misalnya jika anda ingin menghasilkan lima bulat acak (atau salah satu) dalam jangkauan [0, 10], lakukan:

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 IntStream yang dihasilkan (yang merupakan kelebihan beban metode yang menghasilkan unlimited IntStream).

Jika anda perlu melakukan beberapa panggilan terpisah, anda dapat membuat aplikasi yang tak terbatas primitif iterator dari stream:

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 melakukan itu untuk double dan panjang nilai-nilai.

Semoga membantu! :)

Anda dapat mengedit kedua contoh kode untuk:

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

Hanya modifikasi kecil dari anda solusi pertama akan cukup.

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

Lihat lebih lanjut di sini untuk pelaksanaan Random

The Matematika.Random kelas di Jawa adalah 0-based. Jadi, jika anda menulis sesuatu seperti ini:

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

x akan antara 0-9 inklusif.

Jadi, diberikan berikut para 25 barang-barang, kode untuk menghasilkan nomor acak antara 0 (dasar array) dan array.panjang akan sama:

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

index = rand.nextInt( i.length );

Sejak saya.panjang akan kembali 25, yang nextInt( saya.panjang ) akan kembali sejumlah antara berbagai 0-24. Pilihan lain akan dengan Matematika.Random` yang bekerja dengan cara yang sama.

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

Untuk pemahaman yang lebih baik, check out forum post Interval waktu yang Acak (archive.org).

ThreadLocalRandom setara dengan kelas java.util.Acak untuk multithreaded lingkungan. Menghasilkan angka acak yang dilakukan secara lokal di setiap thread. Jadi kita memiliki kinerja yang lebih baik dengan mengurangi konflik.

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

x,y - interval misalnya (1,10)

Maafkan aku untuk menjadi cerewet, tapi solusi yang disarankan oleh mayoritas, yaitu, menit + rng.nextInt(max - min + 1)), tampaknya berbahaya karena fakta bahwa:

• rng.nextInt(n) bisa mencapai Integer.MAX_VALUE.
• (max - min) dapat menyebabkan meluap ketika min adalah negatif.

Sebuah solusi yang sangat mudah akan memberikan hasil yang benar untuk setiap menit <= max dalam [bilangan Bulat.MIN_VALUE, Integer.MAX_VALUE]. Pertimbangkan hal berikut naif pelaksanaan:

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 sementara loop akan selalu menjadi 50% atau lebih tinggi.

Hal ini dapat dilakukan dengan hanya melakukan pernyataan:

jawa Randomizer.menghasilkan(0,10); //menit dari nol, max sepuluh

Di bawah ini adalah source-code

Randomizer.java

jawa public class Randomizer { public static int menghasilkan(int menit,int max) { kembali min + (int)(Math.random() * ((max - min) + 1)); } }

Itu hanya bersih dan sederhana.

Aku bertanya-tanya jika salah satu nomor acak menghasilkan metode-metode yang disediakan oleh Apache Commons Matematika perpustakaan akan sesuai dengan tagihan.

Misalnya: RandomDataGenerator.nextInt atau RandomDataGenerator.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 memahami ini...

Menginisialisasi max dengan nilai tertinggi dan min dengan nilai terendah.

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

5, 6, 7, 8, 9, 10

Jadi, jumlah ini akan menjadi max - min + 1.

yaitu 10 - 5 + 1 = 6

nomor acak akan menghasilkan angka antara 0-5.

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

Menambahkan min nilai bilangan acak akan menghasilkan:

5, 6, 7, 8, 9, 10

oleh Karena itu kita memperoleh kisaran yang diinginkan.

Menghasilkan nomor acak untuk perbedaan min dan max dengan menggunakan nextint(n) metode dan kemudian tambahkan min nomor hasilnya:

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

Sebagai Java 7, anda harus tidak lagi menggunakan Random. Bagi kebanyakan menggunakan, random number generator pilihan sekarang ThreadLocalRandom.

Untuk garpu bergabung renang dan paralel sungai, gunakan SplittableRandom.

Joshua Bloch. Efektif Jawa. Edisi Ketiga.

Mulai dari Jawa 8

Untuk fork bergabung renang dan sungai paralel, menggunakan SplittableRandom yang biasanya lebih cepat, lebih baik statistik kemerdekaan dan keseragaman sifat-sifat dalam perbandingan dengan Random.

Untuk menghasilkan acak int di kisaran [0, 1_000]:

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

Untuk menghasilkan acak int[100] array dari nilai-nilai dalam kisaran [0, 1_000]:

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

Untuk mengembalikan Aliran nilai acak:

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

Metode ini mungkin akan nyaman untuk digunakan:

Metode ini akan menghasilkan nomor acak antara disediakan min dan max nilai:

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 sebuah nomor acak dari disediakan min dan max nilai (sehingga angka yang dihasilkan juga bisa min atau max number):

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

    return randomNumber;
}

Dalam kasus bergulir dadu itu akan menjadi nomor acak antara 1 sampai 6 (tidak 0 sampai 6), sehingga:

face = 1 + randomNumbers.nextInt(6);

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

Atau lihatlah ke RandomUtils dari Apache Commons.

Berikut ini's kelas membantu untuk menghasilkan acak int dalam berbagai dengan kombinasi inklusif/eksklusif-batas:

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