64 Soru: Java'da belirli bir aralıktaki rasgele tam sayıları nasıl oluştururum?

tarafından oluşturulan soru Sat, Jan 5, 2019 12:00 AM

Belirli bir aralıkta rastgele int değeri nasıl oluştururum?

Aşağıdakileri denedim, ancak işe yaramadı:

Deneme 1:

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

2. deneme:

 
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.
    
3240
30 Yanıtlar                              30                         

Java 1.7 veya sonraki sürümlerde , bunu yapmanın standart yolu aşağıdaki gibidir:

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

Bkz. ilgili JavaDoc . Bu yaklaşım açıkça bir java.util.Random örneği, uygun olmayan bir şekilde kullanılırsa karışıklık ve hata kaynağı olabilir.

Ancak, bunun tersine, tohumu açıkça belirtmenin bir yolu yoktur; bu nedenle, oyun durumlarını test etmek veya kaydetmek veya benzeri gibi yararlı olduğu durumlarda sonuçları tekrarlamak zor olabilir. Bu durumlarda, aşağıda gösterilen Java öncesi 1.7 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;
}

Bkz. ilgili JavaDoc . Uygulamada, java .util.Random sınıfı genellikle java.lang.Math.random () .

Özellikle, görevi tamamlamak için standart kitaplıkta basit bir API olduğunda rasgele tamsayı oluşturma tekerleğini yeniden icat etmeye gerek yoktur.

    
3591
2018-10-14 17: 08: 35Z
  1. max değerinin Integer.MAX_VALUE olduğu çağrılar için, java.lang.IllegalArgumentException ile sonuçlanan taşma yapmak mümkündür. Ile deneyebilirsiniz: randInt(0, Integer.MAX_VALUE). Ayrıca, nextInt((max-min) + 1) en yüksek değeri verirse (oldukça nadir, sanırım) tekrar taşmayacak mı (en az ve en yüksek değerlerin yeterli olduğunu varsayalım)? Bu tür durumlarla nasıl başa çıkılır?
    2014-08-12 10: 34: 30Z
  2. Bu uzun süre işe yaramıyor
    2015-02-23 06: 26: 46Z
  3. @ MoisheLipsker nextLong'un nextInteger ile sınırlanmadığı anlaşılmalıdır
    2015-06-17 18: 42: 57Z
  4. @ leventov ThreadLocalRandom, bu sorunun ilk sorulmasından 2/2 yıl sonra Java'ya eklendi. Ben her zaman Rastgele vakasının yönetiminin sorunun kapsamı dışında olduğu fikrine katılıyorum.
    2015-09-11 01: 57: 18Z
  5. Android'de Rastgele rand = new Random ();
    2016-10-03 19: 55: 05Z

Bu yaklaşımın nextInt yaklaşımından daha taraflı ve daha az etkili olduğuna dikkat edin, https://stackoverflow.com/a/738651/360.211

Bunu başarmak için standart bir şablon şudur:

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

Java Matematik kitaplığı işlevi Math.random () çift değer oluşturur [0,1) aralığında. Bu aralığın 1’i içermediğine dikkat edin.

Öncelikle belirli bir değer aralığını elde etmek için, değer aralığının büyüklüğü ile çarpmanız gerekir.kapalı kalmak istiyorsun.

 
Math.random() * ( Max - Min )

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

Örneğin, [5,10) istiyorsanız, beş tam sayı değerini kullanmanız gerekir, böylece kullanmanız gerekir

 
Math.random() * 5

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

Şimdi bu aralığı hedeflemekte olduğunuz aralığa kaydırmanız gerekiyor. Bunu Min değerini ekleyerek yaparsınız.

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

Artık [Min,Max) aralığında bir değer alacaksınız. Örneğimize göre bu, [5,10):

anlamına geliyor.  
5 + (Math.random() * (10 - 5))

Ancak, bu hala Max'u içermiyor ve siz de çifte değer alıyorsunuz. Max değerini dahil etmek için, (Max - Min) aralık parametrenize 1 eklemeniz ve ardından bir int öğesine yazarak ondalık kısmı kesmeniz gerekir. Bu şu şekilde gerçekleştirilir:

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

Ve işte orada. [Min,Max] aralığında veya [5,10] örneğinde rastgele bir tam sayı değeri:

 
5 + (int)(Math.random() * ((10 - 5) + 1))
    
1383
2019-02-08 14: 13: 34Z
  1. Sun dokümantasyonu açıkça bir çift üreten Math.random () yerine bir int'e ihtiyacınız varsa Random () kullanmanız gerektiğini söyler.
    2012-02-23 23: 26: 34Z
  2. Bu aslında bir sonrakiInt yöntemleriyle karşılaştırıldığında önyargılıdır. stackoverflow.com/a/738651 /360211
    2016-12-29 13: 35: 53Z

Kullanım:

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

x tamsayısı şimdi 5-10 olası sonucu olan rasgele sayıdır.

    
338
2019-02-08 14: 14: 20Z

Kullanım:

 
minimum + rn.nextInt(maxValue - minvalue + 1)
    
143
2014-06-22 22: 22: 52Z

ints(int randomNumberOrigin, int randomNumberBound) Random sınıfında.

Örneğin, [0, 10] aralığında beş rastgele tam sayı (veya tek bir tane) oluşturmak istiyorsanız, şunu yapın:

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

İlk parametre, yalnızca oluşturulan IntStream'un boyutunu belirtir (bu, sınırsız IntStream üreten aygıtın aşırı yüklenmiş yöntemidir).

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

Bunu double ve long değerleri için de yapabilirsiniz.

Umarım yardım eder! :)

    

118
2019-02-08 14: 14: 56Z
  1. randomIterator'ı yalnızca bir kez başlatmanızı öneriyorum. Greg Case'in kendi cevabına yaptığı yorumu görün.
    2018-02-26 07: 13: 43Z
  2. mümkünse streamSize'un önemini açıklayabilir misiniz - streamSize !=0 verilen bu yöntemin ilk paramı. streamSize 1/2 /n verildiğinde fark nedir?
    2018-04-10 10: 39: 40Z

İkinci kod örneğinizi şu şekilde düzenleyebilirsiniz:

 
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;
    
100
2019-02-08 13: 02: 02Z

İlk çözümünüzde yalnızca küçük bir değişiklik yapılması yeterli olacaktır.

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

Random

    
97
2019-02-08 14: 14: 29Z
  1. Minimum için < = değer < maksimum, Math ile aynı şeyi yaptım: randomNum = minimum + (int) (Math.random () * (maksimum-minimum)); ancak oyuncu seçimi gerçekten hoş değil;)
    2016-07-08 12: 30: 15Z

    Çok iş parçacıklı ortam için java.util.Random sınıfının ThreadLocalRandom eşdeğeri. Her bir dişinde yerel olarak rastgele bir sayı üretilir. Bu yüzden çatışmaları azaltarak daha iyi bir performansa sahibiz.

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

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

        
    62
    2016-04-21 06: 03: 42Z

    Java 'daki Math.Random sınıfı 0 tabanlıdır. Öyleyse, böyle bir şey yazarsanız:

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

    x, 0-9 dahil olmak üzere olacaktır.

    Dolayısıyla, aşağıdaki 25 maddeden oluşan bir dizi verilirse, 0 (dizinin tabanı) ile array.length arasında rasgele bir sayı üretecek kod şöyle olacaktır:

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

    i.length, 25 değerini döndüreceğinden, nextInt( i.length ), 0-24 aralığı arasında bir sayı döndürür. Diğer seçenek de aynı şekilde çalışan Math.Random ile devam ediyor.

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

    Daha iyi bir anlayış için, Rastgele Aralıkları (archive.org) .

        
    61
    2019-02-08 14: 14: 25Z
    1. wayBackMachine arşiv ekran görüntüsü için + 1 link & Cevabınız hala bir aralıkta "rastgele" ints w /almak için yararlı bir referanstır.
      2016-10-30 05: 44: 57Z
    2. Dizini neden 0 olarak başlattığım için beni şaşırtıyor.
      2017-08-02 13: 53: 53Z
    3. @ CodeConfident index değişkeni rasgele sayının sonucunu etkilemez. Sonucu değiştirme konusunda endişelenmenize gerek kalmadan istediğiniz şekilde başlatmayı seçebilirsiniz. Umarım bu yardımcı olur.
      2017-08-02 14: 38: 52Z
    4. Kesinlikle ... tamamen kullanılmamış. Doğrudan rand: int index = rand.nextInt(i.Length);'a başlatacağım
      2017-08-02 14: 41: 09Z

    Titiz olduğum için beni bağışlayın, ancak çoğunluk tarafından önerilen çözüm, yani min + rng.nextInt(max - min + 1)), aşağıdakiler nedeniyle tehlikeli görünüyor:

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

    Kusursuz bir çözüm, [min <= max, Integer.MIN_VALUE] içindeki herhangi bir Integer.MAX_VALUE için doğru sonuçları verir. Aşağıdaki saf uygulamayı göz önünde bulundurun:

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

    Yetersiz olmasına rağmen, while döngüsündeki başarı olasılığının her zaman% 50 veya daha yüksek olacağını unutmayın.

        
    48
    2018-04-23 05: 21: 33Z
    1. Neden fark = Integer.MAX_VALUE olduğunda IllegalArgumentException atılmıyor? O zaman while döngüsüne ihtiyacınız olmaz.
      2015-01-09 10: 27: 57Z
    2. @ mpkorstanje Bu uygulama, farkları MAX_VALUE değerine eşit veya hatta daha büyük olsalar da, min
      2015-05-06 19: 27: 30Z

      Bir Apache Commons Math tarafından sağlanan rasgele sayı üreten yöntemlerden herhangi birinin olup olmadığını merak ediyorum > kütüphane tasarıya uyacaktır.

      Örneğin: RandomDataGenerator.nextInt veya RandomDataGenerator.nextLong

          
      33
      2016-11-16 12: 08: 17Z

      Sadece açıklama yaparak yapılabilir:

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

      Aşağıda kaynak kodu verilmiştir

      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.

          
      31
      2019-03-03 14: 29: 04Z
      1. Bu, diğer örneğin bir düzenlemesi olabilirdi, şimdi sadece itibar için bariz bir kopya. "En çok oyu alan cevap" a işaret etmek de doğrudan değil, değişebilir.
        2017-06-19 21: 23: 47Z
      2. Doğru mu @MaartenBodewes. Bu cevabı yazdığımda, yukarıda en çok oy alan cevabı hala algoritma benzeri bir çözüm olarak yazdı. Şimdi, yukarıdaki çözüm çok değişti ve şimdi bu cevap bir kopya-kedi gibi görünüyordu.
        2017-06-20 00: 36: 07Z

      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, en düşük değere sahip min.

               

      Şimdi, kaç olası değer elde edilebileceğini belirlemeliyiz. Bu örnek için şöyle olurdu:

               
            

      5, 6, 7, 8, 9, 10

          
               

      Öyleyse, bunun sayısı en fazla - min + 1 olur.

               
            

      yani. 10 - 5 + 1 = 6

          
               

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

               
            

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

          
               

      min değerinin rastgele sayıya eklenmesi şu sonucu verir:

               
            

      5, 6, 7, 8, 9, 10

          
               

      Böylece istenen aralığı elde ederiz.

        
          
      30
      2019-02-08 14: 14: 10Z
       
       rand.nextInt((max+1) - min) + min;
      
          
      27
      2017-12-20 19: 34: 30Z

      nextint (n) yöntemi ve daha sonra sonuca min. sayı ekleyin:

       
      Random rn = new Random();
      int result = rn.nextInt(max - min + 1) + min;
      System.out.println(result);
      
          
      22
      2019-02-08 14: 15: 07Z
        

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

      Çatallar için havuzlar ve paralel   akışları, SplittableRandom 'ı kullanın.

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

      Java 8'den Başlarken

      Çatal birleştirme havuzları ve paralel akışlar için, genellikle daha hızlı olan SplittableRandom'u kullanın, Random'a kıyasla daha iyi bir istatistiksel bağımsızlık ve tekdüzelik özelliklere sahiptir.

      int aralığında rastgele bir [0, 1_000]: oluşturmak için

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

      int[100] aralığında rastgele bir [0, 1_000]: değer dizisi oluşturmak için

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

      Rastgele değerler akışını döndürmek için:

       
      IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
      
          
      21
      2019-02-08 08: 56: 49Z
      1. Örneğin .parallel() içermesinin bir nedeni var mı? Bana göre 100 rastgele sayı üretmek, paralelliği garanti etmek için çok önemsiz olacak gibi görünüyor.
        2018-07-20 06: 29: 12Z
      2. @ Johnbot Yorumunuz için teşekkürler, haklısınız. Ancak, ana neden bir API göstermekti (elbette, akıllı yol parallel işlemeyi kullanmadan önce performansı ölçmektir). Bu arada, 1_000_000 element dizisi için, parallel versiyonu makinemde sıralı ile kıyaslandığında 2 kat daha hızlıydı.
        2018-07-20 08: 35: 20Z

      İşte, kapsayıcı /özel sınırların herhangi bir kombinasyonuyla bir aralıkta rastgele ints oluşturmak için yararlı 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;
          }
      }
      
          
      19
      2012-02-15 16: 19: 03Z

      Bir zar atılması durumunda, 1 ile 6 arasında (0 ile 6 arasında değil) rasgele bir sayı olacaktır, yani:

       
      face = 1 + randomNumbers.nextInt(6);
      
          
      19
      2016-04-21 06: 01: 47Z

      "İki sayı arasında" rasgele 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) ve 11 (özel) arasında rastgele bir sayı verir, bu nedenle 1 ekleyerek upperBound değerini başlatın. Örneğin, 1 ile 10 arasında rasgele sayı oluşturmak istiyorsanız, daha sonra 10 yerine 11.

          
      19
      2019-02-08 14: 09: 12Z
       
      int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
      

      Veya Apache Commons 'dan RandomUtils’a bakın.

          
      19
      2019-02-08 14: 11: 23Z
      1. Bu kullanışlı, ancak küçük bir kusura dikkat edin: yöntem imzaları gibidir: nextDouble (double startInclusive, double endInclusive), ancak yöntemlerin içine bakarsanız, endInclusive aslında olmalı endExclusive.
        2015-01-30 09: 27: 17Z
      2. Double.valueOf(Math.random()*(maximum-minimun)).intValue(), (int)(Math.random()*(maximum-minimun)) demenin oldukça karışık (ve verimsiz) bir yoludur…
        2016-06-03 09: 47: 15Z
      3. Minimum getiri için yazım uyumsuzluğu minimum + Double.valueOf (Math.random () * (maximum - minimum)). intValue ();
        2016-12-26 05: 14: 23Z

      Bu yöntemler kullanımı uygun olabilir:

      Bu yöntem, verilen minimum ve maksimum değerin rasgele bir sayısını //>> /em> 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 sağlanan minimum ve maksimum değeri /em> 'den rasgele bir sayı döndürecektir (oluşturulan sayı aynı zamanda minimum veya maksimum sayı da olabilir):

       
      public static int getRandomNumberFrom(int min, int max) {
          Random foo = new Random();
          int randomNumber = foo.nextInt((max + 1) - min) + min;
      
          return randomNumber;
      }
      
          
      19
      2019-02-08 14: 14: 37Z
      1. // Since the random number is between the min and max values, simply add 1. Niye ya? Min sayılmaz mı? Genellikle, aralık min [max, maks] 'dir, min min içerilir ve max hariçtir. Yanlış cevap, oy kullanıldı.
        2017-03-01 21: 26: 35Z
      2. @ MaartenBodewes +1 eklendi, çünkü getRandomNumberBetween, sağlanan bitiş noktaları hariç rasgele bir sayı oluşturuyor.
        2017-03-02 09: 53: 53Z
      3. min + 1 sayısı, getRandomNumberBetween'un sonucundan iki kat daha büyük olacaktır!
        2018-06-17 12: 21: 50Z

      Bunu Java 8'de tam olarak başarabilirsiniz:

       
      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);
      
          
      17
      2019-02-08 14: 14: 15Z

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


      Bu örnek, belirli bir aralıktaki rasgele tam sayı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.
      
          
      17
      2019-02-08 14: 14: 44Z

      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);
      
          
      17
      2019-02-08 14: 15: 11Z
      1. Burada daha önce sayısız yayında yayınlanmamış yeni bir şey göremiyorum.
        2017-06-19 21: 21: 53Z

      Çok fazla rastgele sayıya ihtiyacınız olduğunda, API'deki Random sınıfını önermiyorum. Çok küçük bir dönemi var. Bunun yerine Mersenne twister'ı deneyin. bir Java uygulaması .

          
      16
      2013-08-01 18: 02: 34Z
       
      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);
      }
      
          
      16
      2019-02-08 14: 15: 15Z

      Başka bir seçenek yalnızca 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);
          // ...
       }
      
          
      15
      2018-04-23 05: 22: 28Z

      İşte [min, max] aralığında kapalı min <= max is true aralığından rasgele sayı oluşturmayı gösteren basit bir örnek: 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
      
      yönteminin tümünü tek bir yerde de bulunduran, onu delik sınıfındaki alan olarak yeniden kullanabilirsiniz

      Sonuç örneği:

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

      Kaynaklar:

       
      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;
      }
      
          
      14
      2014-11-28 00: 58: 54Z
      1. 2017-06-19 21: 21: 16Z

      SecureRandom yerine kullanmak daha iyidir sadece rastgele değil.

       private static int SecureRandom rand = new SecureRandom();     
      13
      2016-07-06 19: 19: 36Z
      1. Bu o kadar iyi değil, çünkü aynı mili saniye içinde çalıştırılırsa aynı sayıyı alırsınız, rand başlatma işlemini ve setSeet ayarını dışa koymanız gerekir. Yöntemin.
        2015-04-16 19: 30: 54Z
      2. Evet, ancak SecureRandom kullanmanız gerekir.
        2015-04-17 12: 03: 36Z
      3. Üzgünüm, ancak değişiklik isteğini reddeden Java programlaması hakkında hiçbir ipucu yok İyi bir öneri, ancak yanlış olduğu gibi çünkü aynı mili saniyede çalıştırılırsa rastgele değil aynı sayıyı verecektir.
        2015-04-18 09: 19: 43Z
      4. Doğru çözüm bulunacak bir yer değil, çok sayıda kişi statik ilkleyici blokları bilmiyor ... ... tohumu ayarlamak için kullanmanız gereken şey bu: 1: static { 2: rand.setSeed(...); 3: } 4: SecureRandom
        2015-04-18 09: 30: 44Z
      5. setSeed tohumlamaya kesinlikle gerek yok, sistem tarafından ekilecek. Doğrudan SecureRandom'u aramak çok tehlikelidir, (gerçekten rastgele) tohumun tarihini değiştirebilir. Ve bu kesinlikle olmaz bir SecureRandom ile sonuçlanır, çünkü herkes zamanı tahmin edebilir ve bu bilgiyle kendi
        rand.nextInt((max+1) - min) + min;
        
        örneğini ekmeye çalışır.
        2017-03-01 21: 32: 46Z
         

        Bu iyi çalışıyor.

            
        12
        2016-04-21 06: 01: 59Z
kaynak yerleştirildi İşte