1 package cn.temptation;
2
3 public class Sample01 {
4 public static void main(String[] args) {
5 // 需求:一堆分数,要统计最高分、最低分、总分、平均分
6 // int score1 = 80;
7 // int score2 = 70;
8 // int score3 = 90;
9 // int score4 = 65;
10 // // ...
11 // // 以计算平均分为例
12 // double average = ((double)(score1 + score2 + score3 + score4)) / 4;
13 // System.out.println("平均分为:" + average);
14
15 // 问题:相同意义的变量定义了一大堆,觉得这样一点都不简洁
16
17 // 思考解决方案:运用抽象的思维,类比生活中使用的冰格,作为一个制作冰块的容器,其内部每一个格子中的冰块可以单独使用的,兼具了批量性 和 独立性
18 // 那么考虑制作一个存放分数的容器,且在这个分数容器中的每一个分数也可以单独使用
19
20 // 数组:Array,存储同一数据类型的多个元素的容器
21
22 // 注意:【数组是引用数据类型(引用类型),基本数据类型是值类型】
23 // 内存:根据处理的内容的不同,分为 堆栈(栈:stack) 和 堆(Heap)
24 // 值类型:存储在栈中
25 // 引用数据类型:声明存储在栈中,内容存储在堆中
26
27 // 数组的格式:
28 // 形式1:数据类型[] 数组名(硬性要求:大家使用这种形式):声明了一个xxx数据类型的数组,名字叫yyy
29 // 形式2:数据类型 数组名[]:声明了一个xxx数据类型,名字叫yyy的数组
30
31 // 声明一个成绩数组
32 // int[] scoreArr;
33 // int scoreArr[]; // 语法OK,但是不建议这样写
34
35 // 数组变量使用前必须进行初始化操作
36 // 语法错误:The local variable scoreArr may not have been initialized
37 // System.out.println(scoreArr);
38
39 // 数组初始化形式:
40 // 1、动态初始化:由使用者设置数组的长度,再填充元素
41 // 2、静态初始化:由使用者填充元素,由JDK计算数组的长度
42
43 // 动态初始化的格式:new 数据类型[数组的长度];
44 // A:new 关键字用来在内存的堆(Heap)中开辟一块空间
45 // B:数组的长度由使用者设置
46 // C:数组的下标(索引)用来表示数组中元素的位置,下标(索引)从0开始,到数组的长度-1结束
47
48 // 对于已经声明过的数组变量,进行动态初始化并赋值
49 // scoreArr = new int[3];
50
51 // 数组的初始化:可以把数组的声明 和 初始化 放在一行语句中执行
52 int[] scoreArr = new int[3];
53
54 // 下句输出 [I@15db9742 ,表示了scoreArr数组变量在内存中的类型 和 地址(以@符号作为分隔,前面是类型,后面是地址)
55 System.out.println(scoreArr); // [I@15db9742
56 }
57 }
1 package cn.temptation;
2
3 public class Sample02 {
4 public static void main(String[] args) {
5 // 数组的下标(索引)是从0开始的
6 // 数组的长度就是描述数组中元素的个数
7 // int[] arr = new int[3];
8 // arr[0] = 90; // 对数组中的第一个元素赋值为90
9
10 // 创建int类型的数组,向其中存放其他数据类型的元素,会发生什么现象?
11 // 向int类型的元素存放boolean类型的内容,语法出错
12 // 产生语法错误:Type mismatch: cannot convert from boolean to int
13 // arr[1] = true; // 对数组中的第二个元素赋值为true
14
15 // 向int类型的元素存放long类型的内容,语法出错
16 // 产生语法错误:Type mismatch: cannot convert from long to int
17 // arr[1] = 12345678901L;
18
19 // 向int类型的元素存放byte类型的内容,语法OK
20 // arr[1] = (byte)126;
21
22 // 向int类型的元素存放short类型的内容,语法OK
23 // arr[1] = (short)130;
24
25 // 【数组在内存中的存储形式】
26 // 赋值号左边的是数组的声明,类比名片
27 // 赋值号右边的是数组的内容,类比具体的家的位置
28 // 通过名片找到具体的家的位置
29 // 通过栈上声明的变量找到堆中具体存放内容的位置来使用数组
30
31 // System.out.println(arr); // [I@15db9742
32
33 // 数组中元素的默认值
34 // byte、short、int、long类型的数组的元素默认值为0
35 // int[] arr1 = new int[3];
36 // System.out.println(arr1[0]); // 0
37 // System.out.println(arr1[1]); // 0
38 // System.out.println(arr1[2]); // 0
39
40 // byte[] arr2 = new byte[3];
41 // System.out.println(arr2[0]); // 0
42 // System.out.println(arr2[1]); // 0
43 // System.out.println(arr2[2]); // 0
44 //
45 // short[] arr3 = new short[3];
46 // System.out.println(arr3[0]); // 0
47 // System.out.println(arr3[1]); // 0
48 // System.out.println(arr3[2]); // 0
49 //
50 // long[] arr4 = new long[3];
51 // System.out.println(arr4[0]); // 0
52 // System.out.println(arr4[1]); // 0
53 // System.out.println(arr4[2]); // 0
54
55 // double、float类型的数组的元素默认值为0.0
56 // double[] arr5 = new double[3];
57 // System.out.println(arr5[0]); // 0.0
58 // System.out.println(arr5[1]); // 0.0
59 // System.out.println(arr5[2]); // 0.0
60 //
61 // float[] arr6 = new float[3];
62 // System.out.println(arr6[0]); // 0.0
63 // System.out.println(arr6[1]); // 0.0
64 // System.out.println(arr6[2]); // 0.0
65
66 // char类型的数组的元素默认值为'\u0000'
67 // char[] arr7 = new char[3];
68 // System.out.println(arr7[0]); // '\u0000'
69 // System.out.println(arr7[1]); // '\u0000'
70 // System.out.println(arr7[2]); // '\u0000'
71
72 // boolean类型的数组的元素默认值为false
73 boolean[] arr8 = new boolean[3];
74 System.out.println(arr8[0]); // false
75 System.out.println(arr8[1]); // false
76 System.out.println(arr8[2]); // false
77 }
78 }
1 package cn.temptation;
2
3 public class Sample03 {
4 public static void main(String[] args) {
5 int[] scoreArr = new int[3];
6
7 System.out.println(scoreArr); // [I@15db9742
8 System.out.println(scoreArr[0]); // 0
9 System.out.println(scoreArr[1]); // 0
10 System.out.println(scoreArr[2]); // 0
11
12 System.out.println("-------------------------------------");
13
14 // 对数组中的部分元素进行赋值
15 scoreArr[0] = 80;
16 scoreArr[2] = 55;
17
18 // 1、数组的元素的值发生变化后,数组的地址没有变化
19 // 2、数组的元素的值发生变化后,数组中没有发生变化的元素的值还是之前的值
20 System.out.println(scoreArr); // [I@15db9742
21 System.out.println(scoreArr[0]); // 80
22 System.out.println(scoreArr[1]); // 0
23 System.out.println(scoreArr[2]); // 55
24 }
25 }
1 package cn.temptation;
2
3 public class Sample04 {
4 public static void main(String[] args) {
5 // 需求:把数组中的元素的值都显示出来
6 int[] scoreArr = new int[3];
7
8 // 下面的写法可以实现需求,但是使用起来很不方便
9 // System.out.println(scoreArr[0]);
10 // System.out.println(scoreArr[1]);
11 // System.out.println(scoreArr[2]);
12
13 // 看到有重复的操作,就想到了循环
14 // for (int i = 0; i < 3; i++) {
15 // System.out.println(scoreArr[i]);
16 // }
17
18 // 上面的写法不具备通用性,因为这里的数字3是硬编码,其实它应该表示为数组的长度(数组中元素的个数)
19
20 // 通过使用 数组名.length 可以获取到数组的长度
21 // System.out.println("数组的长度为:" + scoreArr.length);
22
23 // 下面的写法就具备通用性(注意:eclipse中提供的for语句块结构:iterate over array,即在数组上进行迭代)
24 // for (int i = 0; i < scoreArr.length; i++) {
25 // System.out.println(scoreArr[i]);
26 // }
27
28 // 还有更加简单的写法,使用增强型for循环-----> foreach
29 // 增强型for循环的格式:for(数据类型 遍历变量名(迭代变量名) : 被遍历变量名(被迭代变量名)) { ... }
30 // for (int i : scoreArr) {
31 // System.out.println(i);
32 // }
33
34 // 注意:遍历变量名(迭代变量名)可以由使用者自己定义名称
35 // for (int item : scoreArr) {
36 // System.out.println(item);
37 // }
38
39 // 产生错误:Type mismatch: cannot convert from element type int to byte
40 // for (byte i : scoreArr) {
41 // System.out.println(i);
42 // }
43
44 // 产生错误:Type mismatch: cannot convert from element type int to short
45 // for (short i : scoreArr) {
46 // System.out.println(i);
47 // }
48
49 // 语法OK
50 // for (long i : scoreArr) {
51 // System.out.println(i);
52 // }
53
54 // 总结:被遍历的变量名的数据类型,认为其内部的元素也是该数据类型的,那么用范围比它大的数据类型接收时是可以的
55 // 用范围比它小的数据类型接收时就会抱语法错误
56
57 // 需求:使用循环和数组长度等技术点,制作一个方法printArray,用来打印数组中的元素,要求显示为[元素1的值, 元素2的值, ... 元素n的值]
58 printArray(scoreArr);
59 }
60
61 /**
62 * 打印数组方法
63 * @param arr:int类型的数组
64 */
65 public static void printArray(int[] arr) {
66 // 最左边先打印出一个"["
67 System.out.print("[");
68
69 // 遍历数组
70 for (int i = 0; i < arr.length; i++) {
71 if (i == arr.length - 1) { // 数组中的最后一个元素,加上"]"
72 System.out.print(arr[i] + "]");
73 } else { // 数组中的其他元素,加上","
74 System.out.print(arr[i] + ",");
75 }
76 }
77
78 // 换行
79 System.out.println();
80 }
81 }
1 package cn.temptation;
2
3 public class Sample05 {
4 public static void main(String[] args) {
5 int[] arr = new int[3];
6 arr[0] = 10;
7 arr[1] = 21;
8 arr[2] = 30;
9
10 // 需求:制作一个方法getMaxItem,获取数组中的最大元素值
11 int maxItem = getMaxItem(arr);
12 System.out.println("数组中最大的元素为:" + maxItem);
13
14 // 需求:制作一个方法getMinItem,获取数组中的最小元素值
15 int minItem = getMinItem(arr);
16 System.out.println("数组中最小的元素为:" + minItem);
17
18 // 需求:制作一个方法getTotal,获取数组中的元素的总和
19 int total = getTotal(arr);
20 System.out.println("数组中元素的总和为:" + total);
21
22 // 需求:制作一个方法getAverage,获取数组中的元素的平均值
23 double average = getAverage(arr);
24 System.out.println("数组中元素的平均值为:" + average);
25 }
26
27 /**
28 * 获取数组中的最大元素值
29 * @param arr:数组
30 * @return:最大的元素值
31 *
32 * 思路:使用穷举思路
33 * 1、先设置一个作为比较的标杆,从数组中拿出一个元素认为它是最大的
34 * 2、把数组中的其他元素与之进行比较
35 * 3、如果有其他的元素比作为标杆的元素大,则替换之
36 * 4、比较完成后,就可以得到数组中的最大元素
37 */
38 public static int getMaxItem(int[] arr) {
39 int tempMax = arr[0];
40
41 // 遍历数组
42 for (int i = 0; i < arr.length; i++) {
43 if (arr[i] > tempMax) {
44 tempMax = arr[i];
45 }
46 }
47
48 return tempMax;
49 }
50
51 /**
52 * 获取数组中的最小元素值
53 * @param arr:数组
54 * @return:最小的元素值
55 */
56 public static int getMinItem(int[] arr) {
57 int tempMin = arr[0];
58
59 // 遍历数组
60 for (int i = 0; i < arr.length; i++) {
61 if (arr[i] < tempMin) {
62 tempMin = arr[i];
63 }
64 }
65
66 return tempMin;
67 }
68
69 /**
70 * 获取数组中的元素值的总和
71 * @param arr:数组
72 * @return:数组中元素的总和
73 */
74 public static int getTotal(int[] arr) {
75 int total = 0;
76
77 // 遍历数组
78 for (int i = 0; i < arr.length; i++) {
79 total += arr[i];
80 }
81
82 return total;
83 }
84
85 /**
86 * 获取数组中的元素值的平均值
87 * @param arr:数组
88 * @return:数组中元素的平均值
89 */
90 public static double getAverage(int[] arr) {
91 double total = 0.0;
92
93 for (int i = 0; i < arr.length; i++) {
94 total += arr[i];
95 }
96
97 return total / arr.length;
98 }
99 }
1 package cn.temptation;
2
3 public class Sample06 {
4 public static void main(String[] args) {
5 int[] arr1 = new int[3];
6 arr1[0] = 80;
7 arr1[2] = 55;
8
9 int[] arr2 = new int[3];
10 arr2[0] = 80;
11 arr2[2] = 55;
12
13 System.out.println("数组1的地址:" + arr1); // [I@15db9742
14 printArray(arr1);
15
16 System.out.println("数组2的地址:" + arr2); // [I@6d06d69c
17 printArray(arr2);
18
19 System.out.println("----- 修改元素值 -----");
20
21 arr2[0] = 38;
22 arr2[1] = 100;
23
24 System.out.println("数组1的地址:" + arr1); // [I@15db9742
25 printArray(arr1);
26
27 System.out.println("数组2的地址:" + arr2); // [I@6d06d69c
28 printArray(arr2);
29
30 // 不同的数组,元素的值相同,修改后,对其他数组中的元素的值无影响
31 // 因为不同的数组中的元素存放在内存的堆中不同的空间里
32
33 // 从运行的结果得知:
34 // 【只要使用了new关键字,就在内存的堆中开辟了新的空间】
35 }
36
37 /**
38 * 打印数组方法
39 * @param arr:int类型的数组
40 */
41 public static void printArray(int[] arr) {
42 // 最左边先打印出一个"["
43 System.out.print("[");
44
45 // 遍历数组
46 for (int i = 0; i < arr.length; i++) {
47 if (i == arr.length - 1) { // 数组中的最后一个元素,加上"]"
48 System.out.print(arr[i] + "]");
49 } else { // 数组中的其他元素,加上","
50 System.out.print(arr[i] + ",");
51 }
52 }
53
54 // 换行
55 System.out.println();
56 }
57 }
1 package cn.temptation;
2
3 public class Sample07 {
4 public static void main(String[] args) {
5 int[] arr1 = new int[3];
6 arr1[0] = 80;
7 arr1[2] = 55;
8
9 // 注意:下句语句体现了引用数据类型的特点
10 int[] arr2 = arr1;
11
12 System.out.println("数组1的地址:" + arr1); // [I@15db9742
13 printArray(arr1);
14
15 System.out.println("数组2的地址:" + arr2); // [I@15db9742
16 printArray(arr2);
17
18 System.out.println("----- 修改元素值 -----");
19
20 arr2[0] = 38;
21 arr2[1] = 100;
22
23 System.out.println("数组1的地址:" + arr1); // [I@15db9742
24 printArray(arr1);
25
26 System.out.println("数组2的地址:" + arr2); // [I@15db9742
27 printArray(arr2);
28
29 // 从运行的结果得知:
30 // 1、只要使用了new关键字,就在内存的堆中开辟了新的空间
31 // 2、引用数据类型在做值传递时,传递的是引用
32 }
33
34 /**
35 * 打印数组方法
36 * @param arr:int类型的数组
37 */
38 public static void printArray(int[] arr) {
39 // 最左边先打印出一个"["
40 System.out.print("[");
41
42 // 遍历数组
43 for (int i = 0; i < arr.length; i++) {
44 if (i == arr.length - 1) { // 数组中的最后一个元素,加上"]"
45 System.out.print(arr[i] + "]");
46 } else { // 数组中的其他元素,加上","
47 System.out.print(arr[i] + ",");
48 }
49 }
50
51 // 换行
52 System.out.println();
53 }
54 }
1 package cn.temptation;
2
3 public class Sample08 {
4 public static void main(String[] args) {
5 // 值类型的特点
6
7 // int i = 2;
8 // int j = 2;
9 //
10 // System.out.println("i的值为:" + i);
11 // System.out.println("j的值为:" + j);
12 //
13 // System.out.println("----- 修改元素值 -----");
14 //
15 // j = 3;
16 //
17 // System.out.println("i的值为:" + i);
18 // System.out.println("j的值为:" + j);
19
20 int i = 2;
21 int j = i;
22
23 System.out.println("i的值为:" + i);
24 System.out.println("j的值为:" + j);
25
26 System.out.println("----- 修改元素值 -----");
27
28 j = 3;
29
30 System.out.println("i的值为:" + i);
31 System.out.println("j的值为:" + j);
32
33 // 值类型的特点
34 // 存储在栈上,没有栈和堆之间的指向引用,变化只影响自身
35 }
36 }
1 package cn.temptation;
2
3 public class Sample09 {
4 public static void main(String[] args) {
5 // 数组初始化
6 // 静态初始化:由使用者填充数组的元素,由JDK自动判定数组的长度
7
8 // 静态初始化的格式:
9 // 1、简写形式:{ 元素1, 元素2, ... 元素n}
10 // 2、完整形式:new 数据类型[] { 元素1, 元素2, ... 元素n}
11
12 // 简写形式
13 int[] arr1 = { 10, 20, 30 };
14 System.out.println("数组的长度为:" + arr1.length);
15
16 // 完整形式
17 int[] arr2 = new int[] { 10, 20, 30 };
18 System.out.println("数组的长度为:" + arr2.length);
19
20 // 遍历数组中的元素
21 // 方式1:一般for循环
22 for (int i = 0; i < arr1.length; i++) {
23 System.out.println(arr1[i]);
24 }
25
26 // 方式2:增强型for循环
27 for (int item : arr2) {
28 System.out.println(item);
29 }
30
31 // 注意:
32 // 1、静态初始化的简写形式看起来没有new,但是实际上还是做了new的操作,还是在内存的堆上开辟了空间
33 // 2、数组的初始化有两种形式,使用时只能选择一种形式使用,不能混搭
34
35 // 混搭动态初始化和静态初始化会产生语法错误
36 // 产生语法错误:Cannot define dimension expressions when an array initializer is provided
37 // int[] arr3 = new int[3] { 10, 20, 30 };
38 }
39 }
1 package cn.temptation;
2
3 public class Sample10 {
4 public static void main(String[] args) {
5 // 1、下面语句是否在内存的堆中开辟了空间? 答:new出了空间,地址为15db9742
6 // 2、下面这个数组长度是多少? 答:数组长度为0
7 // 3、如何为这个数组填充元素并给元素赋值?
8 int[] arr = {};
9
10 System.out.println(arr); // [I@15db9742
11 System.out.println("数组的长度为:" + arr.length); // 0
12
13 // 遍历数组
14 for (int i = 0; i < arr.length; i++) {
15 System.out.println(arr[i]);
16 }
17
18 for (int item : arr) {
19 System.out.println(item);
20 }
21
22 // 下句执行时会产生异常:java.lang.ArrayIndexOutOfBoundsException: 0,数组索引越界异常
23 // 因为当前arr数组中一个元素都没有,而下句语句要给第一个元素进行赋值,自然出现数组索引越界异常
24 // arr[0] = 10;
25 // 下句执行时会产生异常:java.lang.ArrayIndexOutOfBoundsException: 10,数组索引越界异常
26 // arr[10] = 99;
27 // 由上面的语句得知java.lang.ArrayIndexOutOfBoundsException后的数字指的是越界元素对应的索引
28
29 // 考虑1、考虑设置数组arr的length属性
30 // 语法错误:The final field array.length cannot be assigned
31 // 数组的length属性可以被读取,但是不可以被修改
32 // arr.length = 3;
33
34 // 考虑2、张冠李戴
35 // 通过创建一个新的数组,在堆中开辟一块新的空间,然后把指向之前开辟出的空间的引用(arr的栈堆之间的引用)改为指向新开辟的空间的引用
36 int[] arrExtend = { 10, 20, 30 };
37 arr = arrExtend;
38
39 // 遍历数组
40 for (int i = 0; i < arr.length; i++) {
41 System.out.println(arr[i]);
42 }
43
44 for (int item : arr) {
45 System.out.println(item);
46 }
47 }
48 }