Get random boolean in Java

Question

Okay, I implemented this SO question to my code: Return True or False Randomly

But, I have strange behavior: I need to run ten instances simultaneously, where every

Answer 1

Words in a text are always a source of randomness. Given a certain word, nothing can be inferred about the next word. For each word, we can take the ASCII codes of its letters, add those codes to form a number. The parity of this number is a good candidate for a random boolean.

Possible drawbacks:

1. this strategy is based upon using a text file as a source for the words. At some point, the end of the file will be reached. However, you can estimate how many times you are expected to call the randomBoolean() function from your app. If you will need to call it about 1 million times, then a text file with 1 million words will be enough. As a correction, you can use a stream of data from a live source like an online newspaper.

2. using some statistical analysis of the common phrases and idioms in a language, one can estimate the next word in a phrase, given the first words of the phrase, with some degree of accuracy. But statistically, these cases are rare, when we can accuratelly predict the next word. So, in most cases, the next word is independent on the previous words.

   package p01;

   import java.io.File; import java.nio.file.Files; import java.nio.file.Paths;

   public class Main {

   String words[];
   int currentIndex=0;
   
   public static String readFileAsString()throws Exception 
     { 
       String data = ""; 
       File file = new File("the_comedy_of_errors");
       //System.out.println(file.exists());
       data = new String(Files.readAllBytes(Paths.get(file.getName()))); 
       return data; 
     } 
   
   public void init() throws Exception
   {
       String data = readFileAsString(); 
       words = data.split("\\t| |,|\\.|'|\\r|\\n|:");
   }
   
   public String getNextWord() throws Exception
   {
       if(currentIndex>words.length-1)
           throw new Exception("out of words; reached end of file");
   
       String currentWord = words[currentIndex];
       currentIndex++;
   
       while(currentWord.isEmpty())
       {
           currentWord = words[currentIndex];
           currentIndex++;
       }
   
       return currentWord;
   }
   
   public boolean getNextRandom() throws Exception
   {
       String nextWord = getNextWord();
       int asciiSum = 0;
   
       for (int i = 0; i < nextWord.length(); i++){
           char c = nextWord.charAt(i);        
           asciiSum = asciiSum + (int) c;
       }
   
       System.out.println(nextWord+"-"+asciiSum);
   
       return (asciiSum%2==1) ;
   }
   
   public static void main(String args[]) throws Exception
   {
       Main m = new Main();
       m.init();
       while(true)
       {
           System.out.println(m.getNextRandom());
           Thread.sleep(100);
       }
   }
   

   }

In Eclipse, in the root of my project, there is a file called 'the_comedy_of_errors' (no extension) - created with File> New > File , where I pasted some content from here: http://shakespeare.mit.edu/comedy_errors/comedy_errors.1.1.html

Answer 2

you could get your clock() value and check if it is odd or even. I dont know if it is %50 of true

And you can custom-create your random function:

static double  s=System.nanoTime();//in the instantiating of main applet
public static double randoom()
{

s=(double)(((555555555* s+ 444444)%100000)/(double)100000);


    return s;
}

numbers 55555.. and 444.. are the big numbers to get a wide range function please ignore that skype icon :D

Answer 3

Java 8: Use random generator isolated to the current thread: ThreadLocalRandom nextBoolean()

Like the global Random generator used by the Math class, a ThreadLocalRandom is initialized with an internally generated seed that may not otherwise be modified. When applicable, use of ThreadLocalRandom rather than shared Random objects in concurrent programs will typically encounter much less overhead and contention.

java.util.concurrent.ThreadLocalRandom.current().nextBoolean();

Answer 4

You can also make two random integers and verify if they are the same, this gives you more control over the probabilities.

Random rand = new Random();

Declare a range to manage random probability. In this example, there is a 50% chance of being true.

int range = 2;

Generate 2 random integers.

int a = rand.nextInt(range);
int b = rand.nextInt(range);

Then simply compare return the value.

return a == b; 

I also have a class you can use. RandomRange.java