数组：
1数组:
2格式
3数组的特点
(1)数组的本质
(2)数组的初始化
*回顾变量初始化
**数组的初始化
(3) 数据类型相同
(4)数组的内存分配
(5)访问数组的元素
4异常
5数组的初始化
(1)静态初始化
(2) 动态初始化
6数组最大值
7数组的倒置
8数组的查找
(1)数组的基本查找
(2)二分法查找
(3)冒泡排序法
9foreach 数组/集合专用遍历器
10可变参数
11 Arrays数组工具类
12数组的动态扩容
13数组的增删查改
14多维数组
(1)访问二维数组的格式:
*格式一:
**格式二：
(2)二维数组的静态初始化
1数组:
数组属于引用类型,数组的本质就是一个容器,存放一组相同数据类型变量的数据容器
1
2格式
数据类型[] 数组名; // Java语法
变式: 数据类型 数组名[]; // C语言
1
2
3数组的特点
(1)数组的本质
就是一个引用类型的变量,既然是一个变量就必须满足先声明再赋值再使用
1
(2)数组的初始化
*回顾变量初始化
a.声明: 告诉计算机开辟多大的内存空间
b.赋值: 找到变量所对应的内存地址,将数据保存到地址多标识的空间中去
c.使用: 通过地址找到空间,将数据取出,进行使用再重新保存到原空间中
1
2
3
**数组的初始化
a.声明: 告诉计算机开辟多大的连续内存空间
b.赋值:
c.使用:
1
2
3
(3) 数据类型相同
数组名实际就是一个变量，既然是变量就必须先赋值再使用
数组的每一个元素既可以是基本数据类型也可以是引用数据类型
1
2
(4)数组的内存分配
数据类型[] 数组名 = new 数据类型[长度];
1
(5)访问数组的元素
arr[下标/索引]
1
4异常
java.lang.NullPointerException
异常名称: 空指针异常
产生原因: 对象没有new就访问了对象的成员
解决办法: new
java.lang.ArrayIndexOutOfBoundsException
异常名称: 数组越界
产生原因: 访问了不在数组定义范围内的索引
解决办法: 检查索引是否超出了数组定义的范围
5数组的初始化
(1)静态初始化
格式一: 数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3,...元素n};
格式二: 数据类型[] 数组名 = {元素1,元素2,元素3,...元素n};
1
2
(2) 动态初始化
格式:数据类型[] 数组名 = new 数据类型[长度];
1
注意:
有了格式二为什么还需要格式一: 格式一用作匿名对象(后面讲解面向对象讲解),格式二用作初始化
静态初始化和动态初始化的区别:
静态初始化在初始化的同时会给每一个元素赋值,不需要指定数组的长度,系统会自动根据元素的个数去动态计算数组的长度
动态初始化在初始化的同时由系统分配默认值,但是必须指定数组的长度
#数组的遍历
获取每一个元素
import java.util.Arrays;
/*
* 数组的遍历: 获取每一个元素
*
* 开闭原则: 对扩展开放,对修改关闭
*/
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arr;
arr = new int[] { 11, 22, 33, 44, 55 };
// arr[0] = 0.5;
// 方法一
// System.out.println(arr[0]);
// System.out.println(arr[1]);
// System.out.println(arr[2]);
// System.out.println(arr[3]);
// System.out.println(arr[4]);
// System.out.println(arr[5]);
System.out.println("=========================");
// 方法二:利用循环改进
// for (int i = 0; i < 6; i++) {
// System.out.println(arr[i]);
// }
System.out.println("=========================");
// System.out.println(arr.length);
// for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
// }
// printArray(arr);
// System.out.println(arrayToString(arr));
System.out.println(Arrays.toString(arr));
}
/*
* 功能: 遍历数组
* 返回值类型: void
* 参数列表: int[] arr
* 方法名: printArray
*/
// 方法三
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void printArray(double[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
/*
* [11, 22, 33, 44, 55]
* 功能: 遍历数组
* 返回值类型: String
* 参数列表: int[] arr
* 方法名: arrayToString
*
* 思路:
* 1.拼接[
* 2.遍历数组获取到每一个元素
* 3.拼接元素
* 如果是最后一个元素,只拼接元素
* 否则拼接元素 + ", "
* 4.拼接]
*/
public static String arrayToString(int[] arr) {
String result = "";
// 1.拼接[
result += "["; // result = result + "[";
// 2.遍历数组获取到每一个元素
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
// 如果是最后一个元素,只拼接元素
result += arr[i];
} else {
// 否则拼接元素 + ", "
result += arr[i] + ", ";
}
}
// 4.拼接]
result += "]";
return result;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
6数组最大值
/*
* 功能: 求出最大值。 返回值类型: int 参数列表: int[] arr 方法名: getMaxValue
*
* 1.假设第一个数为最大值 2.让第一个数和后面每一个数进行比较 3.如果发现后面有一个数大于这个假定的最大值 4.那么就将这个数设置为假定的最大值
* 5.循环结束之后，最大值就出来
*/
public static int getMaxValue(int[] arr) {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
public static int getMinValue(int[] arr) {
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
return min;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
7数组的倒置
/*
* 功能: 将数组倒置并输出
* 返回值类型: void
* 参数列表: int[] arr
* 方法名: reverseArray
*
* 11, 22, 33, 44, 55 第一个数和最后一个数交换位置
* arr[0] arr[arr.length - 1 - 0] int temp = 0;
* temp = arr[0];
* arr[0] = arr[arr.length - 1 - 0];
* arr[arr.length - 1] =temp;
* 第二个数和倒数第二个数交换位置
* arr[1] arr[arr.length - 1 - 1] int temp = 0;
* temp =arr[1]; arr[1] = arr[arr.length - 1 - 1];
* arr[arr.length - 1 - 1] = temp;
*
* arr[2] arr[arr.length - 1 - 2] 交换的次数 如果arr.length = 5, 交换2次 如果arr.length = 6,
* 交换3次 如果arr.length = 7, 交换3次 如果arr.length = 8, 交换4次 i arr.length / 2次
*/
public static void reverseArray(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = 0;
temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
8数组的查找
(1)数组的基本查找
/*
* E 数组查找 猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数。
* 返回值类型: boolean
* 参数列表: int[] arr, int num
* 方法名: basicSearch
*/
public static boolean basicSearch(int[] arr, int num) {
boolean flag = false;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
flag = true;
break;
}
}
return flag;
}
public static int basicSearch2(int[] arr, int num) {
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
index = i;
break;
}
}
return index;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
(2)二分法查找
/*
* 二分法查找
* 返回值类型: int
* 参数列表: int[] arr, int num
* 方法名: binarySearch
*/
public static int binarySearch(int[] arr, int num) {
// 1.定义最小索引和最大索引
int min = 0;
int max = arr.length - 1;
// 2.计算中间索引
int mid = (min + max) / 2;
while (arr[mid] != num) {
/*
* 中间索引所对应的数值 > num 左边找
* 中间索引所对应的数值 < num 右边找
*/
if (arr[mid] > num) {
max = mid - 1;
} else if (arr[mid] < num) {
min = mid + 1;
}
if (min > max) {
return -1;
}
mid = (min + max) / 2;
}
// 返回中间索引
return mid;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
(3)冒泡排序法
规律:
* 1.相邻两个数进行比较,大的数冒泡,交换两个数的位置
* 2.一共比较了arr.length - 1趟
* 3.每一趟比上一趟少比较1次
*/
public class ArrayDemo08 {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 55, 13};
System.out.println("冒泡排序前:" + Arrays.toString(arr));
// 第一趟排序
/*
* arr[0] arr[1] 比较
* arr[1] arr[2] 比较
* arr[2] arr[3] 比较
* arr[3] arr[4] 比较
*
* 如果左边的大于右边的就交换两个数的位置
* 一共比较了4次
*/
/*for (int i = 0; i < arr.length - 1 - 0; i++) {
if (arr[i] > arr[i+1]) {
int temp = 0;
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第一趟排序后:" + Arrays.toString(arr));
for (int i = 0; i < arr.length - 1 - 1; i++) {
if (arr[i] > arr[i+1]) {
int temp = 0;
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第二趟排序后:" + Arrays.toString(arr));
for (int i = 0; i < arr.length - 1 - 2; i++) {
if (arr[i] > arr[i+1]) {
int temp = 0;
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第三趟排序后:" + Arrays.toString(arr));
for (int i = 0; i < arr.length - 1 - 3; i++) {
if (arr[i] > arr[i+1]) {
int temp = 0;
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第四趟排序后:" + Arrays.toString(arr));*/
System.out.println("=========================");
/*for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j+1]) {
int temp = 0;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}*/
bubbleSort(arr);
System.out.println("冒泡排序后:" + Arrays.toString(arr));
}
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = 0;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
9foreach 数组/集合专用遍历器
foreach遍历数组
集合和数组专属遍历方式,底层还是使用普通for遍历
格式:
for(数据类型 变量名: 数组名/集合名){
}
普通for和foreach的区别
1.简化了遍历
2.没有索引
public class ArrayDemo11 {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for(int i : arr) {
System.out.println(i);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
10可变参数
针对参数类型相同但是参数的个数不同的情况非常方便
可变参数: 是一种形参类型，本质就是数组,用来接收个数不同但是类型相同的多个参数
可变参数的格式: 数据类型… 参数名
可变参数的注意事项
1.可变参数本质是数组
2.可变参数的…可以放在参数类型和变量名中间的任意位置
3.可变参数必须出现参数列表的最后面
public class ArrayDemo12 {
public static void main(String[] args) {
// System.out.println(add(10, 20)); // [I@7852e922
// System.out.println(add(10, 20, 30));
// System.out.println(add(10, 20, 30, 40));
int[] arr = {11, 22, 33, 44};
int[] arr2 = {55,66};
add(arr, arr2);
}
// public static int add(int... args) {
//// System.out.println("我是可变参数的方法");
//// System.out.println(args);
// int sum = 0;
// for(int i : args) {
// sum += i;
// }
// return sum;
// }
// public static int add(double d, int... args) {
//// System.out.println("我是可变参数的方法");
//// System.out.println(args);
// int sum = 0;
// for(int i : args) {
// sum += i;
// }
// return sum;
// }
public static int add(int[]... args) {
// System.out.println("我是可变参数的方法");
// System.out.println(args);
// int sum = 0;
// for(int i : args) {
// sum += i;
// }
// return sum;
System.out.println(args);
return 0;
}
public static void show(String... args) {
}
// 计算两个数的和
// public static int add(int a, int b) {
// System.out.println("ArrayDemo12.add(a,b)");
// return a + b;
// }
//
// // 计算三个数的和
// public static int add(int a, int b, int c) {
// System.out.println("ArrayDemo12.add(a,b,c)");
// return a + b + c;
// }
//
// public static int add(int a, int b, int c, int d) {
// System.out.println("ArrayDemo12.add(a,b,c,d)");
// return a + b + c + d;
// }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
11 Arrays数组工具类
ublic class ArrayDemo03 {
public static void main(String[] args) {
int[] arr = {22, 11, 66, 88, 99, 44};
// Arrays的遍历输出方法
System.out.println(Arrays.toString(arr));
// Arrays的排序方法
// Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// Arrays的二分法查找方法
int index = Arrays.binarySearch(arr, 88);
System.out.println(index);
// System的arraycopy方法,这是一个本地方法,底层不由Java实现,由C语言实现
int[] dest = {100, 200, 300};
// Object src, int srcPos,Object dest, int destPos, int length
System.arraycopy(arr, 1, dest, 0 ,3);
System.out.println(Arrays.toString(dest));
// 复制数组
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println(Arrays.toString(newArr));
// 数组扩容
int[] newArr2 = Arrays.copyOf(arr, arr.length + 1);
System.out.println(Arrays.toString(newArr2));
// 缩小数组的容量
int[] newArr3 = Arrays.copyOf(arr, arr.length - 2);
System.out.println(Arrays.toString(newArr3));
// 填充数组
// Arrays.fill(arr, 100);
// System.out.println(Arrays.toString(arr));
// 填充数组的一部分 左闭右开原则
// Arrays.fill(arr, 2, 4, 100);
// System.out.println(Arrays.toString(arr));
int[] copyArr = Arrays.copyOfRange(arr, 2, 5);
System.out.println(Arrays.toString(copyArr));
int[] arr1 = {11, 22, 33, 44};
int[] arr2 = {11, 22, 33, 44};
System.out.println(Arrays.equals(arr1, arr2));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
12数组的动态扩容
package com.sxt.arraydemo;
import java.util.Arrays;
/*
* 数组的扩容和缩容
* 动态扩容
* 1.使用for循环复制元素扩容
* 缺陷: 拷贝一部分元素需要计算索引,比较复杂
* 2.System.arracopy()扩容
* 缺陷: 拷贝数组的一部分到目标数组,如果长度超过了目标数组的索引,会抛出异常
* 3.Arrays.copyOf扩容
* 观察copyOf方法的源码:
* public static int[] copyOf(int[] original, int newLength) {
* int[] copy = new int[newLength];
* System.arraycopy(original, 0, copy, 0,
* Math.min(original.length, newLength));
* return copy;
* }
* 4.利用Object类中一个 clone 方法,该方法是真正意义上的复制数组
*/
public class ArrayDemo04 {
public static void main(String[] args) {
int[] src = { 11, 22, 33, 44 };
int[] desc = new int[10];
// 1.使用for循环复制元素扩容
// for (int i = 0; i < src.length; i++) {
// desc[i] = src[i];
// }
// System.out.println(Arrays.toString(desc));
// 2.System.arracopy()扩容
// System.arraycopy(src, 0, desc, 7, src.length); // 数组越界
// System.out.println(Arrays.toString(desc));
// 3.Arrays.copyOf扩容
int[] descArr = Arrays.copyOf(src, src.length + 5);
System.out.println(Arrays.toString(descArr));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
13数组的增删查改
实现的功能:
增加add 插入 insert 删除 delete 修改 update 查询 get
package com.sxt.arraydemo;
import java.util.Arrays;
/*
* 自定义工具类 MyArrays
*/
public class MyArrays {
static int[] srcArr;
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
setArr(arr);
System.out.println("源数组: " + Arrays.toString(srcArr));
add(66);
System.out.println("add: " + Arrays.toString(srcArr));
insert(2, 88);
System.out.println("insert: " + Arrays.toString(srcArr));
delete(5);
System.out.println("delete: " + Arrays.toString(srcArr));
update(0, 100);
System.out.println("update: " + Arrays.toString(srcArr));
System.out.println("get: " + get(0));
}
/*
* 功能: 用于外界传入一个数组来初始化我这个全局变量的数据
* 返回值类型: void
* 参数列表: int[] arr;
* 方法名: setArr
*/
public static void setArr(int[] arr) {
srcArr = arr;
}
/*
* 功能: 在数组的末尾添加一个元素
* 返回值类型: void
* 参数列表: int num
* 方法名: add
* 1.创建一个新的数组,长度+1
* 2.将源数组的元素全部复制到目标数组中
* 3.在目标数组的末尾添加元素
* 4.地址传递
*/
public static void add(int num) {
int[] descArr = Arrays.copyOf(srcArr, srcArr.length + 1);
descArr[descArr.length - 1] = num;
srcArr = descArr;
}
/*
* 功能: 在数组的指定索引位置插入一个元素
* 返回值类型: void
* 参数列表: int index, int num
* 方法名: insert
* 1.创建一个新的数组,长度+1
* 2.插入位置前面的元素原封复制到目标数组中
* 3.将num这个元素插入到索引位置
* 4.将索引后面的元素复制到目标数组
* 5.地址传递
*/
public static void insert(int index, int num) {
int[] descArr = new int[srcArr.length + 1];
System.arraycopy(srcArr, 0, descArr, 0, index);
descArr[index] = num;
System.arraycopy(srcArr, index, descArr, index + 1, srcArr.length - index);
srcArr = descArr;
}
/*
* 功能: 在数组的指定索引位置删除一个元素
* 返回值类型: void
* 参数列表: int index
* 方法名: delete
* 1.创建一个新的数组,长度-1
* 2.删除位置前面的元素原封复制到目标数组中
* 3.将源数组索引后面的元素覆盖复制到目标数组中
* 4.地址传递
*/
public static void delete(int index) {
int[] descArr = new int[srcArr.length - 1];
System.arraycopy(srcArr, 0, descArr, 0, index);
System.arraycopy(srcArr, index + 1, descArr, index, descArr.length - index);
srcArr = descArr;
}
/*
* 修改数组中对应索引的元素
* 返回值类型: void
* 参数列表: int index, int num
* 方法名: update
*/
public static void update(int index, int num) {
srcArr[index] = num;
}
/*
* 查询数组中对应索引的元素
* 返回值类型: int
* 参数列表: int index
* 方法名: get
*/
public static int get(int index) {
return srcArr[index];
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
14多维数组
/*
* 多维数组本质也是一维数组
* 二维数组
* 本质就是存放了一维数组的数组
*
* 格式1:
* 数据类型[] 数组名 = new 数据类型[数组的长度];
* 数据类型[][] 数组名 = new 数据类型[m][n];
* m: 二维数组中一维数组的长度。m必不可少
* n: 每一个一维数组中元素的个数。n可以省略
*
* int[][] arr = new int[3][2];
* 表示arr中有3个一维数组,每一个一维数组有2个元素
*
* 变式:
* 数据类型 数组名[][] = new 数据类型[m][n];
* 数据类型[] 数组名[] = new 数据类型[m][n];
*
* 面试题:
* int[] x,y[],z[][]; 表示1个一维数组,1一个二维数组,1个三维数组
*
* int[] x;
* int[] y[];
* int[] z[][];
*
* 格式2:
* 数组类型[][] 数组名 = new 数据类型[m][];
* m: 二维数组中一维数组的长度
* n: m必不可少,n可省略,表示每一个一维数组的元素个数不确定
* 可以后期动态地改变每一个一维数组元素的个数
*
* int a=2,b=2,c;
*/
public class TwoArrayDemo01 {
public static void main(String[] args) {
int[][] arr = new int[3][2];
int[] arr2[] = new int[3][3];
int[] x,y[],z[][]; // 1
int n[] = new int[2],i,j,k;
/*
* int n[] = new int[2];
* int i;
* int j;
* int k;
*/
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
(1)访问二维数组的格式:
*格式一:
数据类型[][] 数组名 = new 数据类型[m][n];
注意: m必不可少,n可省略
数组名[m][n];
1
2
3
public class TwoArrayDemo02 {
public static void main(String[] args) {
int[][] arr = new int[3][2];
System.out.println(arr); // 地址 [[I@7852e922
System.out.println(arr[0]); // 地址 [I@4e25154f
System.out.println(arr[1]); // 地址 [I@70dea4e
System.out.println(arr[2]); // 地址 [I@5c647e05
// System.out.println(arr[3]); // 数组越界
System.out.println(arr[0][0]); // 0
System.out.println(arr[0][1]); // 0
System.out.println(arr[1][0]); // 0
// System.out.println(arr[1][2]); // 数组越界
arr[0][0] = 100;
arr[0][1] = 200;
arr[1][0] = 300;
System.out.println(arr[0][0]); // 100
System.out.println(arr[0][1]); // 200
System.out.println(arr[1][0]); // 300
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
**格式二：
二维数组的格式2的内存图
数据类型[][] 数组名 = new 数据类型[m][];
1
2
public class TwoArrayDemo03 {
public static void main(String[] args) {
int[][] arr = new int[3][];
System.out.println(arr); // 地址
arr[0] = new int[3];
arr[1] = new int[2];
arr[2] = new int[1];
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]); // 0
System.out.println(arr[0][1]); // 0
System.out.println(arr[1][0]); // 0
// System.out.println(arr[1][2]); // 数组越界
arr[0][0] = 100;
arr[0][1] = 200;
arr[1][0] = 300;
arr[2][0] = 400;
System.out.println(arr[0][0]); // 100
System.out.println(arr[0][1]); // 200
System.out.println(arr[1][0]); // 300
System.out.println(arr[2][0]); // 400
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
(2)二维数组的静态初始化
二维数组的静态初始化
1
public class TwoArrayDemo04 {
public static void main(String[] args) {
int[][] arr = {{11,22,33}, {44,55}, {66,77,88,99}};
// 遍历第一个一维数组
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[0][2]);
for (int i = 0; i < arr[0].length; i++) {
System.out.println(arr[0][i]);
}
// 遍历第二个一维数组
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
for (int i = 0; i < arr[1].length; i++) {
System.out.println(arr[1][i]);
}
// 遍历第三个一维数组
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println(arr[2][2]);
System.out.println(arr[2][3]);
for (int i = 0; i < arr[2].length; i++) {
System.out.println(arr[2][i]);
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
---------------------
作者：lyk1599021827
来源：CSDN
原文：https://blog.csdn.net/lyk1599021827/article/details/89323476
版权声明：本文为博主原创文章，转载请附上博文链接！
