数组是编程语言中常见的一种引用数据结构，他用来存储一组相同数据类型的数据，也就是说，在一个数组中所有的数据的数据类型都是一致的。数组中提供了数组下标的概念，通过数组下标可以访问到数组中的各个数据。和许多其他的语言一样，在Java中也有一位数组，二维数组两个概念，让我们分别来看一下吧

   一：一维数组

   1：数组的定义

   数据类型[] 数组名称;  或者  数据类型 数组名称[];  

   注意：

   ◆上面两条语句，仅仅是声明了一个数组，还没有指向任何的内存空间，所以这个时候不能访问这个数组。

   ◆相比较而言，建议使用第一种方式创建数组，具有更好的语意和可读性。如：int[] a; 我们知道这是声明了一个变量，变量名为a,类型为int[]数组，简单明了。

   ◆定义数组时不能指定数组的长度。如int[2] b;这种定义是错误的

   2：数组的创建

   数组名 = new 数据类型[数组长度];

   注意：

   ◆数组在声明时并没有分配数组所指向的地址空间，然而在创建时，通过new就在内存中创建了数组长度个数据类型大小的空间类存放数据。

   ◆数组的下标从0开始到数组长度减1。比如：数组长度为n，则索引的范围为[0~n-1]

   3：数组声明与定义的相互结合

    数据类型[] 数组名称 = new 数据类型[数组长度];

   4：数组的初始化

   （1）静态初始化

   数据类型[] 数组名 = {值1，值2，值3...};

   ◆千万不要再[]中指定数组的长度

   ◆注意这里没有new 关键字来创建数组

   （2）动态初始化

   所谓的动态初始化，就是指将数组的定义与数组的初始化分离开来。

   数据类型[] 数组名  = new 数据类型[数组长度];

   数组名[0] = 值1；。。。。。。 数组名[n-1] = 值n;

   5：数组的输出

   （1）格式化输出：

   Arrays类为我们提供了数组的格式化输出方法：Arrays.toString(数组名);

   （2）for循环输出：  

  for(数据类型 循环变量  = 初值；循环条件；变量的递增)

       {  System.out.println(数组名称[i]);   }      

   6：一维数组的具体应用

   (1)数组的定义，创建，初始化，格式化输出

public class TestArray {
    public static void main(String[] args) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
        int[] niArr = new int[5];//数组定义创建的结合使用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
        System.out.println("数组的动态初始化");
        niArr[0] = 1;
        niArr[1] = 2;
        niArr[2] = 3;
        niArr[3] = 4;
        niArr[4] = 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
        System.out.println("格式化输出结果："+Arrays.toString(niArr));
        System.out.println("数组的静态初始化");
        int[] niArr2 = {1,2,3,4,5};
        System.out.print("for循环输出结果：");
        for(int i = 0;i<niArr2.length;i++){
            System.out.print(niArr2[i]+"  ");
        }
    }
}

   输出结果：

数组的动态初始化
格式化输出结果：[1, 2, 3, 4, 5]
数组的静态初始化
for循环输出结果：1  2  3  4  5

   （2）数组的最值问题

   所谓的最值问题，就是求数组中元素的最大值，或者最小值。我们可以想象一下擂主产生的过程？第一个参赛者上台，假设他是擂主，后面的人来挑战他，如果打败了他，则挑战者为擂主，如果没有打败，则继续当擂主，知道所有的参赛者全部比赛完毕，留下来的就是擂主。同理数组的最值问题也迎刃而解    

public class TestArray {
    public static void main(String[] args) {
                                                                                                                                                                                                                                                                                                                                                                                           
        int[] niArr = new int[5];//数组用来存储输入的数据
        int max = niArr[0];//假设数组的第一个元素为最大
        Scanner scan = new Scanner(System.in);
        for(int i=0;i<niArr.length;i++){
            System.out.println("请输入第"+(i+1)+"名学生的成绩：");
            niArr[i] = scan.nextInt();//数组的每一个元素，用来存储每一个数据输入
            if(niArr[i]>max){//逐个比较数组中的元素
                max = niArr[i];//如果他大于max，则调换两者的地位
            }
        }
        System.out.println("最高分为："+max);
    }
}

   结果：

请输入第1名学生的成绩：
55
请输入第2名学生的成绩：
88
请输入第3名学生的成绩：
55
请输入第4名学生的成绩：
66
请输入第5名学生的成绩：
99
最高分为：99

   （3）数组的排序问题

   Arrays类为我们提供的sort()方法，实现了对数组的升序排序。    

public class TestArray {
    public static void main(String[] args) {
                                                                                                                                                                                                                                                                                                                                     
        int[] niArr = {54,7,99,25,41,66};//数组的定义及静态初始化
        System.out.println("数组排序前：");
        System.out.println(Arrays.toString(niArr));
        System.out.println("数组排序后：");
        Arrays.sort(niArr);//sort排序数组
        System.out.println(Arrays.toString(niArr));
    }
}

   结果：

数组排序前：
[54, 7, 99, 25, 41, 66]
数组排序后：
[7, 25, 41, 54, 66, 99]

   （4）数组的拷贝

   ◆通过数组变量拷贝实现数组的拷贝

   数组变量拷贝实现的数组拷贝，得到的两个数组指向同一个地址空间，因此只要其中一个数组的某一个元素改变时，则也会影响到另一个数组的变化。

public class TestArray {
    public static void main(String[] args) {
        int[] befor = { 54, 7, 99, 25, 41, 66 };// 数组的定义及静态初始化
        int[] after = new int[10];
        System.out.println("原数组：" + Arrays.toString(befor));
        System.out.println("目的数组：" + Arrays.toString(after));
        System.out.println();
        after = befor;// 数组变量拷贝实现的数组拷贝
        System.out.println("数组变量拷贝实现的数组拷贝");
        System.out.println("原数组：" + Arrays.toString(befor));
        System.out.println("目的数组：" + Arrays.toString(after));
        System.out.println();
        after[3] = 1000;// 改变目的数组中的一个值
        System.out.println("改变目的数组中的一个值后的结果：");
        System.out.println("原数组：" + Arrays.toString(befor));
        System.out.println("目的数组：" + Arrays.toString(after));
        System.out.println();
                                                                                                                                                                                              
    }
}

     结果：

原数组：[54, 7, 99, 25, 41, 66]
目的数组：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
数组变量拷贝实现的数组拷贝
原数组：[54, 7, 99, 25, 41, 66]
目的数组：[54, 7, 99, 25, 41, 66]
改变目的数组中的一个值后的结果：
原数组：[54, 7, 99, 1000, 41, 66]
目的数组：[54, 7, 99, 1000, 41, 66]

     ◆使用System.arrsycopy(原数组，原数组开始位置，目的数组，目的数组开始位置，拷贝的数组长度)；方法完成数组间的值拷贝

public class TestArray {
    public static void main(String[] args) {
        int[] befor1 = { 54, 7, 99, 25, 41, 66 };// 数组的定义及静态初始化
        int[] after1 = new int[10];
        System.out.println("System.arraycopy实现的数组拷贝");
        System.arraycopy(befor1,0,after1,0,3);//从原数组0开始拷贝三个给目的数组
        System.out.println("原数组：" + Arrays.toString(befor1));
        System.out.println("目的数组：" + Arrays.toString(after1));
                                                                                                                                                                                          
    }
}

   结果：

System.arraycopy实现的数组拷贝
原数组：[54, 7, 99, 25, 41, 66]
目的数组：[54, 7, 99, 0, 0, 0, 0, 0, 0, 0]


 二：二维数组

   Java中支持多维数组，多为数组也就是数组的数组。

   1：多维数组的定义

   二维数组：数据类型[][] 数组名；

   三维数组：数据类型[][][]  数组名；

   2：多维数组的创建

   使用new创建多维数组时，要注意：不必指定每一维的大小，只要指定最左边的位数大小即可，而如果制定了其中一维，那么这一维左边的各维都需要指定。   

int [][]a = new int[2][];
        int [][][] b = new int[2][3][];

   3：多维数组的初始化

   （1）直接初始化数组

int [][] a ={{1,2,3},{2,2},{3,3,3,3}};

 （2）分开初始化

int [][] a =new int[2][];
        a[0] = new int[3];
        a[1] = new int[6];

   

外边要下大暴雨了。我先撤了哈。。。。j_0005.gif