一个as3工具类

public final class Random
public static function get boolean() : Boolean
public static function get wave() : int
public static function get color() : uint

public static function integet(num : int) : int
public static function number(num : int) : Number
public static function char(…args) : String
public static function string(num : int) : String

public static function intRange(n1 : uint, n2 : uint) : int
public static function numRange(n1 : Number, n2 : Number) : Number
public static function charRange(s1 : String, s2 : String) : String

public static function intRanges(…args) : int
public static function numRanges(…args) : Number
public static function charRanges(…args) : String
public static function strRanges(num : uint,…args) : String
public static function colorRanges(r1:uint=0, r2:uint=255, g1:uint=0, g2:uint=255, b1:uint=0, b2:uint=255) : uint

public static function disorder(arr : Array) : Array
public static function takeOut(num : uint, arr : Array) : Array
public static function find(num : uint, arr : Array) : Array
_____________________________________________________________

Random.boolean : Boolean
随机获取一个布尔值，true或者false

Random.ware : int
随机获取一个波形值，1或者-1

Random.color : uint
随机获得一个32位色颜色代码

Random.integet(num:int) : int
随机获得0~num的整数，其中不包括num

Random.number(num:int) : Number
随机获得0~num的双精度浮点小数，其中不包括num

Random.char(…args) : String
随机获得所有指定参数中的任何一个字符

Random.string(num:int) : String
随机获得一个指定长度的字符串，范围是26个大小字母和10个数字

Random.intRange(n1:uint, n2:uint) : uint
随机获得一个指定范围内的整数N，并且 较小数 <= N < 较大数

Random.numRange(n1: Number, n2: Number) : uint
随机获得一个指定范围内的双精度浮点小数N，并且 较小数 <= N < 较大数

Random.charRange(n1:Stirng, n2:Stirng) : String
随机获得一个指定范围内的字符N，包括两个范围界线的字符

Random.intRanges(…args) : int
随机获得多个指定范围内的整数，参数成双输入，若出现奇数个参数则报错
如 Random.intRanges(4,8,12,20,45,70); 则返回4~8,12~20,45~70之间的任何一个整数，获得的随机数界限标准可参考 Random.intRange(n1:int, n2:int)

Random.numRanges(…args) : Number
同Random.intRanges(…args),只是返回的类型是双精度浮点

Random.charRanges(…args) : String
随机获得多个指定范围内的字符，参数成双输入，若出现奇数个参数则报错
如 Random.intRanges(4,8,12,20,45,70); 则可能返回4~8,12~20,45~70之间的任何一个整数，获得的随机数界限标准可参考 Random.charRange(n1:Stirng, n2: Stirng)

Random.strRanges(num:uint, …args) : String
随机获得指定长度的多个指定范围内的字符串，参考Random.charRanges(…args)

Random.colorRanges(r1:uint=0, r2:uint=255, g1:uint=0, g2:uint=255, b1:uint=0, b2:uint=255) : uint
随机获得特殊要求的颜色，如随机返回一个偏红的颜色值：
Random.colorRanges (153,255,0,100,0,100);

Random.disorder(arr:Array) : Array
随机打乱数组，并返回(是否使用返回又实际需求决定)

Random.takeOut(num:uint, arr:Array) : Array
随机从原数组中取出指定个数的元素，并且在原数组中删除它们。从表面上看此函数功能与Random.find函数相同，但是Random.find不修改原数组，效率更高，此方法在需要删除随机选中的元素时使用更为妥当。

Random.find(num:uint, arr:Array) : Array
随机从原数组中取出指定个数的元素，在新数组中返回。

package {
 
	public final class Random {
		public static function get boolean() : Boolean {
			return Math.random() < .5;
		}
 
		public static function get wave() : int {
			return Math.random() < .5 ? -1 : 1;
		}
 
		public static function get color() : uint {
			return Math.random() * 16777216;
		}
 
		public static function integet(num : int) : int {
			return Math.random() * num;
		}
 
		public static function number(num : int) : Number {
			return Math.random() * num;
		}
 
		public static function char(...args) : String {
			return args[int(Math.random() * args.length)];
		}
 
		public static function string(num : int) : String {
			for (var i : uint = 0,src : String = "";i < num;i++) {
				src += charRanges("0", "9", "A", "Z", "a", "z");
			}
			return src;
		}
 
		public static function intRange(n1 : uint, n2 : uint) : uint {
			return Math.random() * (n2 - n1) + n1;
		}
 
		public static function numRange(n1 : Number, n2 : Number) : Number {
			if (n1 < 0 || n2 < 0) {
				throw new Error("参数错误：不可为负数。");
			}
			return Math.random() * (n2 - n1) + n1;
		}
 
		public static function charRange(s1 : String, s2 : String) : String {
			var n1 : uint = s1.charCodeAt(0),n2 : uint = s2.charCodeAt(0);
			return String.fromCharCode(int(Math.random() * (n2 - n1)) + n1);
		}
 
		public static function intRanges(...args) : int {
			var n1s : Array = new Array();
			var n2s : Array = new Array();
			while (args.length) {
				n1s.push(args.shift());
				n2s.push(args.shift());
			}
			var len : uint = n1s.length;
			var s1 : uint = 0, s2 : uint = 0;
			for (var i : uint = 0;i < len; i++) {
				s1 += n1s[i];
				s2 += n2s[i];
			}
			var r : int = Math.random() * (s2 - s1) + n1s[0];
			i = 0;
			while (r >= n2s[i++]) {
				r += n1s[i] - n2s[i - 1];
			}
			return r;
		}
 
		public static function numRanges(...args) : Number {
			var n1s : Array = new Array();
			var n2s : Array = new Array();
			while (args.length) {
				n1s.push(args.shift());
				n2s.push(args.shift());
			}
			var len : uint = n1s.length;
			var s1 : uint = 0, s2 : uint = 0;
			for (var i : uint = 0;i < len; i++) {
				s1 += n1s[i];
				s2 += n2s[i];
			} 
			do {
				var r : Number = Math.random() * (s2 - s1) + n1s[0];
				i = 0;
				while (r >= n2s[i++]) {
					r += n1s[i] - n2s[i - 1];
				}
			} while (isNaN(r));
			return r;
		}
 
		public static function charRanges(...args) : String {
			var n1s : Array = new Array();
			var n2s : Array = new Array();
			while (args.length) {
				n1s.push(args.shift().charCodeAt(0));
				n2s.push(args.shift().charCodeAt(0) + 1);
			}
			var len : uint = n1s.length;
			var s1 : uint = 0, s2 : uint = 0;
			for (var i : uint = 0;i < len; i++) {
				s1 += n1s[i];
				s2 += n2s[i];
			}
			var r : int = Math.random() * (s2 - s1) + n1s[0];
			i = 0;
			while (r >= n2s[i++]) {
				r += n1s[i] - n2s[i - 1];
			}
			return String.fromCharCode(r);
		}
 
		public static function strRanges(num : uint,...args) : String {
			var n1s : Array = new Array();
			var n2s : Array = new Array();
			while (args.length) {
				n1s.push(args.shift().charCodeAt(0));
				n2s.push(args.shift().charCodeAt(0) + 1);
			}
			var len : uint = n1s.length;
			var s1 : uint = 0, s2 : uint = 0;
			for (var i : uint = 0;i < len; i++) {
				s1 += n1s[i];
				s2 += n2s[i];
			}
			var src : String = "";
			while (num-- > 0) {
				var r : int = Math.random() * (s2 - s1) + n1s[0];
				i = 0;
				while (r >= n2s[i++]) {
					r += n1s[i] - n2s[i - 1];
				}
				src += String.fromCharCode(r);
			}
			return src;
		}
 
		public static function colorRanges(...args) : uint {
			return intRange(args[0], args[1] + 1) << 16 + intRange(args[2], args[3] + 1) << 8 + intRange(args[4], args[5] + 1);
		}
 
		public static function disorder(arr : Array) : Array {
			var len : uint = arr.length;
			var cache : *,ti : uint;
			for (var i : uint = 0;i < len;i++) {
				ti = int(Math.random() * len);
				cache = arr[i];
				arr[i] = arr[ti];
				arr[ti] = cache;
			} 
			while (--i >= 0) {	
				ti = int(Math.random() * len);
				cache = arr[i];
				arr[i] = arr[ti];
				arr[ti] = cache;
			}
			return arr;
		}
 
		public static function takeOut(num : uint,arr : Array) : Array {
			var newArr : Array = new Array(num);
			for (var i : uint = 0;i < num; i++) {
				newArr.push(arr.splice(int(Math.random() * arr.length)), 1);
			}
			return newArr;
		}
 
		public static function find(num : uint, arr : Array) : Array {
			var newArr : Array = arr.concat();
			var cache : *,ti : uint, len : uint = arr.length;
			for (var i : uint = 0;i < num; i++) {
				ti = int(Math.random() * len);
				cache = newArr[i];
				newArr[i] = newArr[ti];
				newArr[ti] = cache;
			}
			return newArr.splice(0, num);
		}
	}
}