1.      数组说明及特点

Ø        数组是一列值，每个值都对应一个编号，这个编号被索引或下标。在JAVA中，数组索引都是从0开始，大小为N的数组的索引从0到N-1。当引用一个数组元素时，如果索引如果是小于0或大于N-1时，就会抛出ArrayIndexOutOfBoundsException异常。

Ø        在JAVA中，数组是一个对象，它可以存储基本数据类型变量，也可以存储类对象。

Ø        在JAVA中，所有的数组都有一个属性length，用于获取数组的元素个数。

2.      操作数组的重要方法

2.1.   数组的复制

arraycopy()函数用于数组复制，它是System类的一个静态方法，其函数有原型：public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

2.1.1.    基本数据类型数组复制

现在来写一个关于基本数据类型数组复制的实例：
publicclass Array {
    publicstaticvoid main(String[] args) {
         int[] arr1 = newint[]{1,2,3};
         int[] arr2 = newint[3];
         System.arraycopy(arr1, 0, arr2, 0, arr1.length);
         for(int i=0; i<arr2.length; i++){
         System.out.println("arr2["+i+"]="+arr2[i]);
         }
         arr2[1]=10;  //改变arr2数组索引为1的值，看是否arr1数组索引为1的值是否会改变
         System.out.println("arr1[1]="+arr1[1]);  //没有发生改变，说明存储是数据拷贝
    }
}
编译结果：
arr2[0]=1
arr2[1]=2
arr2[2]=3
arr1[1]=2

2.1.2.    对象数组的复制

现在来写一个关于对象数组复制的实例：
publicclass Array {
    publicstaticvoid main(String[] args) {
         Point[] arr1 = new Point[]{new Point(1,1), new Point(2,2), new Point(3,3)};
         Point[] arr2 = new Point[3];
         System.arraycopy(arr1, 0, arr2, 0, arr1.length);
         for(int i=0; i<arr2.length; i++){
         System.out.println(arr2[i]);
         }
         arr2[1].x=5; //改变arr2数组索引为1的值，看是否arr1数组索引为1的值是否会改变
         arr2[1].y=5;
         System.out.println(arr1[1]);     //发生了改变，说明对象数组存储是对象引用
    }
}
 
class Point{
    int x,y;
    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
    publicString
        return "x="+x+",y="+y;
    }
}编译结果：x=1,y=1
x=2,y=2
x=3,y=3
x=5,y=5

2.2.   数组排序

Arrays类有个sort()函数用于数据的排序，它是一个重载函数，可以对基本数据类型数组进行排序，也可以对对象数组进行排序。

2.2.1.    基本数据类型数组的排序

现在来写一个关于基本数据类型数组排序的实例：
import java.util.Arrays;
publicclass Array {
    publicstaticvoid main(String[] args) {
         int[] arr = newint[]{2,1,3};
         Arrays.sort(arr);
         for(int i=0; i<arr.length; i++){
         System.out.println("arr["+i+"]="+arr[i]);
         }
    }
}
 
编译结果：
arr[0]=1
arr[1]=2
arr[2]=3

2.2.2.    对象数组的排序

现在来写一个关于对象数组排序的实例：
import java.util.Arrays;
publicclass Array {
    publicstaticvoid main(String[] args) {
        Student[] stu = new Student[]{new Student(18,"aaa"),
                                       new Student(20,"bbb"),
                                       new Student(19,"ccc")};
        Arrays.sort(stu);
         for(int i=0; i<stu.length; i++){
         System.out.println("stu["+i+"]="+stu[i]);
         }
    }
}
 
class Student{
    int num;
    String name;
    Student(int num, String name){
        this.num = num;
         = name;
    }
}
 
编译结果：
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable
    at java.util.Arrays.mergeSort(Arrays.java:1144)
    at java.util.Arrays.sort(Arrays.java:1079)
    at Array.main(Array.java:7)
Comparable
Comparable
compareTo(T o)抽象方法。
现在对类Student进行改写，改写后的实例：
import java.util.Arrays;
publicclass Array {
    publicstaticvoid main(String[] args) {
         Student[] stu = new Student[]{new Student(18,"aaa"),
                                       new Student(20,"bbb"),
                                       new Student(19,"ccc")};
         Arrays.sort(stu);
         for(int i=0; i<stu.length; i++){
         System.out.println("stu["+i+"]="+stu[i]);
         }
    }
}
 
class Student implements Comparable{
    int num;
    String name;
    Student(int num, String name){
        this.num = num;
         = name;
    }
    public String toString(){
        return "num="+num+",name="+name;
    }
    publicint compareTo(Object o){
        Student stu = (Student)o;
        return stu.num>num?-1:(stu.num==num?0:1);
    }
}
 
编译结果：
stu[0]=num=18,name=aaa
stu[1]=num=19,name=ccc
stu[2]=num=20,name=bbb