二维数组
二维数组是一个特殊的一维数组，是由一个由行和列组成的一个表格，矩阵Matrix其每一个元素都是一个一维数组，例如：
String str[][] = new String[3][4];
我们在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的
特别的，如果一个二维数组的行和列相等的话，也称之为是方阵
二维数组在内存中的存储
- 无论是二维数组，还是多维数组，它们本身就是一个一维数组
- 尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组罢了！
如何创建二维数组
创建一个3行4列的二维数组，元素默认都是0
int[][] matrix=new int[3][4];
创建个指定元素的二维数组
int[][] matrix=new int[][]{{1，2，3，4}，{2，3，4，5}，{3，4，5，6}}；
class Test01{
public static void main(String[] args){
int[][] matrix=new int[][]{
{1,2,3,4},
{5,6,7,8},
{8,7,6,5},
{4,3,2,1}
};
//matrix.length 表示的就是最外层那个一维数组的长度 行数
//matrix[i] 表示的是最外层那个一维数组当中角标i的那个元素 只不过这个元素也是一个一维数组
//matrix[i].length 表示的是这个一维数组元素的长度(当前行的长度)
//matrix[i][j] 表示的就是这个一维数组元素中角标j的那个元素
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[i].length;j++){
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
//int[][] matrix=new int[m][n]; 这个二维数组定义下
//内存中一共有几个一维数组 m+1
}
}
或
int[][] matrix={{1，2，3，4}，{2，3，4，5}，{3，4，5，6}}；
public class Array2 {
public static void main(String[] args) {
/*第一种创建二维数组的方法*/
int[][] a1=new int[3][2];
a1[0][0]=1;
a1[0][1]=2;
a1[1][0]=3;
a1[1][1]=4;
a1[2][0]=5;
a1[2][1]=6;
/*第二种创建二维数组的方法*/
String[][] a2={{"q","w"},{"e","r"},{"t","y"}};
System.out.println("第一个二维数组");
for(int i=0;i<a1.length;i++){
for(int j=0;j<a1[i].length;j++){
System.out.print(a1[i][j]+" ");
}
System.out.println();
}
System.out.println("第一个二维数组");
for(int i=0;i<a2.length;i++){
for(int j=0;j<a2[i].length;j++){
System.out.print(a2[i][j]+" ");
}
System.out.println();
}
}
}
二维数组的动态初始化
1. 直接为每一维分配空间，格式如下：
type[][] typeName = new type[arrayLength1][arrayLength2];
type 可以为基本数据类型和复合数据类型，arraylength1 和 arraylength2 必须为正整数，arraylength1 为行数，arraylength2 为列数。
例如：
int a[][] = new int[2][3];
解析：
二维数组 a 可以看成一个两行三列的数组。
2. 从最高维开始，分别为每一维分配空间，例如：
String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");
解析：
s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。
二维数组的引用
对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：
num[1][0];
传参
基本数据类型传参 传的是常量在常量池中的地址
引用数据类型传参 传的是对象在堆内存中的地址
实参——>形参 传的永远是地址
基本数据类型 是原子型数据 就是不可再拆分
引用数据类型 是复合型数据 当前对象数据中，其实还包括了其他更多的子数据
int a,b,c;-> arr [a,b,c]
复合型数据 指的就是由多个基本数据或其他引用数据组成的一个数据，例如
人：姓名 年龄 性别 身高 体重....
形参变量永远不可能去改变实参中已储存的数据地址，除非return 实参且接收，就算形参变量所存储的数据地址被改变，那也是改变形参自己，与实参无关。无非是:
实参本身指向的是一个对象，然后把这个对象的地址传递给了形参，形参就可以通过该地址去堆内存中找对象，可以修改对象中的数据。实参再去访问对象时，对象中的数据就已经被改变。因为实参和形参目前使用操作的都是同一个对象！
总结：
无论实参还是形参，实参就是把变量空间所存的地址给了形参而已，他们都是变量！
所以对于变量的修改而言,主要分两种！
1.要么改变该变量空间所存储的地址
int a=3;
a=7;
int[] arr=new int[]{1,2,3};
arr=new int[]{3,2,1};
2.要么改变该变量空间所存储的地址所指向的那个对象中的数据
int[] arr=new int[]{1,2,3};
arr[0]=10;
对与基本数据类型而言，能否支持2操作 不能！
class Test02{
public static void main(String[] args){
int a=3;
int b=7;
swap(a,b);
System.out.printf("a=%d,b=%d\n",a,b);
int[] arr={3,7};
swap(arr[0],arr[1]);
System.out.printf("arr[0]=%d,arr[1]=%d\n",arr[0],arr[1]);
swap(arr);
System.out.printf("arr[0]=%d,arr[1]=%d\n",arr[0],arr[1]);
swap2(arr);
}
public static void swap(int m,int n){
m=7;
n=3;
}
public static void swap(int[] arr){
arr[0]=7;
arr[1]=3;
}
public static void swap2(int[] arr){//0xabc
arr=new int[]{10,20};
}
}
来源：CSDN
作者：weixin_44077638
链接：https://blog.csdn.net/weixin_44077638/article/details/104405500