scala.util.Random
object Random extends Random
The object Random
offers a default implementation of scala.util.Random and
random-related convenience methods.
Deprecated Value Members From scala.util.Random
final def isAlphaNum$1(c: Char): Boolean
Definition Classes
Annotations
Deprecated
(Since version 2.11.6) Preserved for backwards binary compatibility. To
remove in 2.12.x.
(defined at scala.util.Random)
Value Members From scala.util.Random
def alphanumeric: collection.immutable.Stream[Char]
Returns a Stream of pseudorandomly chosen alphanumeric characters, equally
chosen from A-Z, a-z, and 0-9.
(defined at scala.util.Random)
implicit def javaRandomToRandom(r: java.util.Random): Random
(defined at scala.util.Random)
def nextBytes(bytes: Array[Byte]): Unit
Generates random bytes and places them into a user-supplied byte array.
(defined at scala.util.Random)
def nextInt(n: Int): Int
Returns a pseudorandom, uniformly distributed int value between 0 (inclusive)
and the specified value (exclusive), drawn from this random number generator’s
sequence.
(defined at scala.util.Random)
def nextString(length: Int): String
Returns a pseudorandomly generated String. This routine does not take any
measures to preserve the randomness of the distribution in the face of factors
like unicode’s variable-length encoding, so please don’t use this for anything
important. It’s primarily intended for generating test data.
length
the desired length of the String
returns
Definition Classes
(defined at scala.util.Random)
def setSeed(seed: Long): Unit
(defined at scala.util.Random)
def shuffle[T, CC[X] <: TraversableOnce[X]](xs: CC[T])(implicit bf: CanBuildFrom[CC[T], T, CC[T]]): CC[T]
Returns a new collection of the same type in a randomly chosen order.
returns
Definition Classes
Random
(defined at scala.util.Random)
Full Source:
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala
package util
import scala.collection.mutable.ArrayBuffer
import scala.collection.generic.CanBuildFrom
import scala.collection.immutable. { List , Stream }
import scala.language. { implicitConversions , higherKinds }
/**
* @author Stephane Micheloud
*
*/
class Random ( val self : java.util.Random ) extends AnyRef with Serializable {
/** Creates a new random number generator using a single long seed. */
def this ( seed : Long ) = this ( new java . util . Random ( seed ))
/** Creates a new random number generator using a single integer seed. */
def this ( seed : Int ) = this ( seed . toLong )
/** Creates a new random number generator. */
def this () = this ( new java . util . Random ())
/** Returns the next pseudorandom, uniformly distributed boolean value
* from this random number generator's sequence.
*/
def nextBoolean () : Boolean = self . nextBoolean ()
/** Generates random bytes and places them into a user-supplied byte
* array.
*/
def nextBytes ( bytes : Array [ Byte ]) { self . nextBytes ( bytes ) }
/** Returns the next pseudorandom, uniformly distributed double value
* between 0.0 and 1.0 from this random number generator's sequence.
*/
def nextDouble () : Double = self . nextDouble ()
/** Returns the next pseudorandom, uniformly distributed float value
* between 0.0 and 1.0 from this random number generator's sequence.
*/
def nextFloat () : Float = self . nextFloat ()
/** 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.
*/
def nextGaussian () : Double = self . nextGaussian ()
/** Returns the next pseudorandom, uniformly distributed int value
* from this random number generator's sequence.
*/
def nextInt () : Int = self . nextInt ()
/** Returns a pseudorandom, uniformly distributed int value between 0
* (inclusive) and the specified value (exclusive), drawn from this
* random number generator's sequence.
*/
def nextInt ( n : Int ) : Int = self . nextInt ( n )
/** Returns the next pseudorandom, uniformly distributed long value
* from this random number generator's sequence.
*/
def nextLong () : Long = self . nextLong ()
/** Returns a pseudorandomly generated String. This routine does
* not take any measures to preserve the randomness of the distribution
* in the face of factors like unicode's variable-length encoding,
* so please don't use this for anything important. It's primarily
* intended for generating test data.
*
* @param length the desired length of the String
* @return the String
*/
def nextString ( length : Int ) = {
def safeChar () = {
val surrogateStart : Int = 0xD800
val res = nextInt ( surrogateStart - 1 ) + 1
res . toChar
}
List . fill ( length )( safeChar ()). mkString
}
/** Returns the next pseudorandom, uniformly distributed value
* from the ASCII range 33-126.
*/
def nextPrintableChar () : Char = {
val low = 33
val high = 127
( self . nextInt ( high - low ) + low ). toChar
}
def setSeed ( seed : Long ) { self . setSeed ( seed ) }
/** Returns a new collection of the same type in a randomly chosen order.
*
* @return the shuffled collection
*/
def shuffle [ T , CC [ X ] <: TraversableOnce [ X ]]( xs : CC [ T ])( implicit bf : CanBuildFrom [ CC [ T ] , T , CC [ T ]]) : CC [ T ] = {
val buf = new ArrayBuffer [ T ] ++= xs
def swap ( i1 : Int , i2 : Int ) {
val tmp = buf ( i1 )
buf ( i1 ) = buf ( i2 )
buf ( i2 ) = tmp
}
for ( n <- buf . length to 2 by - 1 ) {
val k = nextInt ( n )
swap ( n - 1 , k )
}
( bf ( xs ) ++= buf ). result ()
}
@deprecated ( "Preserved for backwards binary compatibility. To remove in 2.12.x." , "2.11.6" )
final def `scala$util$Random$$isAlphaNum$1` ( c : Char ) = ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) || ( c >= '0' && c <= '9' )
/** Returns a Stream of pseudorandomly chosen alphanumeric characters,
* equally chosen from A-Z, a-z, and 0-9.
*
* @since 2.8
*/
def alphanumeric : Stream [ Char ] = {
def nextAlphaNum : Char = {
val chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
chars charAt ( self nextInt chars . length )
}
Stream continually nextAlphaNum
}
}
/** The object `Random` offers a default implementation
* of scala.util.Random and random-related convenience methods.
*
* @since 2.8
*/
object Random extends Random {
implicit def javaRandomToRandom ( r : java.util.Random ) : Random = new Random ( r )
}