二维数组

1 数组:
　　1.1 数组的优点和缺点，并且要理解为什么。
　　第一：空间存储上，内存地址是连续的。
　　第二：每个元素占用的空间大小相同。
　　第三：知道首元素的内存地址。
　　第四：通过下标可以计算出偏移量
　　通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高。

　　优点：检索效率高
　　缺点：随机增删效率较低，数组无法存储大数据量。
　　注意：数组最后一个元素的增删效率不受影响。

　　1.2 一维数组的静态初始化和动态初始化。
　　静态初始化：
　　int[] arr = {1,2,3,4};
　　Object[] objs = {new Object(),new Object(),new Object()};
　　动态初始化：
　　int[] arr = new int[4];// 4个长度，每个元素默认0
　　Object[] objs = new Object[4]; // 4个长度，每个元素默认值null

　　1.3 一维数组的遍历。
　　for(int i = 0; i < arr.length; i++){
　　　　System.out.println(arr[i]);
　　}

　　1.4 二维数组静态初始化和动态初始化。
　　静态初始化：
　　int[][] arr = {
　　　　　　　　{1,2,3},
　　　　　　　　{4,5,6},
　　　　　　　　{7,8,9}
　　　　　　   };

　　Object[][] objs = {
　　　　　　　　　　{new Object()},
　　　　　　　　　　{new Object()},
　　　　　　　　　　{new Object()}
　　　　　　　　   };
　　动态初始化：
　　int[][] arr = new int[3][4];
　　Object[][] objs = new Object[1][2];
　　// Animal类型的数组，里面可以存储Animal类型对象，以及Animal类型的子类型都可以。
　　Animal[][] animals = new Animal[3][2];

　　1.5 二维数组的遍历
　　for(int i = 0; i < arr.length; i++){ //外面的for循环负责遍历外面的一维数组
　　　　// 里面的for循环负责循环数组中的元素
　　　　for(int j= 0; j < arr[i].length; j++){
　　　　　　System.out.print(arr[i][j]);
　　　　}
　　　　// 输入换行符
　　　　System.out.println();
　　}

　　1.6 main方法上“String[] args”参数的使用（非重点，了解一下，以后一般都是有界面的。这个东西非常鸡肋。）

　　1.7 数组的拷贝：System.arraycopy()方法的使用。
　　数组有一个特点：长度一旦确定，不可变。
　　所以数组长度不够的时候，需要扩容，扩容机制是：新建一个大数组。
　　将小数组中的数据拷贝到大数组中，然后小数组对象被垃圾回收。

　　1.8 对数组中存储引用数据类型的情况，要会画他的内存结图。

关于java中的二维数组案例：

package com.javase.array;
/*
关于java中的二维数组
    1 二维数组其实是一个特殊的数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
    2 二维数组是什么？
        三维数组是一个特殊的二维数组。特殊在这个二维数组中每一个元素是一个一维数组。
    3 二维数组静态初始化
        int[][] = {{1,2,3,4,5},{1,1,1,1,1},{0,0,0,0,0,0}}
*/
public class ArrayTest09 {
    public static void main(String[] args) {
        // 一维数组
        int[] i = {1,2,3,4,5};
        System.out.println(i.length);//5
        
        // 二维数组
        // 以下代码当中，是四个一维数组
        int[][] a = {
                {1,2,3,4,5,6},
                {7,8,9,10,11},
                {12,13,14,15,16},
                {0,1,23,4,5,6,7}
        };
        System.out.println(a.length);// 4
        System.out.println(a[0].length);// 6
        System.out.println(a[1].length);// 5
        System.out.println(a[2].length);// 5
        System.out.println(a[3].length);// 7
        
        // 下面这个代码里面是5个一维数组
        int[][] a1 = {
                {1,2,3,4,5,6},
                {7,8,9,10,11},
                {12,13,14,15,16},
                {0,1,23,4,5,6,7},
                {1,3,5,7,9}
        };
     }
}

 

关于二维数组元素中的：读和改。案例：

package com.javase.array;
/*
关于二维数组元素中的：读和改。
    a[二维数组中的一维数组的下标][一维数组的下标]
    a[0][0]:表示第一个一维数组中的第一个元素。
    a[3][100]:表示第四个一维数组中的第101个元素。
    
    注意:对于a[3][100]来说，其中a[3]是一个整体。[100]是前面a[3]执行结束的结果然后再下标100。
*/
public class ArrayTest10 {
    public static void main(String[] args) {
        // 二维数组
        int[][] a = {
                {1,2,3,4,5},
                {6,7,8,9,0},
                {22}
        };
        
        // 请取出第一个一维数组。
        int[] 我是第一个一维数组 = a[0];
        
        int 我是第一个一维数组中的第一个元素 = 我是第一个一维数组[0];
        System.out.println(我是第一个一维数组中的第一个元素);
        
        // 合并以上代码
        // 以下代码的由来是因为以上代码的合并导致的。
        System.out.println(a[0][0]);
        
        // 取出第二一维数组的第三个元素。
        System.out.println(a[1][2]);
        
        // 取出第三个一维数组中的第一个元素
        System.out.println(a[2][0]);
        
        // 改
        a[2][0] = 11111;
        System.out.println(a[2][0]);
        
        // 注意别越界
        // ArrayIndexOutOfBoundsException
        // System.out.println(a[2][1]);
    }
}

二维数组的遍历案例：

package com.javase.array;
/*
二维数组的遍历
*/
public class ArrayTest11 {
    public static void main(String[] args) {
        String[][] array = {
                {"java","oracle","c++","python","php"},
                {"张三","李四","王五"},
                {"jack","rose","lucy"}
        };
        
        // 遍历二维数组
        for (int i = 0 ; i < array.length ; i++){// 外层循环3次。（负责纵向）
            String[] 一维数组 = array[i];
            // 内层负责循环输出一行
             for (int j = 0; j < 一维数组.length; j++){
                System.out.println(一维数组[j] + " ");
             }
            System.out.println();
        }
        
        // 合并代码
        for (int i = 0 ; i < array.length ; i++){// 外层循环3次。（负责纵向）
            for (int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

动态初始化二维数组案例：

package com.javase.array;
/*
动态初始化二维数组
*/
public class ArrayTest12 {
    public static void main(String[] args) {
        // 3行4列
        // 3个一维数组，每一个一维数组中4个元素
        int[][] a = new int[3][4];
        
        //遍历二维数组
        /*for (int i = 0; i < a.length; i++){
            for (int j = 0 ; j < a[i].length; j++){
                System.out.print(a[i][j]);
            }
            System.out.println();
        }*/
        
        int[][] b = {{1,2,3},{4,5,6},{7,8,9}};
        
        printArray(b);
        
        // 没有这种语法
        // printArray({{1,2,3},{4,5,6},{7,8,9}});
        
        // 可以这样写。
        printArray(new int[][]{{1,2,3},{4,5,6},{7,8,9}});
    }
    
    public static void printArray(int[][] array){
        for (int i = 0; i < array.length; i++){
            for (int j = 0 ; j < array[i].length; j++){
                System.out.print(array[i][j]);
            }
            System.out.println();
        }
    }
}