Java中一维数组和二维数组的详解
博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
点击跳转到网站
一、数组的概述：
-
数组的理解：数组(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
二维数组使用细节和注意事项：
