scala.util.Random
class Random extends Serializable
Deprecated Value Members From scala.util.Random
final def isAlphaNum$1(c: Char): Boolean
Annotations
Deprecated
(Since version 2.11.6) Preserved for backwards binary compatibility. To
remove in 2.12.x.
(defined at scala.util.Random)
Instance Constructors From scala.util.Random
new Random()
Creates a new random number generator.
(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)
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
(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
the shuffled collection
(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 )
}