我也水一个读书笔记！Array 数组

我也水一个读书笔记！Array 数组

Array 数组

来源：http://bbs.actionscript3.cn/thread-1635-1-3.html
声名数组:例

var a:Array;//声名一个a数组,但没有告诉a这个引用指向. trace (a);//得到null

var b:Array=[];//声名一个空数组b,trace(b);//得到空白显示

var c:Array=new Array();//等同b

(var b:Array=["01","02"];trace(b);//输出01,02)(var b:Array=new Array("01","02");trace(b);//输01,02)

var d:Array=new Array(5);//声名一个长度为5的空数组

访问数组元素:

索引方式:0开始-N 例:var foo:Array=["1","2","3"];trace(foo[0]);//输出1

数组的长度:

数组的长度(length)属性不是创建好就固定不变的,数组的长度可以随着成员的增加删除而变化,length是uint型,即非负整数.

实现方式:public function get length():uint 或 public function set length(value:uint):void 例:trace(foo.length);

Object 及关联数组:

实现方式:var foo:Object=new Object();或var foo:Object={};

实例(1):var foo:Object={name:"haishabei",web:"haishabei.net"};trace(foo.name); //输出haishabei

实例(2):

var bar :Object={hello:function (){trace("haishabei");},ok:function():String{return "haishabei-net";}};
bar.hello();//输出haihsabei
trace(bar.ok());//输出haihsabei-net

实例(3):

//先初始化，之后在新增属性和动态添加方法
var kk:Object={};
kk.name="haishabei";
kk.hello=function (){
trace(".net")
};
trace(kk.name);//输出haishabei
trace(kk["name"]);//输出haishabei
kk.hello();//输出.net

多维数组(嵌套数组)

例:

//直接用中括号嵌套来创建多维数组
var tt1:Array=[[1,2,3],[4,5,6],[7,8,9]];
trace(tt1[2]);//输出7,8,9
trace(tt1[2][1]);//输出8

//使用构造函数来创建多维数组
var tt2:Array=new Array(new Array(1,2,3),new Array(4,5,6),new Array(7,8,9));
trace(tt2[2][1]);//输出8

//先定义数组长度,再一一添加子数组
var tt3:Array=new Array(3);
tt3[0]=[1,2,3];
tt3[1]=[4,5,6];
tt3[2]=[7,8,9];
trace(tt3[2][1]);//输出8

数组Array 的基本操作:

1>查找:indexOf、lastIndexOf(indexOf是从左到右查找,lastIndexOf是从右到左,如果找到返回索引值,找不到返回-1)

用法格式:

目标数组.indexOf(要查找的元素);

目标数组.indexOf(要查找的元素,查找的起始位置);

目标数组.lastIindexOf(要查找的元素);

目标数组.lastIndexOf(要查找的元素,查找的起始位置);

2>在数组首尾新增元素:push、unshift(这2种方法都有返回值,返回值是增加元素后的数组长度)

用法格式:

数组.push(元素1,元素2,...元素N);//在数组首

数组.unshift(元素1,元素2,...元素N);//在数组尾

3>删除数组首尾元素:shift、pop(这2种方法都有返回值,返回值就是那个被删除的元素)

用法格式:

数组.pop();//删除尾部

数组.shift();//删除头部

4>在数组中插入或删除元素:灵活多变的splice(返回值是被删除的元素)

用法格式:

//(1)从数组没位置开始,删除指定数目的元素,并插入一些新元素.

数组.splice(删除点的索引,要删除的元素的数目,新增元素1,...新增元素N);

//(2)删除数组中某位置之后的几个元素.

数组.splice(删除点的索引,要删除的元素的数目);

//(3)删除数组中某位置之后的所有元素

数组.splice(删除点的索引);

//(4)在数组中某位置之后,插入新元素

数组.splice(删除点的索引,0,新增元素1,...新增元素N);

5>获取数组中的部分元素:slice

(可以获取数组中连续的元素,而不改变原有数组的内容,slice的返回值是截取的元素组成的新数组,新数组中包括起点索引的元素,而不包括终点索引的元素)

用法:数组.slice(起点索引,终点索引);

数组.slice(起点索引);//返回包括起点索引的元素和之后的全部元素组成的新数组.

6>将多个元素或数组拼合成新数组:concat

(可以将多个元素或数组拼合成一个新数组,并且且通过返回值返回,不改变原有数组内容)

用法:数组.concat( 参数 1, 参数 2,... 参数 N);

例:var foo:Array=["A","B","C"];

var bar1:int=1;

var bar2:Array=[2,3,4,5];

var newfoo=foo.concat(bar1,bar2);

trace(newfoo); //A,B,C,1,2,3,4,5

*******
(到这发现个 问题 :var bar2:Array=[2,3,4,5];这么写没 问题 ,而var foo:Array=[A,B,C];这样则报错,

这是因为var foo:Array=[A,B,C]中的三个元素全部被看成变量,但是这三个变量都未声明.//因为默认下除了数字能自动转化为数字类型外,字符是默认看成变量的.)
*******

7>浅复制与深复制

[1]当数组元素全部是基元数据类型,即全都是值类型.没有深浅复制的分别.

[2]当数组元素全是复杂数据类型,即引用类型.分深浅复制.

----------------------------------------------------------------------------

1.生成浅复制只需要原数组的slice方法或concat方法不传任何参数.即可生成浅复制.

方法:var copy:Array=tt.concat();或var copy:Array=tt.slice();

*****

使用浅复制生成的新数组,其各个元素存放的只是引用.两个数组中相同位置的元素存放的引用指向同一个 对象 .那么
,如果对该元素操作,就等于是操作引用指向的对象.如果该对象状态发生变化,那么也会影响到另一个数组中相对应的元素.

*****

例(1)
var ob:Object={name:"haishabei",web:"haishabei.net"};
var obb:Array=[1,2,3];
var foo:Array=["456j",obb,ob];
//var bar:Array=foo.slice();
var bar=foo.slice();
trace(foo);//456j,1,2,3,[object Object]
trace(bar);//456j,1,2,3,[object Object]
bar[0]="ttttt";
bar[1][0]=150;
bar[2].name="0000000h";
trace(foo);//456j,150,2,3,[object Object]
trace(bar);//ttttt,150,2,3,[object Object]
trace(foo[2].name);//0000000h
trace(bar[2].name);//0000000h

---------------------------------------------------------------------------------------
2.深复制:使用深复制生成的新数组,其所有元素都是真正的原数组元素的备份.这时两个数组中相同位置的元素,存放的是不同的引用,
指向不同的对象.但是这两个对象的状态是完全一致的.

例(2)

var ob:Object={name:"haishabei",web:"haishabei.net"};
var obb:Array=[1,2,3];
var foo:Array=["456j",obb,ob];

//下4行深复制数组foo
var fooBA:ByteArray= new ByteArray();
fooBA.writeObject(foo);
fooBA.position=0;
var bar:Array=fooBA.readObject() as Array;
trace(foo);//456j,1,2,3,[object Object]
trace(bar);//456j,1,2,3,[object Object]
bar[0]="www";
bar[1][0]=150;
bar[2].web=".com";
trace(foo);//456j,1,2,3,[object Object]
trace(bar);//www,150,2,3,[object Object]
trace(foo[2].web);//haishabei.net
trace(bar[2].web);//.com

8>排序:reverse、sort、sortOn

[1]reverse 方法能将数组元素倒序,返回新数组.用法:数组.reverse();

[2]sort方法是对数组元素排序.有3种方法.

[2][1]数组.sort();//默认排序

[2][2]数组.sort(排列方式);//使用"排序方式"参数来排序,排列方式是一些定义好的整数常量

[2][3]数组.sort(比较函数);//使用自定义的比较函数,注意此处只写函数名即可.

当数组元素是复杂数据型,且需要根据这种对象的某个属性值来排序时就需要sortOn方法.

数组.sortOn("name");//根据指定属性,默认排序.

数组.sortOn("name",排序方式);//根据指定属性,使用指定的"排序方式"来排序.

数组.sortOn("name",比较函数);//根据指定属性,使用自定义函数排序.

[2][1]默认排序sort();//默认排序是按照字符串字母顺序的,返回值是排序后的数组./*如果数组中的元素是数值,默认排序也会把它当成字符串来排序*/

例:

var ary:Array=["A","C","B"];
var Numberary:Array=[2005,12,1000];
trace(ary.sort());//A,B,C
trace(Numberary.sort());//1000,12,2005

[2][2]排序方式:

Array.CASEINSENSITIVE 值为:1 ,表示大小写不敏感按字母顺序排序,如果是数字则从小到大.

Array.DESCENDING 值为:2 ,表示按字母倒序排列

Array.UNIQUESORT 值为:4 ,表示必须是唯一性排序,如果比较值结果相同,则放弃排序.

Array.RETURNINDEXEDARRAY 值为:8 ,让sort()和sortOn()函数返回值返回排序后的索引列表,同时保持原数组不变.

Array.NUMERIC or 16 值为:16 ,强制sort()和sortOn()中对数值采用从小到大排序,否则,不设方式.sort()和sortOn()将把数字当成字符串来排序.

排序方式可以同时用多个,使用"|"号隔开.

[2][3]比较函数.(比较函数要求是,有两个参数,返回值是1,0,-1中的一个.)

格式:function 函数名(参数A:类型,参数B:类型):int{...}

例:

var a:Object={price:20,number:3};
var b:Object={price:10,number:7};
var c:Object={price:50,number:1};
var amountAry:Array=[a,b,c];
function compare(paraA:Object,paraB:Object):int {
var resultA=paraA.price*paraA.number;
var resultB=paraB.price*paraB.number;
if (resultA>resultB) {
return 1;
}
if (resultA<resultB) {
return -1;
}
return 0;
}
amountAry.sort(compare);
trace(amountAry[0].price);//50
trace(amountAry[1].price);//20
trace(amountAry[2].price);//10