Java中数组的定义，一般使用方法，以及在js中的使用笔记

首先，我们来看一下数组的定义和一般的使用方法;
0、定义一个Java数组

String[] aArray = new String[5];String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

1、打印Java数组中的元素

int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
System.out.println(intArray);// [I@7150bd4d
System.out.println(intArrayString);// [1, 2, 3, 4, 5]

这里的重点是说明了Java中数组的引用和值得区别，第三行直接打印intArray，输出的是乱码，因为intArray仅仅是一个地址引用。第4行输出的则是真正的数组值，因为它经过了Arrays.toString()的转化。对Java初学者来说，引用和值仍需重视。
2、数组转为list

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);// [a, b, c, d, e]

注意：int[]数组转为list时，asList方法是将int[]作为一个对象来解析的，如：
int[] arr = {1,2,3,4,5};
List model = Arrays.asList(arr)//[I@2542880d
List<int[]> model2 = Arrays.asList(arr);
System.out.println(model2);//[[I@2542880d]

所以int[]转为list现在只能新建list，循环遍历 数组添加进list中；不过java8中list估计应该有int数组的构造；
list转为数组

List<String> strList = new ArrayList<String>();
strList.add("aa");
strList.add("bb");
Object[] objs = strList.toArray();
--------------
如果要变成String数组，需要强转类型。
String[] strs = (String[]) strList.toArray();
-----------------

3、检查数组中是否包含某一个值

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");System.out.println(b);// true

先使用Arrays.asList()将Array转换成List，这样就可以用动态链表的contains函数来判断元素是否包含在链表中。

4、连接两个数组

int[] intArray = { 1, 2, 3, 4, 5 };int[] intArray2 = { 6, 7, 8, 9, 10 };// Apache Commons Lang libraryint[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

ArrayUtils是Apache提供的数组处理类库，其addAll方法可以很方便地将两个数组连接成一个数组。

5、声明一个数组内链

method(new String[]{"a", "b", "c", "d", "e"});

6、将数组中的元素以字符串的形式输出

String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);// a, b, c

同样利用StringUtils中的join方法，可以将数组中的元素以一个字符串的形式输出。
这个方法在后台传值时有时会用到；
7、将Array转化成Set集合

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

在Java中使用Set，可以方便地将需要的类型以集合类型保存在一个变量中，主要应用在显示列表。同样可以先将Array转换成List，然后再将List转换成Set。

8、数组翻转

int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));//[5, 4, 3, 2, 1]

9、从数组中移除一个元素

int[] intArray = { 1, 2, 3, 4, 5 };int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

数组中还有个就是sort方法，就是排序，默认的排序是有小到大，不过我们可以自定义排序规则，这里就用到了实现comparators，然后实现他的compare方法即可；
1、Arrays.sort(int[] a)
这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。
举例如下：

  import java.util.Arrays; 
  public class Main {
      public static void main(String[] args) { 

        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; 
        Arrays.sort(a);
         for(int i = 0; i < a.length; i ++) {
              System.out.print(a[i] + " ");
         }
     }
 }
 运行结果如下：
0 1 2 3 4 5 6 7 8 9 

2、Arrays.sort(int[] a, int fromIndex, int toIndex)
这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序哦！

 import java.util.Arrays; 

 public class Main { 
    public static void main(String[] args) { 

          int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
          Arrays.sort(a, 0, 3); 
         for(int i = 0; i < a.length; i ++) {
             System.out.print(a[i] + " ");
        }
     } 
 }

3、public static void sort(T[] a,int fromIndex, int toIndex, Comparator

 public class Main { 
     public static void main(String[] args) { 
         //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char） 
         //而要使用它们对应的类
         Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
         //定义一个自定义类MyComparator的对象
         Comparator cmp = new MyComparator();
         Arrays.sort(a, cmp);
         for(int i = 0; i < a.length; i ++) {
             System.out.print(a[i] + " ");
         }
     }
 }
 //Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
 //而不是extends Comparator
 class MyComparator implements Comparator<Integer>{
     @Override
     public int compare(Integer o1, Integer o2) {
        //如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
         //这样颠倒一下，就可以实现反向排序了
         if(o1 < o2) { 
             return 1;
         }else if(o1 > o2) {
             return -1;
         }else {
             return 0;
         }
     }    
 }
 运行结果如下：
9 8 7 6 5 4 3 2 1 0 

**下面我们来看一下在js中使用数组的情况：
1、数组的创建**
var arrayObj = new Array();　//创建一个数组
var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
var arrayObj = new Array([element0[, element1[, …[, elementN]]]]);　//创建一个数组并赋值
要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。

2、数组的元素的访问
var testGetArrValue=arrayObj[1]; //获取数组的元素值
arrayObj[1]= “这是新值”; //给数组元素赋予新的值

3、数组元素的添加
arrayObj. push([item1 [item2 [… [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
var a = [1,2,3,4,5];
var b = a.push(6,7); //a：[1,2,3,4,5,6,7] b：7
arrayObj.unshift([item1 [item2 [… [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
var a = [1,2,3,4,5];
var b = a.unshift(-2,-1); //a：[-2,-1,1,2,3,4,5] b：7
注：在IE6.0下测试返回值总为undefined，FF2.0下测试返回值为7，所以这个方法的返回值不可靠，需要用返回值时可用splice代替本方法来使用。
arrayObj.splice(insertPos,0,[item1[, item2[, … [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回”“。
4、数组元素的删除
arrayObj.pop(); //移除最后一个元素并返回该元素值
var a = [1,2,3,4,5];
var b = a.pop(); //a：[1,2,3,4] b：5//不用返回的话直接调用就可以了
arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移
var a = [1,2,3,4,5];
var b = a.shift(); //a：[2,3,4,5] b：1
arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量
splice还具有先删除后添加的功能，即先删除几个元素，然后在删除的位置再添加若干元素，删除与添加的元素的个数没有必须相等，这时侯deleteCount也是要用到的。
var a = [1,2,3,4,5];
var b = a.splice(2,2,7,8,9); //a：[1,2,7,8,9,5] b：[3,4]
deleteCount的元素，数组形式返回所移除的元素
5、数组的截取和合并
arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素，原数组没有影响；
如：[1,2,3,4,5,6].slice(1,4)将得到[2,3,4]。当 start或者end为负数时，则使用他们加上length后地值。如：[1,2,3,4,5,6].slice(-4,-1)将得到[3,4,5]。如果end小于等于start，将返回空数组。
arrayObj.concat([item1[, item2[, … [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组
var a = [1,2,3,4,5];
var b = a.concat(6,7); //a：[1,2,3,4,5] b：[1,2,3,4,5,6,7]
6、数组的拷贝
arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向
arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向
7、数组元素的排序
arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址
arrayObj.sort(); //对数组元素排序，返回数组地址
自定义排序最后有说；
8、数组元素的字符串化
arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。
9、是关于数组的遍历：
第一种：

<script type="text/javascript">
 <!--
var arr = new Array(13.5,3,4,5,6);
for(var i=0;i<arr.length;i++){
 arr[i] = arr[i]/2.0;
}
alert(arr);
 //-->
 </script>

第二种：

<html>
<body>
<script type="text/javascript">
var x
var mycars = new Array()
mycars[0] = "Saab"
mycars[1] = "Volvo"
mycars[2] = "BMW"
for (x in mycars)
{
document.write(mycars[x] + "<br />")
}
</script>
</body>
</html>

最后在js中排序问题：

javascript 数组排序：
arrayobj.sort(sortfunction) 

参数

arrayObj
    数组
sortFunction 
    可选项。比较函数。如果这个参数被省略，那么元素将按照 ASCII 字符顺序进行升序排列。 
     比较函数必须返回下列值之一：

    * 负值，如果所传递的第一个参数比第二个参数小。
    * 零，如果两个参数相等。
    * 正值，如果第一个参数比第二个参数大
举例：
var testArray=[1,5,2,3,6,4] 
testArray.sort(function(a,b){return a-b;}); 
alert(testArray);