Java数组

数组是编程语⾔中⾮常常⻅的⼀种数据结构，是⼀种容器，⽤于存储多个相同类

型的数据（元素）。

在数组中，会为每⼀个元素分配⼀个下标（也叫索引），该

下标默认从0开始，⼀直⾃增累加，我们可以通过下标来访问数组中的任意元素；

总结：数组就是⼀个容器，能够帮我们存储很多相同类型的数据；

数组越界异常

public class Demo07 {
 public static void main(String[] args) {
 // 数组⻓度为3,最⼤索引为3-2=1
 int[] arr = {1, 4, 7};
 System.out.println(arr[3]);
 }
}

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访

问数组中不存在的索引，程序运⾏后，将会抛出

ArrayIndexOutOfBoundsExceptio

n 数组越界异常。在开发中，数组的越界异常是不能出现的，⼀旦出现了，就必

须要修改我们编写的代码。

 空指针异常

 arr = null 这⾏代码，意味着变量arr将不会在保存数组的内存地址，也就不允

许再操作数组了，因此运⾏的候会抛出

NullPointerException 空指针异常。

多维数组

多维数组是⼀维数组的延申，我们之前学习⼀维数组时，通过索引下标可以访问

数组中的某个元素；⽽多维数组存储的则是低⼀维度的数组；例如⼆维数组是⼀

维数组的集合，三维数组是⼆维数组的集合；

• ⼀维数组示意图：

•  ⼆维数组：

 二维数组的值都是一个一维数组

• 三维数组

三位数组的值都是一个二维数组（使用较少） 

多维数组的使用

1.初始化多维数组

• 方式1：

数组存储的数据类型[][] 数组名字=new 数组存储的数据类型[⻓度][⻓度];
int[] arr=new int[3][4];

第⼀个⻓度：能够容纳多少个⼀维数组

第⼆个⻓度：每个⼀维数组能够容纳多少个元素

• 方式2：

数组存储的数据类型[][] 数组名字=new 数组存储的数据类型[⻓度][⻓度]{{元素1,元素2...}
{元素1,元素2...}};
int[][] arr=new int[][]{{1,4,7},{3,6,9};

• 方式3：

数组存储的数据类型[][] 数组名字={{元素1,元素2...}{元素1,元素2...}};
int[][] arr={{1,4,7},{3,6,9}};

2.多维数组的访问

⼆维数组中的每⼀个元素都是⼀个⼀维数组；

public class Demo01 {
 public static void main(String[] args) {
 // 定义⼀个⼆维数组
 int[][] arr = {
 {1, 4, 7},
 {2, 5, 8},
 {3, 6, 9},
 };
 // 访问⼆维数组中的第0个元素(是⼀个⼀维数组)
 System.out.println(arr[0]); // 内存地址值: [I@6d6f6e28
 System.out.println(arr[1]); // 内存地址值: [I@135fbaa4
 System.out.println(arr[2]); // 内存地址值: [I@45ee12a7
 System.out.println("------------------");
 }
}

我们可以根据一维数组再来获取里面的数值：

public class Demo01 {
 public static void main(String[] args) {
 // 定义⼀个⼆维数组
 int[][] arr = {
 {1, 4, 7},
 {2, 5, 8},
 {3, 6, 9},
 };
 System.out.println(arr[0][1]); // 4
 System.out.println(arr[1][2]); // 8
 System.out.println(arr[2][1]); // 6
 System.out.println(arr[1][0]); // 2
 }
}

多维数组的遍历

1.先获取到多维数组的低维数组（先获取⼆维数组中的每⼀个⼀维数组）

public class Demo01 {
 public static void main(String[] args) {
 // 定义⼀个⼆维数组
 int[][] arr = {
 {1, 4, 7},
 {2, 5, 8},
 {3, 6, 9},
 };
 System.out.println(arr[0]);
 System.out.println(arr[1]);
 System.out.println(arr[2]);
 System.out.println("-----------------");
 
 for (int i = 0; i < arr.length; i++) {
 // 获取⼆维数组中的每⼀个元素(⼀维数组)
 System.out.println(arr[i]);
 }
 }
}

2.获取每个⼀维数组中的元素

public class Demo01 {
 public static void main(String[] args) {
 // 定义⼀个⼆维数组
 int[][] arr = {
 {1, 4, 7},
 {2, 5, 8},
 {3, 6, 9},
 };
 System.out.println(arr[0]);
 // 把arr[0]当作是⼀个普通的⼀维数组
 for (int i = 0; i < arr[0].length; i++) {
 System.out.println(arr[0][i]);
 }
 System.out.println(arr[1]);
 // 把arr[1]当作是⼀个普通的⼀维数组
 for (int i = 0; i < arr[1].length; i++) {
 System.out.println(arr[1][i]);
 }
 // 把arr[2]当作是⼀个普通的⼀维数组
 System.out.println(arr[2]);
 for (int i = 0; i < arr[2].length; i++) {
 System.out.println(arr[2][i]);
 }
 }
}

3.完成遍历

public class Demo01 {
 public static void main(String[] args) {
 // 定义⼀个⼆维数组
 int[][] arr = {
 {1, 4, 7},
 {2, 5, 8},
 {3, 6, 9},
 };
 // 先遍历获取每⼀个⼀维数组
 for (int x = 0; x < arr.length; x++) {
 // 获取到了每⼀个⼀维数组后,遍历这个⼀维数组
 for (int i = 0; i < arr[x].length; i++) {
 System.out.print(arr[x][i] + ",");
 }
 // 遍历完成后输出⼀个换⾏符
 System.out.println();
 }
 }
}

数组作为方法参数和返回值

• 数组作为⽅法参数传递，传递的参数是数组内存的地址。

public class Demo09 {
 public static void main(String[] args) {
 int[] arr = new int[]{1, 2, 3, 4, 5};
 System.out.println("main⽅法中的arr: " + arr); //[I@1b6d3586
 print(arr);
 }
 public static void print(int[] arr) {
 System.out.println("print⽅法中的arr: " + arr); //[I@1b6d3586
 for (int i = 0; i < arr.length; i++) {
 System.out.print(arr[i] + ",");
 }
 }
}

 

•  数组作为⽅法的返回值，返回的是数组的内存地址

public class Demo10 {
 public static void main(String[] args) {
 //调⽤getArr⽅法接收⽅法返回值,接收到的是数组的内存地址值
 int[] arr = getArr();
 for (int i = 0; i < arr.length; i++) {
 System.out.println(arr[i]);
 }
 }
 public static int[] getArr() {
 int[] arr = {12, 54, 32};
 // 返回数组的的内存地址值
 return arr;
 }
}

---