数组工具类

package com.devil.utils
{
 import flash.utils.Dictionary;

 /**
  * 数组工具类
  * @author     devil
  * @version    V20110219
  * @createTime 2010-7-19
  * @updateTime 2010-09-19     整理
   * @updateTime 2010-10-23     填加【clone(),getKeyArrayByDic(),getValueArrayByDic()】
  * @updateTime 2011-02-19     填加【toArray1()】
  * @qq         346443480
  * @email      sych_1982 @ 163.com
  */ 
 public class ArrayUtil
 {
  
  /**
   * 计算由数字元素组成的数组的元素平均值。
   * @param arr  源数组。
   * @return     平均值。
   *
   */  
  public static function avg(arr:Array):Number
  {
   return sum(arr) / arr.length;
  }

  
  /**
   * 判断一个数组中是否包含指定的元素。
   * @param arr          源数组。
   * @param element      判断是否存在于源数组中的元素。
   * @return             如果一个数组中包含指定的元素,返回true.
   *
   */  
  public static function contains(arr:Array,element:Object):Boolean
  {
   return arr.indexOf(element) > -1;
  }
  
  /**
   * 删除数组内重复的元素,源数组不改变.
   * <p>生成的数组的顺序是按源数组内元素从左到右出现顺序为准.</p>
   * @param arr 要删除重复元素的数组。
   * @return    删除重复元素后的源数组的一份拷贝。
   *
   */  
  public static function createUniqueCopy(arr:Array):Array
  {
   var result:Array = [];
   var len:int = arr.length;
   for(var i:uint = 0; i < len; i++)
   {
    if(!contains(result,arr[i]))result.push(arr[i]);
   }
   return result;
  }
  
  /**
   * 对数组中的每一个元素执行相同的操作.
   * <p>外理的方法需要传入数组的元素做为参数.</p>
   * @param arr    源数组
   * @param f      对元素执行的操作，该参数引用的方法需要传入数组元素做为参数。
   *
   */  
  public static function eachFunction(arr:Array,f:Function):void
  {
   for each(var element:Object in arr)
   {
    f(element);
   }
  }
  
  /**
   * 返回二维数组对应的值。
   * @param i    一维索引
   * @param j    二维索引
   * @param arr  源数组。
   * @return     返回值。
   *
   */  
  public static function getElement(i:int,j:int,arr:Array):Object
  {
   return arr[i][j];
  }
  
  /**
   * 获得对象数组中某个键的所有值
   * @param arr       源数组
   * @param key       健值
   * @return    数组中所有与健对应的值组成的新数组
   * @example
   * <listing version = "3.0">
   *   getKeyValues([{x:0,y:0},{x:-2,y:4},{x:4,y:2}],"x") //[0,-2,4]
   * </listing>
   */ 
  public static function getKeyValues(arr:Array,key:Object):Array
  {
   var values:Array = [];
   for each(var o:Object in arr)
   {
    values.push(o[key]);
   }
   return values;
  }
  
  /**
   * 判断两个数组是否相等(对应位置的对应元素相等)。
   * @param arr1 源数组1。
   * @param arr2 源数组2。
   * @return     如果两个数组相等,返回true.
   *
   */  
  public static function isEqual(arr1:Array,arr2:Array):Boolean
  {
   if(arr1.length != arr2.length)return false;
   var len:int = arr1.length;
   for(var i:int = 0; i < len; i ++)
   {
    if(arr1[i] != arr2[i])return false;
   }
   return true;
  }
  
  /**
   * 在数值数组内小于value的元素个数。
   * @param arr     源数组。
   * @param value   要判断的值。
   * @return        小于value的元素个数。
   *
   */  
  public static function lessThenValueNum(arr:Array,value:int):int
  {
   arr.sort(Array.NUMERIC);
   if(int(arr[0]) > value) return 0;
   if(int(arr[arr.length - 1]) < value) return arr.length;
   var middleIndex:int = (arr.length - 1) / 2;
   if(value < arr[middleIndex])
   {
    while(middleIndex >= 0)
    {
     if(value > arr[middleIndex]) return middleIndex + 1;
     middleIndex --;
    }
   }
   else if(value > arr[middleIndex])
   {
    while(middleIndex < arr.length)
    {
     if(value < arr[middleIndex]) return middleIndex;
     middleIndex ++;
    }
   }
   return middleIndex;
  }
  
  /**
   * 从数组中删除指定的元素.并返回删除的数量,可以选择删除第一个出现的或者数组内所有的元素.
   * @param arr       要删除元素的数组。
   * @param element   要删除的元素。
   * @param all       [可选参数]如果true，则删除数组中所有的与该元素相等的元素，否则只删除一个且是最靠前的元素。
   * @return          删除的元素的个数。
   * 
   */  
  public static function remove(arr:Array,element:Object,all:Boolean = false):int
  {
   var count:int = 0;
   var index:int = arr.indexOf(element);
   if(all)
   {
    while(index > -1)
    {
     arr.splice(index,1);
     count ++;
     index = arr.indexOf(element);
    }
   }
   else
   {
    if(index > -1)
    {
     arr.splice(index,1);
     count ++;
    }    
   }

   return count;
  }
  
  /**
   * 删除数组中某一指定的索引[不包括指定的索引]之后的元素，如果index小于或者等于-1，则清空数组,改变源数组.
   * @param arr    要删除元素的数组。
   * @param index  指定的索引位置。
   * @return       从原数组中删除的元素的组成的数组。
   */  
  public static function removeAllBehindSomeIndex(arr:Array,index:int):Array
  {
   var len:int = arr.length;
   index = MathUtil.clamp(-1,len - 1,index);
   return arr.splice(index + 1,len - index);
  }
  
  /**
   * 计算数组内所有的元素的相加的结果。
   * @param arr  包含计算相加数字元素的数组。
   * @return     数组内数字元素相加后的结果。
   */  
  public static function sum(arr:Array):Number
  {
   var result:Number = 0;
   for each(var element:Number in arr)
   {
    result += element;
   }
   return result;
  }  
  
  /**
   * 随机获得数组中的一个元素.
   * @param array  源数组.
   * @return       随机元素值.
   *
   */  
  public static function getRndElement(array:Array):Object
  {
   return array[int(array.length * Math.random())];
  }
  
  /**
   * 复制数组的一份拷贝,针对一维数组.
   * @param array 源数组。
   * @return      源数组的拷贝。
   */  
  public static function clone(array:Array):Array
  {
   return array.concat();
  }  
  
  /**
   * 将<code>Dictionary</code>类型的值转成数组.
   * @param dic 要转化数组的字典数组.
   * @return  由<code>Dictionary</code>类型的值构成的数组.
   */  
  public static function getValueArrayByDic(dic:Dictionary):Array
  {
   var result:Array = [];
   for each(var value:Object in dic)
   {
    result.push(value);
   }
   return result;
  }
  
  /**
   * 将<code>Dictionary</code>类型的键转成数组.
   * @param dic 要转化数组的字典数组.
   * @return  由<code>Dictionary</code>类型的键构成的数组.
   */  
  public static function getKeyArrayByDic(dic:Dictionary):Array
  {
   var result:Array = [];
   for (var value:Object in dic)
   {
    result.push(value);
   }
   return result;
  }
  
  /**
   * 将二维数组，转成一个一维的数组.把二维数组的值，放到一个新的一维数组内。
   * @param arr2  指定的二维数组。
   * @return      二维转化后的一维数组。
   */  
  public static function toArray1(arr2:Array):Array
  {
   var result:Array = [];
   var row:int = arr2.length;
   var len:int;
   for(var i:int = 0; i < row; i++)
   {
    len = arr2[i].length;
    for(var j:int = 0; j < len;j ++)
    {
     result.push(arr2[i][j]);
    }
   }
   return result;
  }
 }
}