Java'da belirli bir aralıkta rasgele tamsayıları nasıl oluştururum?

intBelirli bir aralıkta nasıl rastgele bir değer oluştururum ?

Aşağıdakileri denedim, ama bunlar çalışmıyor:

Deneme 1:

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

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

Gelen sonra Java 1.7 veya aşağıdaki gibi, bunu yapmak için standart bir yoludur:

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

İlgili JavaDoc'a bakın . Bu yaklaşımın avantajı, uygunsuz bir şekilde kullanıldığında karışıklık ve hata kaynağı olabilecek bir java.util.Random örneğinin açıkça başlatılmasına gerek olmamasıdır .

Bununla birlikte, tam tersine, tohumun açıkça ayarlanmasının bir yolu yoktur, bu nedenle oyun durumlarını test etmek veya kaydetmek gibi faydalı durumlarda sonuçların yeniden üretilmesi zor olabilir. Bu durumlarda, aşağıda gösterilen Java 1.7 öncesi tekniği kullanılabilir.

Java 1.7'den önce , bunu yapmanın standart yolu aşağıdaki gibidir:

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

İlgili JavaDoc'a bakın . Uygulamada, java.util.Random sınıfı genellikle java.lang.Math.random () yerine tercih edilir .

Özellikle, görevi gerçekleştirmek için standart kitaplıkta basit bir API olduğunda rastgele tamsayı oluşturma tekerleğini yeniden keşfetmeye gerek yoktur.

Bu yaklaşımın bir yaklaşımdan daha önyargılı ve daha az verimli olduğunu unutmayın nextInt, https://stackoverflow.com/a/738651/360211

Bunu başarmak için standart bir model:

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

Java Matematik kütüphane işlevi Math.random () aralığı içinde bir çift değeri oluşturur [0,1). Bu aralığın 1'i içermediğine dikkat edin.

Öncelikle belirli bir değer aralığı elde etmek için, kapsanmasını istediğiniz değer aralığının büyüklüğüyle çarpmanız gerekir.

Math.random() * ( Max - Min )

Bu, aralıktaki [0,Max-Min)'Maks-Min' değerinin dahil edilmediği bir değer döndürür .

Örneğin [5,10), isterseniz beş tamsayı değerini kapsamalısınız.

Math.random() * 5

Bu [0,5), 5'in dahil edilmediği aralıktaki bir değer döndürür .

Şimdi bu aralığı hedeflediğiniz aralığa kaydırmanız gerekiyor. Bunu Min değerini ekleyerek yaparsınız.

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

Artık aralıkta bir değer elde edeceksiniz [Min,Max). Örneğimizden sonra bu şu anlama gelir [5,10):

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

Ancak, bu hala içermiyor Maxve iki kat değer elde ediyorsunuz. MaxDahil edilen değeri elde etmek için, aralık parametrenize 1 eklemeniz (Max - Min)ve daha sonra bir int'e döküm yaparak ondalık kısmı kesmeniz gerekir. Bu, şu şekilde gerçekleştirilir:

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

İşte buyur. Aralıktaki [Min,Max]veya örnek başına rastgele bir tamsayı değeri [5,10]:

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

kullanın:

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

Tam sayı xartık olası bir sonucu olan rastgele sayıdır 5-10.

kullanın:

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

İle Java-8Bu yöntemi kişiye ints(int randomNumberOrigin, int randomNumberBound)de Randomsınıf.

Örneğin, [0, 10] aralığında beş rasgele tam sayı (veya tek bir) oluşturmak istiyorsanız, yapmanız gerekenler:

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

İlk parametre sadece IntStreamüretilenin boyutunu gösterir (sınırsız üreten bir kişinin aşırı yüklenmiş yöntemidir IntStream).

Birden fazla ayrı arama yapmanız gerekirse akıştan sonsuz bir ilkel yineleyici oluşturabilirsiniz:

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

Ayrıca değerler doubleve longdeğerler için de yapabilirsiniz . Umut ediyorum bu yardım eder! :)

İkinci kod örneğinizi aşağıdakiler için düzenleyebilirsiniz:

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

İlk çözümünüzde sadece küçük bir değişiklik yapmak yeterli olacaktır.

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

Uygulanması için buraya bakın Random

ThreadLocalRandomjava.util.Randomçok iş parçacıklı ortam için sınıf eşdeğeri . Rastgele bir sayı üretilmesi her bir iş parçacığında lokal olarak gerçekleştirilir. Yani çatışmaları azaltarak daha iyi bir performansa sahibiz.

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

x, y- aralıklar örn. (1,10)

Math.RandomSınıf Java 0 dayalıdır. Yani, böyle bir şey yazarsanız:

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

xarasında 0-9kapsayıcı olacak .

Dolayısıyla, aşağıdaki 25öğe dizisi göz önüne alındığında, 0(dizinin tabanı) arasında rastgele bir sayı oluşturmak için kod ve array.lengthşöyle olur:

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

index = rand.nextInt( i.length );

Yana i.lengthdönecektir 25, nextInt( i.length )aralığında arasında bir sayı döndürür 0-24. Diğer seçenek Math.Randomde aynı şekilde çalışıyor.

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

Daha iyi anlamak için, Rastgele Aralıklarla (archive.org) forum gönderisine göz atın .

Beni titiz olduğu için affedin, ancak çoğunluk tarafından önerilen çözüm, yani min + rng.nextInt(max - min + 1))şu gerçeği nedeniyle tehlikeli görünüyor:

• rng.nextInt(n)ulaşamıyor Integer.MAX_VALUE.
• (max - min)minnegatif olduğunda taşmaya neden olabilir .

Kusursuz bir çözüm, min <= max[ Integer.MIN_VALUE, Integer.MAX_VALUE] için doğru sonuçları döndürür . Aşağıdaki naif uygulamayı düşünün:

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

Verimsiz olmasına rağmen, whiledöngüdeki başarı olasılığının her zaman% 50 veya daha yüksek olacağını unutmayın .

Sadece şu ifadeyi kullanarak yapılabilir:

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

Kaynak kodu aşağıdadır

Randomizer.java

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

Sadece temiz ve basit.

Bir Apache Commons Math kütüphanesi tarafından sağlanan rasgele sayı üretme yöntemlerinden herhangi birinin faturaya uygun olup olmadığını merak ediyorum .

Örneğin: RandomDataGenerator.nextIntveyaRandomDataGenerator.nextLong

Bir örnek ele alalım.

5-10 arasında bir sayı oluşturmak istediğimi varsayalım :

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

Bunu anlayalım ...

En yüksek değere sahip maks ve en düşük değere sahip min değerini başlatın.

Şimdi, kaç olası değerin elde edilebileceğini belirlememiz gerekiyor. Bu örnek için:

5, 6, 7, 8, 9, 10

Yani, bunun sayısı max - min + 1 olacaktır.

yani 10-5 + 1 = 6

Rastgele sayı, 0-5 arasında bir sayı oluşturur .

yani 0, 1, 2, 3, 4, 5

Rastgele sayıya min değeri eklemek aşağıdakileri üretir:

5, 6, 7, 8, 9, 10

Böylece istenen aralığı elde ederiz.

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

Nextint (n) yöntemini kullanarak min ve max farkı için rastgele bir sayı oluşturun ve ardından sonuca min sayısı ekleyin:

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

Bunu kullanıyorum:

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

İsterseniz bir Tamsayıya atabilirsiniz.

Java 7'den itibaren artık kullanmamalısınız Random. Çoğu kullanım için, şimdi seçilen rastgele sayı üreteci ThreadLocalRandom.

Çatal birleştirme havuzları ve paralel akışlar için kullanın SplittableRandom.

Joshua Bloch. Etkili Java. Üçüncü baskı.

Java 8'den başlayarak

Çatal birleştirme havuzları ve paralel akışlar için, SplittableRandomgenellikle daha hızlı olan kullanım, daha iyi bir istatistiksel bağımsızlık ve homojenlik özelliklerine sahiptir Random.

intAralıkta rastgele oluşturmak için[0, 1_000]:

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

int[100]Aralıkta rastgele bir değerler dizisi oluşturmak için[0, 1_000]:

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

Rastgele değerlerden oluşan bir Akış döndürmek için:

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

Sadece Random sınıfını kullanın :

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

Bu yöntemlerin kullanımı uygun olabilir:

Bu yöntem , sağlanan minimum ve maksimum değerler arasında rastgele bir sayı döndürür :

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

ve bu yöntem bir rasgele sayı döndürür dan (üretilen sayısı da az ya da en fazla sayısı olabilir, böylece) temin minimum ve maksimum değeri:

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

    return randomNumber;
}

Bir zarın yuvarlanması halinde 1 ila 6 (0 ila 6 değil) arasında rastgele bir sayı olacaktır, bu yüzden:

face = 1 + randomNumbers.nextInt(6);

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

Veya Apache Commons'tan RandomUtils'e göz atın .

intsKapsayıcı / özel sınırların herhangi bir kombinasyonuyla bir aralıkta rastgele üretmek için yardımcı bir sınıf :

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

"İki sayı arasında" rastgele bir sayı oluşturmak için aşağıdaki kodu kullanın:

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

Bu size 1 (dahil) ile 11 (hariç) arasında rastgele bir sayı verir, bu nedenle 1 ekleyerek upperBound değerini başlatın. Örneğin, 1 ile 10 arasında rastgele bir sayı oluşturmak istiyorsanız, UpperBound numarasını 11 yerine 11 ile başlatın. 10.

Bunu Java 8'de kısaca yapabilirsiniz:

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

Başka bir seçenek sadece Apache Commons kullanıyor :

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

Bu örneği buldum Rastgele sayılar üret :

Bu örnek, belirli bir aralıkta rasgele tamsayılar üretir.

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

Bu sınıfın örnek bir çalışması:

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'u Rastgele kullanmaktan daha iyidir.

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

Burada, kapalı [min, max]aralıktan rastgele sayının nasıl oluşturulacağını gösteren basit bir örnekmin <= max is true

Tüm sınıfları Random.classtek bir yerde toplayarak delik sınıfındaki alan olarak tekrar kullanabilirsiniz

Sonuç örneği:

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

Kaynaklar:

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;

Bu iyi çalışıyor.