not reusing Random object throughout multiple Generex.random() calls causes frequent duplicates about generex HOT 3 CLOSED

However the following works ok:

for (int i = 0; i < 100; i++) {
            // given
            Generex generex = new Generex("([0-9]){5}");

            // when
            Iterator iterator = generex.iterator();
            Stream<String> ids = Stream.generate(() -> iterator.next()).limit(100);

            // then
            Assertions.assertThat(ids.distinct().count()).isEqualTo(100);
        }

Is it that this is the only recommended way to generate random sequences?

from generex.

the behavior of the first code is normal , and the test will very likely failed , so let's talk probability :) :

you're using this pattern "([0-9]){5}", then the set of data contains 10^5 elements. So when we take 100 random elements , the probability of getting 100 distinct elements is equal to :

(10^5-100)/10^5 = 99/100

and you are using a loop that repeat the code 100 times , the test will be OK if in all case you got 100 distinct elements , this means that the probability of getting passed test is

(99/100)^100 ~ 0.37

the second code pass the test because the iterator is used to iterate in lexicographical order over possible string that matches your pattern , so it will not return the same string two time.

from generex.

Thanks for rapid feedback and your kind help.

Yes, doing math leads to 99.9% probability for uniqueness. However empirically I get ~95% with the following test:

@Test
    public void generatesUniqueSequence() throws Exception {
        int sequenceLength = 100;
        int tries = 100000;
        int successCounter = 0;
        for (int i = 0; i < tries; i++) {
            Generex generex = new Generex("([0-9]){5}");
            Stream<String> ids = Stream.generate(() -> generex.random()).limit(sequenceLength);
            if (ids.distinct().count() == sequenceLength) {
                successCounter++;
            }
        }
        Assertions.assertThat(successCounter).isEqualTo(tries);
    }

For "([0-9]){6}" according to math it's 99.99% while empirically I get ~99.51% with the above test.

from generex.