RSS

Java puzzlers, Java random numbers and Java documentation

31 Jul

About a month ago Mehmet D. Akın (of Zemberek fame, currently working at Google) drew my attention to an interesting case related to generating a sequence of random numbers in Java. Let me pose this as an interview question:

What will be the output of the following Java program?


Well, you may object by saying that you are not that expert in Java so I’m going to help you a little bit by providing the following tips (à la Google interview style):

Random(long seed): Creates a new random number generator using a single long seed.

public int nextInt(int n): Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator’s sequence. The general contract of nextInt is that one int value in the specified range is pseudorandomly generated and returned. All n possible int values are produced with (approximately) equal probability.

Let me repeat the question: What will be the output of the program above?

Well, if you consumed your patience you are free to type, compile and run it to see the following output:


5
5
5
5
5
.
.
.
5
5
5
.
.
.

Surprising, isn’t it. After all the sequence does not look random at all, at least not what you’d expect from a random number sequence (and please, oh please, do not get me started on the philosophy of sequences of random numbers). You may have two objections:

1- Why do you create new Random objects all the time? My answer: Why not? Is it fundamentally against generating random numbers? (I’m not suggesting that this is the typical way of generating random numbers in Java, but that’s a different story.) And a new seed is given to a new Random object all the time, so what is the real reason behind the surprising output above?

2- Why don’t we read the documentation more carefully? Well, let’s do:

The algorithm treats the case where n is a power of two specially: it returns the correct number of high-order bits from the underlying pseudo-random number generator. In the absence of special treatment, the correct number of low-order bits would be returned. Linear congruential pseudo-random number generators such as the one implemented by this class are known to have short periods in the sequence of values of their low-order bits. Thus, this special case greatly increases the length of the sequence of values returned by successive calls to this method if n is a small power of two.

Do you find this explanation very satisfying? Of course it is much better than nothing and gives a lot of hints (or should I say ‘warning’?) but still somewhat confusing. In a recent article entitled “The Risks of Stopping Too Soon“, David Lorge Parnas writes (emphasis is mine):

Problems caused by premature termination are found in all kinds of software documentation. For example, if you read the descriptions of methods in a Java library, you can usually pose questions that can only be answered by experimenting with an implementation or reading the code. So called “odd cases” are either not covered or ambiguously covered. For example, one often finds a list of exceptions that a class will “throw” but it is not clear if cases such as zero length string arguments are exceptions or what happens if two of the listed exceptions could be “thrown”. Generally, it appears that the documenter started to write down a description but quit when they got to the tedious parts.

I don’t know whether Parnas would consider the documentation of the Random numbers library of Java as an example of what he describes above, but the first time I read it I was a bit at a loss which made me ask the question “what kind of algorithms are used?”. Apparently, the method used comes from Knuth’s The Art of Computer Programming (Vol. 2, chapter 3.2.1 ‘The Linear Congruential Method’, pages 10-11) and when you read that part (which I actually did, a few times) you will not see any apparent mistakes. To dig deeper you should read the source code util.Random itself, especially lines 263-268. And then reading the first answer to the StackOverflow question entitled “Seeding java.util.Random with consecutive numbers” will be very helpful. You may also find the discussion under ‘Generating Random Numbers‘ section of Java Developer Connection tips useful, too.

As for the final interview question: If your favorite or daily programming language is different from Java, do you have similar quirks? What about the implementation AND the documentation?😉

PS: After reading the source code, I realized that Frank Yellin who coded java.util.Random class among other things and who works at Google now, also happens to be a former Common Lisp programmer, and worked at Richard P. Gabriel‘s Lucid Inc. (It is up to you how to interpret this nugget of information).

 
14 Comments

Posted by on July 31, 2011 in Math, Programlama

 

Tags:

14 responses to “Java puzzlers, Java random numbers and Java documentation

  1. Ali Utku Selen

    August 1, 2011 at 01:28

    Ben cocukken Pascal’da yazdığım basit oyunlarda kullanmak için bir türlü rastgele sayı üretme işini anlayamamıştım. Oyuncular oyunu tekrar oynadıklarında bir sonraki adım da ne olacağını hatırlayabiliyorlardı. Daha sonra anladım ki, seed olarak gerçek zamanı (o anki saati) koymak işi çözüyordu.

    “The generation of random numbers is too important to be left to chance.” geyiğini de herhalde herkes biliyordur.

    Hal böyleyken, malesef ortada şaşırtıcı (puzzling) bir durum göremiyorum. Şöyle ki, new Random ile yarattığın her makina kendi içinde belirttiğin kontratı

    “The general contract of nextInt is that one int value in the specified range is pseudorandomly generated and returned. All n possible int values are produced with (approximately) equal probability.”

    sağlamak zorunda. Üstelik benzer tohumlar kullanarak benzer sayılar elde edince de şaşırmamak gerek.

    Sonuc olarak tekrar belirteyim ben şaşırmadım🙂

    http://xkcd.com/221/

     
  2. Emre Sevinc

    August 2, 2011 at 00:10

    Şaşırmamana şaşırdım açıkçası. Döndürülen değerler benzer sayılar değil, hep aynı sayılar. Örnek kod parçasına + dokümantasyona şöyle bir bakıp hep aynı değer döneceğini tahmin ettiysen ve bunun da sebebini hemen açıklayabildi isen buna lafım yok, guru imişsin der saygı duruşuna geçerim😉

     
  3. Ali Utku Selen

    August 2, 2011 at 08:31

    “Üstelik benzer tohumlar kullanarak ayni sayılar elde edince de şaşırmamak gerek.” demeliydim.

    [0,8) arasinda hep 5 i gormek cok zor degil aslinda?yani 8 yuzlu bir zar olsa herhalde bir kac kere ardi ardina 5 atabilirsin.

    Soru geldiginde ayni sayiyi dondurebilecegini soyleyebilirim ama hangi sayiyi dondurecegini soyleyemem, ya da neden ayni sayiyi dondurebilecegini aciklayabilir misim gibi geliyor.

    Soyle dusunmem yanlis mi acaba?
    Mesela rastgele sayi mekanizmasi her nextInt(8) cagirildiginda sirayla 1,2,3,4,5,6,7 dondursun. Simdi sen seed ile nereden baslayacagini degistirmeye calisiyorsun ki her zaman birden baslamasin 3,4,5,6,7,1,2,3… diye gidebilsin. Senin sagladigin seed MAX INT degerinde olabilir ama aslinda senin icin 1 ile 8 (rastgele sayi serisinin indexi). Senin MAX INT e kadar girdigin sayiyi algoritma [0,MAX INT) den [0,8) e cevirmeli degil mi? Bunu da yapmanin bir yolu MAX INT / 8 * INPUT / x = 1 diyebilmek. x burada senin seedinin hassasligini yokeden sey.

    Demek istedigim seedin birbirine yakin olmasinin sonuclarini anlayabilir misim gibi geliyor, ya da seed’in onemini biliyorum🙂

     
  4. Emre Sevinc

    August 2, 2011 at 12:09

    Buradaki mesele ‘seed’ değil, nextInt’e geçilen değerin 2’nin tam kuvveti olması, anlatmaya çalıştığım şey o. Elbetteki tohum değeri çok önemli ama buradaki meselenin başka bir şey olduğunu gösteren çok basit bir deney yapabilirsin. nextInt(8) yerine nextInt(7) şeklinde yazıp çalıştır programı (ya da 8 yerine 6 ile dene). 5, 4, 5, 5, 3, 2, 4, 3, 1, 0, … şeklinde bir sayı dizisi ile karşılaşacaksın. Tohum üretimine hiç dokunmadık üstelik 8 yüzlü zardan 7 yüzlü zara indik yani olasılık uzayını küçülttük ve elde ettiğimiz sayı dağılımının heterojenliği bir anda arttı. Yani ben aynı soruyu nextInt(8) değil de nextInt(7) yazıp sunsa idim yukarıdaki akıl yürütmen elde edilen sonucu açıklamayacaktı zira akıl yürütmene göre aynı sayı dizisi çıkması gerekirken hiç de öyle olmayan bir sayı dizisi ile karşılaşacaktık. (Belki de bu 7’li örneği blogda belirtseydim daha iyi olurdu, aradaki farkı göstermek açısından).

     
  5. Ali Utku Selen

    August 2, 2011 at 16:09

    Yok, ben hep 2’nin kuvvetleri uzerinden dusunuyorum – zira algoritmanin o konuda ozel davrandigini dokumanda da belirtiyor, senin gosterdigin gibi.

    import java.util.Random;

    public final class RandomPuzzle {
    public static void main(String[] args) {
    for(int i = 0; i < 256; i++) {
    System.out.println(new Random(i * 1023).nextInt(8));
    }
    }
    }

    "Algoritmada ardisik seedlerin, n'in 2'nin kuvveti ile cagrildiklarinda serilerin ilk elemanlarinin dagilimlari esit degil" gibi bisi diyelim?

     
  6. Emre Sevinc

    August 2, 2011 at 17:07

    Diyelim demesine, doğru da bir şey demiş oluyoruz ama bunu dediğimizde bloga konu olan ve benim şaşırtıcı addettiğim duruma dair bir açıklama getirmekten ziyade zaten söylenmiş bir şeyi daha kısaca ifade etmekten başka bir şey yapmış olmuyoruz.

    Son yorumuna dair derdim şu: 2’nin kuvvetleri üzerinden düşünüldüğünde dokümantasyonda zaten özel davranış belirtilmiş diyorsun. nextInt(int n) dokümantasyonunda son kısımda şöyle diyor:

    “The algorithm treats the case where n is a power of two specially: it returns the correct number of high-order bits from the underlying pseudo-random number generator. In the absence of special treatment, the correct number of low-order bits would be returned. Linear congruential pseudo-random number generators such as the one implemented by this class are known to have short periods in the sequence of values of their low-order bits. Thus, this special case greatly increases the length of the sequence of values returned by successive calls to this method if n is a small power of two.”

    Yani 2’nin tam kuvvetlerini kullansanız dahi, normal durumda yani efendi gibi tek bir Random nesnesine sahip olma durumunda, zekice implementasyon sayesinde kabul edilebilir derecede rastsal sayı dizileri elde edersiniz diyor (yanlış anlıyorsam düzelt lütfen). Gayet güzel, bunu okuyan biri güven içinde kodlamasına devam edebilir. Ama ben de diyorum ki bunun konuyla pek bir alakası yok zira dokümantasyonun o kısmında bloga konu olan garip hal (sürekli Random nesnesi üretilmesi ve bunun ardışık tohumlar ile yapılması) ele alınmıyor, buna dair bir şey yok. Böyle olması da beklenen bir durum zira büyük ihtimalle o dokümantasyonu ben de yazsam birinin kalkıp yüzlerce Random nesnesi oluşturması halini hayal etmezdim, zira normal şartlar altında böyle bir şeye kalkışmak saçma olur (rastsal sayı üretmek açısından saçma, bambaşka bir bağlamda başlangıçta anlamlı bir hareket gibi görünmüş olabilir).

    Özetlemek gerekirse:

    a- Random nesnesi ikinin kuvveti olsun ya da olmasın belli ölçüde rastsallık imkanı sunuyor.

    b- Dokümantasyonda n’nin ikinin tam kuvveti olması durumunda nextInt(n)’nin zekice şekilde olası negatif etkileri bertaraf ettiği belirtiliyor.

    c- Random nesneleri ardışık tohumlar ile dahi oluşturulsalar çoğu durumda tekil tekil çağrılan nextInt metodlarının sonuçları kabul edilebilir rastsallıkta sonuç döndürüyor (çoğu durum: n’nin 2’nin kuvveti olMAması hali).

    d- Lakin n’nin 2’nin kuvveti olması durumunda işin rengi epey değişiyor.

    Ve ben de diyorum ki: a, b ve c’den yola çıkarak ve *sadece* dokümantasyona bakarak d sonucunu çıkarsamak mümkün değil. Bu sonuca daha doğrusu tam açıklamaya varabilmek için Random sınıfının implementasyonunun kaynak koduna gitmek gerekiyor ki mesela blogdaki SO linkindeki açıklamada da tam olarak bu yapılmış.

    Eh, bir şeyi açıklamak için bu kadar detaya inmek gerekiyorsa, implementasyonun kaynak koduna dalmak gerekiyorsa o zaman o şeyin şaşırtıcı olduğunu kabul etmekte bir yanlışlık yok. Benim özgün yazıda aktarmaya çalıştığım ana fikir de kısaca buydu.

     
  7. M

    August 2, 2011 at 17:53

    Galiba, Random yapılandırıcısının parametre almadan(seed almadan) kullanım
    durumu da var ki bu bir bug meydana getirmez mi? Dökümanda:

    Random rnd = new Random();
    r.setSeed(seed);

    belirtilmiş. Soru aslında: Seed kullanmak zorunlu ise parametre almayan yapılandırıcıyı private yapmak doğru olmaz mı?

     
  8. Ali Utku Selen

    August 2, 2011 at 17:59

    Katiliyorum. En basta dedigimiz gibi, rastgele sayilar sakaya gelmez.

     
  9. Ali Utku Selen

    August 2, 2011 at 18:01

    Ustteki cevap Emre’ye idi🙂

    setSeed kullanimi zorunlu degil, default constructor ( Random() ) bunu senin icin yapiyor.

     
  10. M

    August 2, 2011 at 18:15

    Ancak dökümanda şöyle yazılmış:

    “If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers.”

     
  11. M

    August 2, 2011 at 18:41

    Şöyle:

    public Random() { this(++seedUniquifier + System.nanoTime()); }

    yapılandırıcı seed almadan yani seed belirtmeden — default yapılandırıcıyı kullanmak (http://download.oracle.com/javase/6/docs/api/java/lang/System.html#nanoTime%28%29) — kullanmak daha tehlikesiz değil mi? Çünkü kazayla aynı seedi verirsek aynı sonuçları almamız mümkün olacaktır.

     
  12. Ali Utku Selen

    August 2, 2011 at 19:00

    Zaten seed’in amaci ayni sonuclari tekrar yaratabilmek. Mesela bir oyun yazdin, rastgele sayilara ihtiyacin var, ayni zamanda oyunun test edilebilir olmasini istiyorsun. oyunda bir sorun ciktiginda tekrar ayni durumu yaratabilmek icin ayni seed i kullanabilirsin.

     
  13. M

    August 5, 2011 at 18:19

    Test etmek istediğim bir durum oldu bunu sizinle paylaşmak isterim:
    Sınıf içerisinde, “static Random nesnelerinden” sadece bir(1) örneğinin oluşturulmasına rağmen randomString() methodunun çağrılması durumu değiştirmiyor yani static olan veya olmayan Random nesnesi bir kereliğine aynı seed ile oluşturulursa randomString() nesnesinin çağrılmasından itibaren sonuçlar farklı olmaktadır.

    import java.util.Random;

    /**
    * RandomTwoInstance class’s main purpose is to show usage difference of static
    * Random variable and Random variable with given same or different seeds.
    *
    *@author M
    *@created 05 Ağustos 2011 Cuma
    */
    public class RandomTwoInstance {

    /**
    * The main program for the RandomTwoInstance class
    *
    *@param args The command line arguments
    */
    public static void main(String[] args) {

    RandomTwoInstance twoInstance = new RandomTwoInstance();

    //seed is 5
    RandomClass object1 = twoInstance.new RandomClass(5);
    // random String length is 5
    String s1 = object1.randomString(5);
    String s10 = object1.randomString(5);
    System.out.println(“Random Object with seed 5 ” + s1);
    System.out.println(“Random Object with seed 5 with calling randomString method ” + s10);

    //seed is 5
    RandomClass object2 = twoInstance.new RandomClass(5);
    // random String length is 5
    String s2 = object2.randomString(5);
    System.out.println(“Random Object with seed 5 ” + s2);

    // random Seed 1
    RandomClass object3 = twoInstance.new RandomClass();
    //random String length is 5
    String s3 = object3.randomString(5);
    System.out.println(“Random Object with random seed ” + s3);

    //random Seed 2
    RandomClass object4 = twoInstance.new RandomClass();
    //random String length is 5
    String s4 = object4.randomString(5);
    System.out.println(“Random object with random seed ” + s4);

    RandomClassWithStatic object5 = new RandomClassWithStatic(6);
    //random String length is 5
    String s5 = object5.randomString(5);
    System.out.println(“Static Random object with seed 6 ” + s5);

    RandomClassWithStatic object6 = new RandomClassWithStatic(6);
    //random String length is 5
    String s6 = object6.randomString(5);
    System.out.println(“Static Random object with seed 6 ” + s6);

    RandomClassWithStatic object7 = new RandomClassWithStatic();
    //random String length is 5
    String s7 = object7.randomString(5);
    String s9 = object7.randomString(5);
    System.out.println(“Static Random object s7 ” + s7);
    System.out.println(“Static Random object s9 with calling randomString method ” + s9);

    RandomClassWithStatic object8 = new RandomClassWithStatic(6);
    //random String length is 5
    String s8 = object8.randomString(5);
    String s11 = object8.randomString(5);
    System.out.println(“Static Random object s8 with seed 6 ” + s8);
    System.out.println(“Static Random object s11 with seed 6 with calling randomString method ” + s11);

    }

    /**
    * Description of the Class
    *
    *@author M
    *@created 05 Ağustos 2011 Cuma
    */
    class RandomClass {
    final static String alpha = “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”;

    Random rnd = new Random();

    /**
    * Constructor for the RandomClass object
    */
    public RandomClass() {
    this.rnd = new Random();
    }

    /**
    * Constructor for the RandomClass object
    *
    *@param seed Description of the Parameter
    */
    public RandomClass(int seed) {
    rnd.setSeed(seed);
    }

    /**
    * Bu kod StackOverflow’dan alında ancak adresi hatırlayamadım. StringBuilder
    * nesnesi ve nextInt ile random bir sayı meydana getirip bu sayı ile alpha
    * String’in belirli kısımlarını substring ile alıp StringBuilder nesnesine
    * ekleyerek geri döndürmektedir.
    *
    *@param len Random oluşturulacak String uzunluğu
    *@return Random oluşturulan String nesnesi dönmektedir.
    */
    public String randomString(int len) {
    StringBuilder sb = new StringBuilder(len);
    for(int i = 0; i < len; i++) {
    int num = rnd.nextInt(alpha.length());
    sb.append(alpha.substring(num, num + 1));
    }
    return sb.toString();
    }

    }

    }

    /**
    * Description of the Class
    *
    *@author M
    *@created 05 Ağustos 2011 Cuma
    */
    class RandomClassWithStatic {

    final static String alpha = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    static Random rnd = new Random();

    /**
    * Constructor for the RandomClass object
    */
    public RandomClassWithStatic() {
    this.rnd = new Random();
    }

    /**
    * Constructor for the RandomClass object
    *
    *@param seed Description of the Parameter
    */
    public RandomClassWithStatic(int seed) {
    rnd.setSeed(seed);
    }

    /**
    * Bu kod StackOverflow'dan alında ancak adresi hatırlayamadım. StringBuilder
    * nesnesi ve nextInt ile random bir sayı meydana getirip bu sayı ile alpha
    * String'in belirli kısımlarını substring ile alıp StringBuilder nesnesine
    * ekleyerek geri döndürmektedir.
    *
    *@param len Random oluşturulacak String uzunluğu
    *@return Random oluşturulan String nesnesi dönmektedir.
    */
    public String randomString(int len) {
    StringBuilder sb = new StringBuilder(len);
    for(int i = 0; i < len; i++) {
    int num = rnd.nextInt(alpha.length());
    sb.append(alpha.substring(num, num + 1));
    }
    return sb.toString();
    }

    }

     
  14. M

    August 5, 2011 at 22:35

    Kodda bir hata vardı ancak çalışma hatası değil. Aslında tam olarak ne demek istediğimi anlatamadım yorumda. static sınıf değişkenleri, bir sınıfın instance meydana getirildiğinde sadece bir kere oluşturulur. Yanlış hatırlamıyorsam, ikinci instance yine oluşturunca static sınıf değişkeni ikinci kez oluşturulmaz. Bu durumu debugging yaparak görmemiz daha iyi olur. Mesela sınıf değişkenleri genellikle final yapıldığında ayrıca static olarak da belirtilir. Çünkü hem değişmeyecek bir sınıf değişkenin sadece bir(1) kere oluşturulmasını sağlamak için. Bu sebeple Random nesnesini static ile static olmama ve seedin aynı yada olmama durumuna göre kodu bu şekilde yazmak istedim. Stackoverflow’da biraz araştırma sonucunda kodun bağlantısını yazdım. Kodun çıktısına baktığımızda static değişken Random rnd’ye bir kere seed verdikten sonra sonuçlar aynı dönmektedir. Sonuç olarak gerçekten random sayı oluşturmanın en iyi yolu default Random yapılandırıcısını static yapmadan kullanmakdır.

    import java.util.Random;

    /**
    * RandomTwoInstance class’s main purpose is to show usage difference of static
    * Random variable and Random variable with given same or different seeds.
    *
    *@author M
    *@created 05 Ağustos 2011 Cuma
    */
    public class RandomTwoInstance {

    /**
    * The main program for the RandomTwoInstance class
    *
    *@param args The command line arguments
    */
    public static void main(String[] args) {

    RandomTwoInstance twoInstance = new RandomTwoInstance();

    //seed is 5
    RandomClass object1 = twoInstance.new RandomClass(5);
    // random String length is 5
    String s1 = object1.randomString(5);
    String s10 = object1.randomString(5);
    System.out.println(“Random Object with seed 5 ” + s1);
    System.out.println(“Random Object with seed 5 with calling randomString method ” + s10);

    //seed is 5
    RandomClass object2 = twoInstance.new RandomClass(5);
    // random String length is 5
    String s2 = object2.randomString(5);
    System.out.println(“Random Object with seed 5 ” + s2);

    // random Seed 1
    RandomClass object3 = twoInstance.new RandomClass();
    //random String length is 5
    String s3 = object3.randomString(5);
    System.out.println(“Random Object with random seed ” + s3);

    //random Seed 2
    RandomClass object4 = twoInstance.new RandomClass();
    //random String length is 5
    String s4 = object4.randomString(5);
    System.out.println(“Random object with random seed ” + s4);

    RandomClassWithStatic object5 = new RandomClassWithStatic(6);
    //random String length is 5
    String s5 = object5.randomString(5);
    System.out.println(“Static Random object with seed 6 ” + s5);

    RandomClassWithStatic object6 = new RandomClassWithStatic(6);
    //random String length is 5
    String s6 = object6.randomString(5);
    System.out.println(“Static Random object with seed 6 ” + s6);

    RandomClassWithStatic object7 = new RandomClassWithStatic();
    //random String length is 5
    String s7 = object7.randomString(5);
    String s9 = object7.randomString(5);
    System.out.println(“Static Random object s7 ” + s7);
    System.out.println(“Static Random object s9 with calling randomString method ” + s9);

    RandomClassWithStatic object8 = new RandomClassWithStatic(6);
    //random String length is 5
    String s8 = object8.randomString(5);
    String s11 = object8.randomString(5);
    System.out.println(“Static Random object s8 with seed 6 ” + s8);
    System.out.println(“Static Random object s11 with seed 6 with calling randomString method ” + s11);

    }

    /**
    * Description of the Class
    *
    *@author M
    *@created 05 Ağustos 2011 Cuma
    */
    class RandomClass {
    final static String alpha = “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”;

    Random rnd = new Random();

    /**
    * Constructor for the RandomClass object
    */
    public RandomClass() { }

    /**
    * Constructor for the RandomClass object
    *
    *@param seed Description of the Parameter
    */
    public RandomClass(int seed) {
    this.rnd.setSeed(seed);
    }

    /**
    * http://stackoverflow.com/questions/41107/how-to-generate-a-random-alpha-numeric-string-in-java/157202#157202
    * StringBuilder nesnesi ve nextInt ile random bir sayı meydana getirip bu
    * sayı ile alpha String’in belirli kısımlarını substring ile alıp
    * StringBuilder nesnesine ekleyerek geri döndürmektedir.
    *
    *@param len Random oluşturulacak String uzunluğu
    *@return Random oluşturulan String nesnesi dönmektedir.
    */
    public String randomString(int len) {
    StringBuilder sb = new StringBuilder(len);
    for(int i = 0; i < len; i++) {
    int num = rnd.nextInt(alpha.length());
    sb.append(alpha.substring(num, num + 1));
    }
    return sb.toString();
    }

    }

    }

    /**
    * Description of the Class
    *
    *@author M
    *@created 05 Ağustos 2011 Cuma
    */
    class RandomClassWithStatic {

    final static String alpha = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    static Random rnd = new Random();

    /**
    * Constructor for the RandomClass object
    */
    public RandomClassWithStatic() { }

    /**
    * Constructor for the RandomClass object
    *
    *@param seed Description of the Parameter
    */
    public RandomClassWithStatic(int seed) {
    this.rnd.setSeed(seed);
    }

    /**
    * http://stackoverflow.com/questions/41107/how-to-generate-a-random-alpha-numeric-string-in-java/157202#157202
    * StringBuilder nesnesi ve nextInt ile random bir sayı meydana getirip bu
    * sayı ile alpha String'in belirli kısımlarını substring ile alıp
    * StringBuilder nesnesine ekleyerek geri döndürmektedir.
    *
    *@param len Random oluşturulacak String uzunluğu
    *@return Random oluşturulan String nesnesi dönmektedir.
    */
    public String randomString(int len) {
    StringBuilder sb = new StringBuilder(len);
    for(int i = 0; i < len; i++) {
    int num = rnd.nextInt(alpha.length());
    sb.append(alpha.substring(num, num + 1));
    }
    return sb.toString();
    }

    }

     

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: