Notes

High Performance Simulation using Java
=================================
The best way to decide which type of data structure to use in an application is to create some benchmarks that reflect how the structure is used in the application
The ArrayList is a random access list, and the LinkedList is a sequential access list.
Position access is a linear-time operation in the sequential access list, and it is a constant-time operation in a random access list. However, the remove operation for the random access list is more expensive than for sequential access list.

The collections class in provides a shuffle method to randomize the order of objects in the List. The shuffle algorithm used in the implementation has a linear time complexity for random access lists and quadratic complexity for sequential access lists.
In order to avoid the expensive operation that would result from shuffling a sequential access list, the shuffle method converts the list into an array before executing shuffling and converts the shuffled array back into the list. Uses the random object provided in the shuffle call to shuffle the list.

Random in java is a psuedo-random number generator and is not 100% random.
It will repeat after 2^48 calls. (it uses a 48-bit seed) This means its not possible to produce every possible long or double using it.
If you want more randomness you can use SecureRandom with shuffle instead.
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.

Math.random has limited use generates - double between 0.0 & 1.0. It calls random.nextInt() twice under the hood. Is pre-synchronized like random.
ThreadlocalRandom is the right choice for single thread fastest access.

public Random() This constructor sets the seed of the random number generator to a value very likely to be distinct from any other invocation of this constructor. Uses a static volatile long seedUniquifier variable. Increments it and adds to system.nanotime to generate the seed.

The implementation of setSeed by class Random happens to use only 48 bits of the given seed. In general, however, an overriding method may use all 64 bits of the long argument as a seed value.
SetSeed method is synchronized. Seed itself is the atomic variable.

Random. protected int next(int bits) ==>
Subclasses should override this, as this is used by all other methods. So if its needed to change the behavior or algorithm behind random generation - overriding this method with the new algorithm will do it. Atomically generates the newseed from oldseed in a CAS loop and then generates the next random int using the new seed.

The algorithm used in random by default is a linear congruential pseudorandom number generator (LCG). LCGs are fast and require minimal memory (typically 32 or 64 bits) to retain state. This makes them valuable for simulating multiple independent streams.
LCGs should not be used for applications where high-quality randomness is critical. For example, it is not suitable for a Monte Carlo simulation because of the serial correlation (among other things).

Because class Random uses a seed with only 48 bits, this algorithm will not return all possible long or double values.
nextGaussian() - Returns the next pseudorandom, Gaussian ("normally") distributed double value with mean 0.0 and standard deviation 1.0 from this random number generator's sequence

Since Java 7 ThreadLocalRandom has been devised that allows for contention free use of random across multiple threads. ThreadLoacRandom.current() gives the T hreadLocalRandom instance for the calling thread.