java二维数组

二维数组

二维数组可以看成以数组为元素的数组。

还可以有二维、三维、甚至更多维数组，但是实际开发中用 的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都很少）。

　　1. 数据类型[] [] 变量名; int[] [] arr; 推荐

　　2. 数据类型 变量名[] []; int arr[] [];

　　3. 数据类型[] 变量名[]; int[] arr[];

 

二维数组的声明

 

动态初始化一个二维数组

　　 格式：数据类型[] [] 变量名 = new 数据类型[m] [n]; 

　　范例：int[] [] arr = new int[2] [3];

　　定义了一个二维数组 二维数组中有2个元素(一维数组) 每一个一维数组有3个元素(int类型数据)

　　适合开始知道数据的数量，但是不确定具体元素值的业务场景

 

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[][] a = new int[3][]; // 动态初始化一个二维数组
// a[0] = {1,2,5}; //错误，没有声明类型就初始化
        a[0] = new int[]{1, 2};
        a[1] = new int[]{2, 2};
        a[2] = new int[]{2, 2, 3, 4};
        System.out.println(a[2][3]);
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}

 

public class Test {
    public static void main(String[] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[][] a = new int[3][]; // 动态初始化一个二维数组
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
// int a1[ ][ ]=new int[ ][4];//非法
    }
}

二维数组的静态初始化

　　 格式：数据类型[] [] 变量名 = new 数据类型[] []{{元素…},{元素…},{元素…},…};

　　范例：int[ ] [ ] arr = new int[] []{{1,2,3},{4,5,6},{7,8,9}};

　　定义了一个二维数组 二维数组中有三个元素(一维数组) 每一个一维数组有三个元素(int类型数据)

　　注意：一维数组中元素的个位可以是不同的 比如： int[] [] arr = new int[] []{{1,2,3},{4,5},{6,7,8,9}}; // new int[][] 为二维数组类型开辟一个空间

　　同样，针对静态初始化，二维数组也给出了简化格式：

　　简化格式：数据类型 [ ][ ] 变量名 = { {元素…},{元素…},{元素…},… };

　　范例：int [ ] [ ] arr = {{1,2,3},{4,5,6},{7,8,9}};

　　适合一开始就能确定元素值的业务场景

public class Test {
    public static void main(String[ ] args) {
        int[ ][ ] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
        System.out.println(a[2][3]);
    }
}

二维数组内存图

 二维数组常见操作----遍历

/*
需求：已知一个二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}}; 请把元素在控制台输出
*/
public class ArrayTest {
    public static void main(String[] args) {
//定义二维数组，并进行静态初始化
        int[][] arr = {
                {1, 2, 3}, 
                {4, 5, 6}, 
                {7, 8, 9}
                        };
//获取数据
        for (int i = 0; i < arr.length; i++) { // 取出二维数组中的一维数组
//arr[i]
            for (int j = 0; j < arr[i].length; j++) { // 依次取出每个二维数组中的一维数组的元素
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}         

　　① 循环嵌套：循环语句中嵌套循环语句

　　② 通过外层循环可以得到一维数组

　　③ 在通过内存循环可以得到每一个二维数组元素

二维数组常见操作---元素打乱

/*
已知二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}};用程序实现把数组中的元素打乱,并在控制台输出打乱后的数组元素

*/

import java.util.Random;  
class Test11 {
    public static void main(String[] args) {
//定义二维数组，并进行静态初始化
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
//创建随机数对象
        Random r = new Random();
//遍历二维数组，进行元素打乱
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
//arr[i][j]
                int x = r.nextInt(arr.length);
                int y = r.nextInt(arr[x].length);
//元素交换
                int temp = arr[i][j];
                arr[i][j] = arr[x][y];
                arr[x][y] = temp;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

 

　　这里的思路和前面一维数组中的元素打乱是一样的，也是要随机产生二维数组中元素的索 引，并进行元素交换。

　　只不过呢，二维数组元素的索引是两个值，所以，这里要产生两个随机数。 

使用Arrays来操作二维数组

使用二维数组保存表格数据

import java.util.Arrays;
class Test11 {
    public static void main(String[] args) {
        // 创建对象类型的一维数组
        Object[] a1 = {1001, "高淇", 18, "讲师", "2-14"}; 
        Object[] a2 = {1002, "高小七", 19, "助教", "10-10"};
        Object[] a3 = {1003, "高小琴", 20, "班主任", "5-5"};
        // 动态初始化一个对象类型的二维数组 存3个一维数组
        Object[][] emps = new Object[3][];
        // 手动把上面创建的一维数组加入到二维数组中
        emps[0] = a1;
        emps[1] = a2;
        emps[2] = a3;
        // 使用arrays类快速获取数组中的数据 ，省去了两个for嵌套循环
        System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));
    }
}