一创建数组
Array 构造函数的使用有三种方式。
1 空数组。用 Array 类的 length 属性来验证数组是否不包含元素。
var names:Array = new Array();
trace(names.length); // 0
2. 初始化数组长度，其长度 0 和 4,294,967,295 之间的无符号整数。
var names:Array = new Array(3);
trace(names.length); // 输出：3
trace(names[0]); // 输出：undefined
trace(names[1]); // 输出：undefined
trace(names[2]); // 输出：undefined
3.初始化构造。
var names:Array = new Array("John", "Jane", "David");
trace(names.length); // 输出：3
trace(names[0]); // 输出：John
trace(names[1]); // 输出：Jane
trace(names[2]); // 输出：David
也可以创建具有数组文本或对象文本的数组。将数组文本直接分配给数组变量，如：
var names:Array = ["John", "Jane", "David"];
二插入数组元素方法：
push()、unshift() 和 splice()
push() 用于在数组末尾添加一个或多个元素。
unshift() 用于在数组开头插入一个或多个元素，在索引号 0 处插入。
splice() 用于在数组中的指定索引处插入任意数目的项目。
如：
var planets:Array = new Array();
planets.push("Mars"); // 数组内容：Mars
planets.unshift("Mercury"); // 数组内容：Mercury,Mars
planets.splice(1, 0, "Venus", "Earth");
传递给 splice() 的第一个参数是整数 1，它用于指示从索引 1 处开始插入。
传递给 splice() 的第二个参数是整数 0，它表示不应删除任何项。
传递给 splice() 的第三和第四个参数 Venus 和 Earth 为要插入的项。
push() ，unshift() 方法均返回一个无符号整数，它们表示修改后的数组长度。
在用于插入元素时，splice() 方法返回空数组，
通过使用 splice() 方法，不仅可以将元素插入到数组中，而且还可以从数组中删除元素。
用于删除元素时，splice() 方法将返回包含被删除元素的数组。
三删除数组元素
pop()、shift() 和 splice()
pop() 方法用于从数组末尾删除一个元素。
shift() 方法用于从数组开头删除一个元素，始终删除索引号 0 处的元素。
splice() 方法既可用来插入元素，也可以删除任意数目的元素，其操作的起始位置位于由发送到此方法的第一个参数指定的索引号处。
如：
var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", "Huron"];
oceans.splice(2, 2, "Arctic", "Atlantic"); // 替换 Aral 和 Superior，
oceans.pop(); // 删除 Huron
oceans.shift(); // 删除 Victoria
pop() 和 shift() 方法均返回已删除的项。由于数组可以包含任意数据类型的值，
splice() 方法将返回包含被删除值的数组。
var lakes:Array = oceans.splice(2, 2, "Arctic", "Atlantic");
trace(lakes); // 输出：Aral,Superior
delete 运算符用于将数组元素的值设置为 undefined，但它不会从数组中删除元素。长度不变。
var oceans:Array = ["Arctic", "Pacific", "Victoria", "Indian", "Atlantic"];
delete oceans[2];
trace(oceans); // 输出：Arctic,Pacific,,Indian,Atlantic
trace(oceans[2]); // 输出：undefined
trace(oceans.length); // 输出：5
数组的length具有截断功能，将数组的 length 属性设置为小于数组当前长度的值，
则会截断数组，索引号高于 length 的新值减 1 处所存储的任何元素将被删除。
如：
var oceans:Array = ["Arctic", "Pacific", "Victoria", "Aral", "Superior"];
oceans.length = 2;
trace(oceans); // 输出：Arctic,Pacific
四对数组排序
reverse()、sort() 和 sortOn()
reverse() 倒序排列
sort() 按照多种预定义的方式对数组进行排序，甚至可用来创建自定义排序算法。
sortOn() 方法可用来对对象的索引数组进行排序，这些对象具有一个或多个可用作排序键的公共属性。
sort() 方法按照"默认排序顺序"重新安排数组中的元素。默认排序顺序具有以下特征：
排序区分大小写，也就是说大写字符优先于小写字符。例如，字母 D 优先于字母 b。
排序按照升序进行，也就是说低位字符代码（例如 A）优先于高位字符代码（例如 B）。
排序将相同的值互邻放置，并且不区分顺序。
排序基于字符串，也就是说，在比较元素之前，先将其转换为字符串（例如，10 优先于 3，
因为相对于字符串 "3" 而言，字符串 "1" 具有低位字符代码）。
您也许需要不区分大小写或者按照降序对数组进行排序，或者您的数组中包含数字，
从而需要按照数字顺序而非字母顺序进行排序。
sort() 方法具有 options 参数，可通过该参数改变默认排序顺序的各个特征。
options 是由 Array 类中的一组静态常量定义的，如以下列表所示：
Array.CASEINSENSITIVE：此选项可使排序不区分大小写。例如，小写字母 b 优先于大写字母 D。
Array.DESCENDING：用于颠倒默认的升序排序。例如，字母 B 优先于字母 A。
Array.UNIQUESORT：如果发现两个相同的值，此选项将导致排序中止。
Array.NUMERIC：这会导致排序按照数字顺序进行，比方说 3 优先于 10。
如：
var poets:Array = ["Blake", "cummings", "Angelou", "Dante"];
poets.sort(); // 默认排序
trace(poets); // 输出：Angelou,Blake,Dante,cummings
poets.sort(Array.CASEINSENSITIVE);
trace(poets); // 输出：Angelou,Blake,cummings,Dante
poets.sort(Array.DESCENDING);
trace(poets); // 输出：cummings,Dante,Blake,Angelou
poets.sort(Array.DESCENDING | Array.CASEINSENSITIVE); // 使用两个选项
trace(poets); // 输出：Dante,cummings,Blake,Angelou
可以编写自定义排序函数，然后将其作为参数传递给 sort() 方法。
如，以下按第二个单词排序，而不是第一个单词排序
以下代码展示如何编写自定义排序函数，函数内部可以不理会。
var names:Array = new Array("John Q. Smith", "Jane Doe", "Mike Jones");
function orderLastName(a, b):int
{
var lastName:RegExp = /\b\S+$/;
var name1 = a.match(lastName);
var name2 = b.match(lastName);
if (name1 < name2)
{
return -1;
}
else if (name1 > name2)
{
return 1;
}
else
{
return 0;
}
}
trace(names); // 输出：John Q. Smith,Jane Doe,Mike Jones
names.sort(orderLastName);
trace(names); // 输出：Jane Doe,Mike Jones,John Q. Smith
说明下：
自定义函数作为参数传入sort。其自定义参数必须有2个参数组成。
因为它每次对两个数组元素进行操作。排序函数的返回值指示应如何对元素排序：
返回值 -1 表示第一个参数 a 优先于第二个参数 b。
返回值 1 表示第二个参数 b 优先于第一个参数 a。
返回值为 0 表示元素具有相同的排序优先级。
sortOn() 方法是为对象数组而使用。
对象元素中应具有一个可用作排序键的公共属性。
如以下数组中的元素是由对象组成。
以下对象中以姓和年份组成。
var poets:Array = new Array();
poets.push({name:"Angelou", born:"1928"});
poets.push({name:"Blake", born:"1757"});
poets.push({name:"cummings", born:"1894"});
poets.push({name:"Dante", born:"1265"});
poets.push({name:"Wang", born:"701"});
使用 sortOn() 方法，按born 属性对数组进行排序。
sortOn() 带两个参数 fieldName 和 options。
如，使用两个参数 "born" 和 Array.NUMERIC 来调用 sortOn()。
Array.NUMERIC 参数用于确保按照数字顺序进行排序，
poets.sortOn("born", Array.NUMERIC);
for (var i:int = 0; i < poets.length; ++i)
{
trace(poets[i].name, poets[i].born);
}
/* 输出：
Wang 701
Dante 1265
Blake 1757
cummings 1894
Angelou 1928
*/
当在sort() 和 sortOn()中使用
Array.RETURNINDEXEDARRAY 常量作为 options 参数。
会对数组排序而又不修改现有数组。
如：
var indices:Array;
//indices 为poets元素排序后的元素索引数组，
indices = poets.sortOn("born", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
for (var i:int = 0; i < indices.length; ++i)
{
var index:int = indices[i];
trace(poets[index].name, poets[index].born);
}
五查询数组
concat()、join()、slice()，toString()
concat() 和 slice() 方法返回新数组
join() 和 toString() 方法返回字符串。
concat() 方法将新数组和元素列表作为参数，并将其与现有数组结合起来创建新数组。
slice() 方法具有两个名为 startIndex 和 endIndex 的参数，
并返回被数组分离出来的元素数组。
分离从 startIndex 处的元素开始，到 endIndex 处的前一个元素结束。
如：
var array1:Array = ["alpha", "beta"];
var array2:Array = array1.concat("gamma", "delta");
trace(array2); // 输出：alpha,beta,gamma,delta
var array3:Array = array1.concat(array2);
trace(array3); // 输出：alpha,beta,alpha,beta,gamma,delta
var array4:Array = array3.slice(2,5);
trace(array4); // 输出：alpha,beta,gamma
join() 和 toString() 方法查询数组，并将其内容作为字符串返回。
join() 方法不带参数，则与toString同，返回所有元素的列表（以逗号分隔）的字符串。
join() 方法带参数； 即返回字符串以参数为分隔符
如：
var rivers:Array = ["Nile", "Amazon", "Yangtze", "Mississippi"];
var riverCSV:String = rivers.toString();
trace(riverCSV); // 输出：Nile,Amazon,Yangtze,Mississippi
var riverPSV:String = rivers.join("+");
trace(riverPSV); // 输出：Nile+Amazon+Yangtze+Mississippi
join() 方法中，如果数组中存在嵌套数组，则按默认方式处理，
如
var nested:Array = ["b","c","d"];
var letters:Array = ["a",nested,"e"];
var joined:String = letters.join("+");
trace(joined); // 输出：a+b,c,d+e