一、数组的概述：
- 数组的理解：数组(Array),是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一的管理。
- 数组的相关概念。
2.1.数组名
2.2.元素
2.3.角标，下标，索引
2.4.数组的长度，元素的个数 - 数组的特点：
3.1.数组是有序排列的
3.2.数组属于引用数据类型的变量，数组的元素即可以是基本数据类型的变量，也可以是引用数据类型的变量。
3.3.创建数组对象会在内存中开辟一整块连续的空间
3.4.数组的长度一旦确定，就不能修改 - 数组的分类：
4.1.按照维数：一维数组，二维数组…
4.2.按照数组元素的类型：基本数据类型元素的数组，引用数据类型元素的数组。
一维数组的声明和初始化：
//一维数组,这是静态初始化 int[] ids; //声明 //静态初始化：数组的初始化和数组的元素的赋值操作同时进行 ids=new int[]{1,2,3,4,5}; //初始化，这是静态初始化 //动态初始化:数组的初始化和数组的元素的赋值分开进行 String[] names=new String[5];
数组一旦初始化完成，数组的长度就确定了。
4.3.如何调用数组指定位置的元素：通过索引调用
数组的索引从0开始，到数组的长度-1结束。
String[] names=new String[5]; //给元素赋值 names[0]="名字0"; names[1]="名字1"; names[2]="名字2"; names[3]="名字3"; names[4]="名字4";
4.4.如何获取数组的长度
属性.length
System.out.println(names.length); //5
4.5.如何遍历数组中的元素
//如何遍历数组 for (int i = 0; i < names.length; i++) { System.out.println(names[i]); }
4.6.数组元素的默认初始化值：
- 数组元素是整型：0
- 数组元素是浮点型：0.0
- 数组元素是char型：0或“\u0000”,而非’0’
- 数组元素是boolean型：false
- 数组元素是引用数据类型：null
二、数组的赋值机制：
先看案例代码如下：
public class ArrayAssign { public static void main(String[] args) { //基本数据类型，赋值方式为值拷贝(值传递) //n2的变化，不会影响n1的值 int n1 = 10; int n2 = n1; n2 = 80; System.out.println("n1=" + n1); //10 System.out.println("n2=" + n2); //80 //数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用传递 //是一个地址,arr2变化会影响到arr1 int[] arr1 = {1, 2, 3}; int[] arr2 = arr1; //把arr1 赋给了 arr2 arr2[0] = 10; //看看arr1的值 System.out.println("====arr1的元素===="); for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); } System.out.println(); System.out.println("====arr2的元素===="); for (int i = 0; i < arr2.length; i++) { System.out.print(arr2[i] + " "); } } }
输出结果如下：
n1=10 n2=80 ====arr1的元素==== 10 2 3 ====arr2的元素==== 10 2 3
图解如下：
2.1 数组的翻转
方法一：
public class ArrayReverse { public static void main(String[] args) { //定义数组 int[] arr = {11, 22, 33, 44, 55, 66,20}; //思路 //规律 //1. 把arr[0] 和 arr[5] 进行交换{66, 22, 33, 44, 55, 11} //2.把arr[1] 和 arr[4] 进行交换{66, 55, 33, 44, 22, 11} //2.把arr[2] 和 arr[3] 进行交换{66, 55, 44, 33, 22, 11} //一共交换3次 = arr.length/2 //5.每次交换时，对应的下标为：arr[i] 和 arr[arr.length-1-i] //代码 int temp = 0; int len = arr.length; //计算数组的长度 for (int i = 0; i < len / 2; i++) { temp = arr[len - 1 - i]; arr[len - 1 - i] = arr[i]; arr[i] = temp; } System.out.println("===反转后的数组==="); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } } }
输出结果如下：
反转后的数组 20 66 55 44 33 22 11
方法二：
public class ArrayReverse02 { public static void main(String[] args) { int[] arr = {11, 22, 33, 44, 55, 66, 20}; int[] temp = new int[arr.length]; for (int i = arr.length - 1, n = 0; i >= 0; i--, n++) { temp[n] = arr[i]; } //当for循环结束后，temp就是一个逆序的数组 //让arr指向temp数据空间，此时arr原来的数据空间就没有变量引用，会被当垃圾，销毁 arr = temp; System.out.println("反转后的数组"); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } } }
输出结果如下：
反转后的数组 20 66 55 44 33 22 11
3、数组的扩容
具体代码如下：
public class ArrayAdd2 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int[] arr = {1, 2, 3}; do { System.out.println("请输入你要添加的元素"); int addNum = scanner.nextInt(); int[] temp = add(arr, addNum); arr = temp; System.out.println("===扩容后的元素==="); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } System.out.println(); System.out.println("是否继续添加 y/n"); char key = scanner.next().charAt(0); if (key == 'n') {//如果输入n，就结束 break; } } while (true); System.out.println("你退出了添加..."); } private static int[] add(int[] arr, int n) { int[] temp = new int[arr.length + 1]; for (int i = 0; i < arr.length; i++) { temp[i] = arr[i]; } temp[temp.length - 1] = n; return temp; } }
输出结果如下：
请输入你要添加的元素 20 ===扩容后的元素=== 1 2 3 20 是否继续添加 y/n y 请输入你要添加的元素 30 ===扩容后的元素=== 1 2 3 20 30 是否继续添加 y/n n 你退出了添加...
三、二维数组的声明与初始化：
4.7 二维数组的理解：我们可以看成是一维数组arry1又作为另一个一维数组arry2的数组元素而存在
//静态初始化 int[][] arr=new int[][]{{1,2,3},{1,2},{4,5,7}}; //动态初始化1 String[][] arr1 = new String[2][3]; //动态初始化2 String[][] arr2 = new String[2][];
4.8.如何获取二维数组指定位置的元素：
//动态初始化1 String[][] arr1 = new String[2][3]; //动态初始化2 String[][] arr2 = new String[2][]; //获取指定位置的元素 System.out.println(arr[2][2]);//7 System.out.println(arr1[1][2]);//null
4.9.获取数组的长度
//获取数组的长度 System.out.println(arr.length); //3 System.out.println(arr[0].length);//3 System.out.println(arr[1].length);//2
4.10.遍历数组中的元素
//如何遍历数组的元素 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(); }
4.11.二维数组的默认初始化值:
规定：二维数组分为二维数组的元素，和内层数组的元素
例如:int[][] arr = new int[3][4];
外层数组元素：arr[0],arr[1],arr[2]…
内层数组元素：arr[1][2],arr[1][4]…
针对于初始化方式一：
int[][] arr = new int[4][3];
外层的初始化值为：地址值
内层的初始化值:跟一维数组的初始化相同
初始化方式二：
int[][] arr1 = new int[3][];
外层的初始化值为：null
内层的初始化值：不能调用
二维数组的详解：
public class TwoDimensionalArray01 { public static void main(String[] args) { int[][] arr = {{0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 2, 0, 3, 0, 0}, {0, 0, 0, 0, 0, 0}}; //关于二维数组的关键概念 //1. System.out.println("二维数组的元素个数：" + arr.length);//4 //2.二维数组的每个元素是一维数组，所以需要得到每个一维数组的值，还需要再次遍历 //3.如果我们要访问第(i+1)个一维数组的第j+1的值 为arr[i][j] //举例 访问3 他是第3个一维数组的第4个值 arr[2][3] System.out.println("第3个一维数组的第4个值为：" + arr[2][3]); for (int i = 0; i < arr.length; i++) {//遍历二维数组的每个元素 //遍历二维数组的每个元素(数组) //1.arr[i]表示二维数组的第i+1个元素 比如arr[0]:二维数组的第一个元素 //2.arr[i].length得到对应的，每个一维数组的长度 for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + " ");//输出了一维数组 } System.out.println(); //换行 } } }
输出结果如下：
二维数组的元素个数：4 第3个一维数组的第4个值为：3 0 0 0 0 0 0 0 0 1 0 0 0 0 2 0 3 0 0 0 0 0 0 0 0
二维数组的内存原理图如下：
public class TwoDimensionalArray02 { public static void main(String[] args) { // int[][] arr = new int[2][3]; //动态初始化 方式一 //动态初始化 方式二 int[][] arr; //声明二维数组 arr = new int[2][3]; //再开空间 arr[1][1] = 8; 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(); } } }
二维数组内存原理图
二维数组动态初始化，之列数不确定的方式详解
public class TwoDimensionalArray03 { public static void main(String[] args) { int[][] arr = new int[10][]; //创建二维数组，但是只是确定一维数组的个数，一维数组还没有开数据空间 for (int i = 0; i < arr.length; i++) {//遍历arr的每个一维数组 //给每个一维数组开空间 new //如果没有给一维数组 new ,那么arr[i] 就是null arr[i] = new int[i + 1]; //遍历一维数组，并给一维数组的每个元素赋值 for (int j = 0; j < arr[i].length; j++) { arr[i][j] = i + 1; //赋值 } } System.out.println("==arr元素=="); 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(); } } }
输出结果如下：
==arr元素== 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10
应用案例使用二维数组，打印10行的杨辉三角，代码如下：
具体代码如下：
public class YangHui { public static void main(String[] args) { int[] yangHui[] = new int[10][]; for (int i = 0; i < yangHui.length; i++) {//遍历yangHui的每个元素 //给每个一维数组(行)开辟空间 yangHui[i] = new int[i + 1]; //给每个一维数组(行) 赋值 for (int j = 0; j < yangHui[i].length; j++) { //每一行的第一个元素和最后一个元素都是1 if (j == 0 || j == yangHui[i].length - 1) { yangHui[i][j] = 1; } else {//中间的元素 yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1]; } } } //输出杨辉三角 for (int i = 0; i < yangHui.length; i++) { for (int j = 0; j < yangHui[i].length; j++) { System.out.print(yangHui[i][j] + "\t"); } System.out.println(); //换行 } } }
输出结果如下:
打印杨辉三角 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1
二维数组使用细节和注意事项：
