1 package cn.temptation;
2
3 import java.util.Scanner;
4
5 public class Sample01 {
6 public static void main(String[] args) {
7 // 需求：定义一个数组存储星期一、星期二、...星期日，打印该数组形式为[星期一, 星期二, ...星期日]，根据用户输入的数字（1~7），显示是星期几？
8
9 // 写法一、考虑使用字符串类型的数组
10 // // 1、创建一个数组来存储星期一、星期二、...星期日
11 // String[] weekDayArr = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
12 // printArray(weekDayArr);
13 //
14 // // 2、接收键盘录入
15 // System.out.println("输入一个数字就可以找到对应是星期几：");
16 // Scanner input = new Scanner(System.in);
17 // int weekDay = input.nextInt();
18 // input.close();
19 //
20 // // 3、判断输入的数字和数组中某个元素的索引之间的关系
21 // if (weekDay >= 1 && weekDay <= 7) {
22 // System.out.println("选择的是：" + weekDayArr[weekDay - 1]);
23 // } else {
24 // System.out.println("输入的数字不在范围内！");
25 // }
26
27 // 写法二、考虑使用int类型的数组
28 // 1、创建一个数组来存储星期一、星期二、...星期日
29 int[] weekDayArr = { 1, 2, 3, 4, 5, 6, 7 };
30 printArray(weekDayArr);
31
32 // 2、接收键盘录入
33 System.out.println("输入一个数字就可以找到对应是星期几：");
34 Scanner input = new Scanner(System.in);
35 int weekDay = input.nextInt();
36 input.close();
37
38 // 3、判断输入的数字和数组中某个元素的索引之间的关系
39 if (weekDay >= 1 && weekDay <= 7) {
40 System.out.println("选择的是：" + convertNumberToString(weekDayArr[weekDay - 1]));
41 } else {
42 System.out.println("输入的数字不在范围内！");
43 }
44 }
45
46 /**
47 * 打印数组
48 * @param arr：字符串数组
49 */
50 public static void printArray(String[] arr) {
51 System.out.print("[");
52
53 // 遍历数组
54 for (int i = 0; i < arr.length; i++) {
55 if (i == arr.length - 1) {
56 System.out.print(arr[i] + "]");
57 } else {
58 System.out.print(arr[i] + ",");
59 }
60 }
61
62 // 换行
63 System.out.println();
64 }
65
66 /**
67 * 打印数组（重载方法）
68 * @param arr：int数组
69 */
70 public static void printArray(int[] arr) {
71 System.out.print("[");
72
73 // 遍历数组
74 for (int i = 0; i < arr.length; i++) {
75 if (i == arr.length - 1) {
76 System.out.print(arr[i] + "]");
77 } else {
78 System.out.print(arr[i] + ",");
79 }
80 }
81
82 // 换行
83 System.out.println();
84 }
85
86 /**
87 * 数字转换为星期字符串的方法
88 * @param i：数字
89 * @return：星期字符串
90 */
91 public static String convertNumberToString(int i) {
92 String result = "";
93
94 switch (i) {
95 case 1:
96 result = "星期一";
97 break;
98 case 2:
99 result = "星期二";
100 break;
101 case 3:
102 result = "星期三";
103 break;
104 case 4:
105 result = "星期四";
106 break;
107 case 5:
108 result = "星期五";
109 break;
110 case 6:
111 result = "星期六";
112 break;
113 case 7:
114 result = "星期日";
115 break;
116 default:
117 result = "输入错误！";
118 break;
119 }
120
121 return result;
122 }
123 }
1 package cn.temptation;
2
3 public class Sample02 {
4 public static void main(String[] args) {
5 // 需求：给定一个int类型的数组，实现如下功能：将数组反转，比如：{1, 2, 3} -----> {3, 2, 1}, {1, 2, 3, 4} -----> {4, 3, 2, 1}
6
7 // 思路：
8 // 1、可能有两种情况，一种数组的长度为奇数，一种数组的长度为偶数
9 // 2、如果长度为奇数，中间那个元素不动，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
10 // 中间那个元素的前一个元素和中间那个元素的后一个元素对调
11 // 3、如果长度为偶数，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
12 // 中间位置的前一个元素和中间位置的后一个元素对调
13
14 int[] arr1 = { 1, 2, 3 };
15 System.out.println("反转前的数组：");
16 printArray(arr1);
17
18 // 调用方法
19 // reversalArray1(arr1);
20 reversalArray2(arr1);
21
22 System.out.println("反转后的数组：");
23 printArray(arr1);
24
25 System.out.println("------------------------------");
26
27 int[] arr2 = { 1, 2, 3, 4 };
28 System.out.println("反转前的数组：");
29 printArray(arr2);
30
31 // reversalArray2(arr2);
32 reversalArray1(arr2);
33
34 System.out.println("反转后的数组：");
35 printArray(arr2);
36
37 // 注意：
38 // 1、代码写完后，自己再考虑一下，不要抱着糊完任务的心态
39 // 2、思考问题的时候是区分了数组为奇数长度和偶数长度的，在编写代码时，发现对于奇数长度，因为其中间元素不参与反转，相当于反转时把中间元素拿掉
40 // 即其操作次数：(数组长度 - 1) / 2， 和 偶数长度数组的操作次数是一致的
41 }
42
43 /**
44 * 打印数组
45 * @param arr：int数组
46 */
47 public static void printArray(int[] arr) {
48 System.out.print("[");
49
50 // 遍历数组
51 for (int i = 0; i < arr.length; i++) {
52 if (i == arr.length - 1) {
53 System.out.print(arr[i] + "]");
54 } else {
55 System.out.print(arr[i] + ",");
56 }
57 }
58
59 // 换行
60 System.out.println();
61 }
62
63 /**
64 * 奇数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
65 * @param arr
66 */
67 public static void reversalArray1(int[] arr) {
68 // 下面写法逻辑错误，这样会对调两次，等于没有对调
69 // for (int i = 0, j = arr.length - 1; i < arr.length; i++, j--) {
70 for (int i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--) {
71 // 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
72 // 中间那个元素的前一个元素和中间那个元素的后一个元素对调
73 // 定义临时变量接收
74 int temp = arr[i];
75 arr[i] = arr[j];
76 arr[j] = temp;
77 }
78 }
79
80 /**
81 * 偶数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
82 * @param arr
83 */
84 public static void reversalArray2(int[] arr) {
85 for (int i = 0; i < arr.length / 2; i++) {
86 // 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
87 // 中间位置的前一个元素和中间位置的后一个元素对调
88 // 定义临时变量接收
89 int temp = arr[i];
90 arr[i] = arr[arr.length - 1 - i];
91 arr[arr.length - 1 - i] = temp;
92 }
93 }
94 }
1 package cn.temptation;
2
3 public class Sample03 {
4 public static void main(String[] args) {
5 int[] arr = { 10, 20, 30 };
6 System.out.println(arr); // [I@15db9742
7 System.out.println(arr[0]); // 10
8
9 arr = null;
10
11 // 产生异常：java.lang.NullPointerException 空指针异常
12 // 有警告：Null pointer access: The variable arr can only be null at this location
13 // System.out.println(arr[0]);
14
15 // 产生异常：java.lang.NullPointerException 空指针异常
16 // 有警告：Null pointer access: The variable arr can only be null at this location
17 // System.out.println(arr.length);
18
19 // 下句语句执行时无异常
20 System.out.println(arr); // null
21
22 // 注意：
23 // 1、设置引用类型变量的值为null，其实就是让其栈中声明的引用类型变量 与 在堆中开辟的空间之间的联系断开
24 // 2、堆中原来开辟的空间并不会立即消失
25
26 // null是一个特殊值，类比boolean类型的特殊值true 和 false
27 // null表示的是引用数据类型的空值，引用数据类型的默认值是null
28
29 // 如下两种写法意义相同
30 // int[] arrExtend;
31 // int[] arrExtend = null;
32
33 // null不能用于给基本数据类型（值类型）赋值，null只能用于引用数据类型
34 // 语法错误：Type mismatch: cannot convert from null to int
35 // int i = null;
36 }
37 }
1 package cn.temptation;
2
3 public class Sample04 {
4 public static void main(String[] args) {
5 // int[] arr = { 1, 2, 3 };
6 // printArray(arr);
7
8 // 匿名数组：没有显示定义数组名的数组
9 // 这里匿名数组使用new关键字直接在内存的堆中开辟元素个数长度的空间，并存储这些元素，然后作为实参传递给方法的形参供方法使用
10
11 // printArray(new int[] { 1, 2, 3 });
12
13 // 匿名数组的优点：直接new出来使用，不用再做声明
14 // 匿名数组的缺点：只能使用一次（因为没有声明数组变量，一次使用完毕后就找不到了）
15
16 // 注意：匿名数组定义时，不能使用静态初始化的简写形式，语法出错
17 // 语法错误：Syntax error on token "printArray", @ expected before this token
18 // printArray({ 4, 5, 6 });
19
20 // 注意：匿名数组定义时，可以使用动态初始化的形式，但是这样定义后，无法进行元素的填充
21 printArray(new int[3]);
22 }
23
24 /**
25 * 打印数组
26 * @param arr：int数组
27 */
28 public static void printArray(int[] arr) {
29 System.out.print("[");
30
31 // 遍历数组
32 for (int i = 0; i < arr.length; i++) {
33 if (i == arr.length - 1) {
34 System.out.print(arr[i] + "]");
35 } else {
36 System.out.print(arr[i] + ",");
37 }
38 }
39
40 // 换行
41 System.out.println();
42 }
43 }
1 package cn.temptation;
2
3 public class Sample05 {
4 public static void main(String[] args) {
5 // 给方法传递值类型参数 和 给方法传递引用数据类型参数
6
7 int i = 1;
8 System.out.println(i); // 1
9
10 // 调用方法
11 show(i); // 3
12
13 System.out.println(i); // 1
14
15 System.out.println("------------------------------");
16
17 int[] arr = { 1, 2, 3 };
18 printArray(arr); // [1,2,3]
19
20 // 调用方法
21 show(arr); // [3,4,5]
22
23 printArray(arr); // [3,4,5]
24 }
25
26 // 方法接收的是值类型的参数
27 // i为形参，它接受show方法调用时传递过来的实参
28 // show方法中使用的i叫做局部变量，声明该局部变量的地方是形参定义的地方，也是它的作用域开始的地方，作用域结束的地方是show方法右侧的大括号
29 public static void show(int i) {
30 i += 2;
31 System.out.println("方法内的参数值为：" + i);
32 }
33
34 // 方法接收的是引用类型的参数
35 // 传递引用类型的参数，其实传递的是堆内存中开辟的空间的地址（也就是所谓的把引用传递了过去）
36 public static void show(int[] arr) {
37 // 遍历数组
38 for (int i = 0; i < arr.length; i++) {
39 arr[i] += 2;
40 }
41
42 // 打印数组
43 printArray(arr);
44 }
45
46 /**
47 * 打印数组
48 * @param arr：int数组
49 */
50 public static void printArray(int[] arr) {
51 System.out.print("[");
52
53 // 遍历数组
54 for (int i = 0; i < arr.length; i++) {
55 if (i == arr.length - 1) {
56 System.out.print(arr[i] + "]");
57 } else {
58 System.out.print(arr[i] + ",");
59 }
60 }
61
62 // 换行
63 System.out.println();
64 }
65 }
1 package cn.temptation;
2
3 public class Sample06 {
4 public static void main(String[] args) {
5 // 可变长参数：Java中当作数组处理
6 // 可变长参数一般出现在方法的形参中
7
8 // 调用方法
9 show(1, new double[] { 2, 3, 4 });
10
11 double[] arr = { 5, 6, 7 };
12 show(9, arr);
13 }
14
15 // 正确形式使用可变长参数
16 public static void show(int i, double... ds) {
17 System.out.println(i); // 1
18
19 System.out.println(ds); // [D@15db9742
20 System.out.println(ds.length); // 3
21
22 // 遍历
23 for (double item : ds) {
24 System.out.println(item);
25 }
26 }
27
28 // 注意：一个方法只能有一个可变长参数，且必须位于参数列表的最后位置
29
30 // 语法错误：The variable argument type double of the method test must be the last parameter
31 // public static void test(int i, double... ds, char... ch) {
32 // // 想创建多个可变长参数的方法
33 // }
34
35 // 语法错误：The variable argument type double of the method test must be the last parameter
36 // public static void test(int i, double... ds, boolean flag) {
37 // // 想创建可变长参数不在最后位置的方法
38 // }
39 }
1 package cn.temptation;
2
3 public class Sample07 {
4 public static void main(String[] args) {
5 // 排序
6
7 // 冒泡排序（两两位置比较，每轮最大数字出现在右侧，依次向左）
8 // 思路：
9 // 1、第一轮，比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
10 // 比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
11 // 以此类推直到第一轮结束（最后一个位置不用参与比较，因为它的右侧没有位置了）,最大的数字在最右侧
12 // 2、第二轮，还是比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
13 // 比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
14 // 以此类推直到第二轮结束（倒数第二个位置不用参与比较，因为它的右侧已经是最大的数了），第二大的数字在倒数第二个
15 // 3、后续的轮以此类推
16
17 int[] arr = { 2, 1, 0, 4, 3 };
18
19 System.out.println("排序前：");
20 printArray(arr);
21
22 // 冒泡排序算法
23 for (int i = 0; i < arr.length - 1; i++) { // 外层循环的轮数是数组长度 - 1，i表示的是当前为第几轮
24 for (int j = 0; j < arr.length - 1 - i; j++) { // j表示的当前轮中的位置
25 // 相邻的两个位置上的数做比较
26 if (arr[j] > arr[j + 1]) {
27 // 对调
28 int temp = arr[j];
29 arr[j] = arr[j + 1];
30 arr[j + 1] = temp;
31 }
32 }
33
34 // 可以使用打印数组的方法查看当轮排序结果
35 printArray(arr);
36 }
37
38 System.out.println("排序后：");
39 printArray(arr);
40 }
41
42 /**
43 * 打印数组
44 * @param arr：int数组
45 */
46 public static void printArray(int[] arr) {
47 System.out.print("[");
48
49 // 遍历数组
50 for (int i = 0; i < arr.length; i++) {
51 if (i == arr.length - 1) {
52 System.out.print(arr[i] + "]");
53 } else {
54 System.out.print(arr[i] + ",");
55 }
56 }
57
58 // 换行
59 System.out.println();
60 }
61 }
1 package cn.temptation;
2
3 public class Sample08 {
4 public static void main(String[] args) {
5 // 排序
6
7 // 选择排序
8 // 思路：
9 // 1、第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
10 // 第一轮操作完成后，在第一个位置上得到最小的那个元素
11 // 2、第二轮，把在第二个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第二个位置上的元素小，就对调，直到比较到最后一个位置上的元素
12 // 第二轮操作完成后，在第二个位置上得到次小的那个元素
13 // 3、以此类推
14
15 int[] arr = { 2, 1, 0, 4, 3 };
16
17 System.out.println("排序前：");
18 printArray(arr);
19
20 // 选择排序算法
21 for (int i = 0; i < arr.length - 1; i++) { // 外层循环的i既表示轮数，又表示比较的位置
22 // 第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
23 // if (arr[0] > arr[1]) {
24 // // 对调
25 // int temp = arr[0];
26 // arr[0] = arr[1];
27 // arr[1] = temp;
28 // }
29 // if (arr[0] > arr[2]) {
30 // // 对调
31 // int temp = arr[0];
32 // arr[0] = arr[2];
33 // arr[2] = temp;
34 // }
35
36 // 归纳上述语句，可以得到规律
37 for (int j = i + 1; j < arr.length; j++) { // 内层循环的j表示其他被比较的位置
38 if (arr[i] > arr[j]) {
39 // 对调
40 int temp = arr[i];
41 arr[i] = arr[j];
42 arr[j] = temp;
43 }
44 }
45
46 // 可以使用打印数组的方法查看当轮排序结果
47 printArray(arr);
48 }
49
50 System.out.println("排序后：");
51 printArray(arr);
52 }
53
54 /**
55 * 打印数组
56 * @param arr：int数组
57 */
58 public static void printArray(int[] arr) {
59 System.out.print("[");
60
61 // 遍历数组
62 for (int i = 0; i < arr.length; i++) {
63 if (i == arr.length - 1) {
64 System.out.print(arr[i] + "]");
65 } else {
66 System.out.print(arr[i] + ",");
67 }
68 }
69
70 // 换行
71 System.out.println();
72 }
73 }
1 package cn.temptation;
2
3 public class Sample09 {
4 public static void main(String[] args) {
5 // 排序
6
7 // 插入排序
8 // 思路：
9 // 1、第一轮，从第2个位置开始，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
10 // 2、第二轮，从第3个位置开始，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
11 // 再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
12 // 3、第三轮，从第4个位置开始，和其左侧的紧靠着它的位置的数（第3个位置上的数）进行比较，小的数放前面，大的数放后面
13 // 再看第3个位置，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
14 // 再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
15 // 4、以此类推
16
17 int[] arr = { 2, 1, 0, 4, 3 };
18
19 System.out.println("排序前：");
20 printArray(arr);
21
22 // 插入排序算法
23 for (int i = 1; i < arr.length; i++) { // 外层循环的i既表示轮数，又表示位置
24 // // 第一轮操作
25 // if (arr[0] > arr[1]) {
26 // // 对调
27 // int temp = arr[0];
28 // arr[0] = arr[1];
29 // arr[1] = temp;
30 // }
31 //
32 // // 第二轮操作
33 // if (arr[1] > arr[2]) {
34 // // 对调
35 // int temp = arr[1];
36 // arr[1] = arr[2];
37 // arr[2] = temp;
38 // }
39 // if (arr[0] > arr[1]) {
40 // // 对调
41 // int temp = arr[0];
42 // arr[0] = arr[1];
43 // arr[1] = temp;
44 // }
45
46 // 归纳上述操作，得到规律
47 // 写法一
48 for (int j = i; j > 0; j--) { // 内层循环的j表示当前的这个位置
49 if (arr[j] < arr[j - 1]) { // // 内层循环的当前的这个位置上的数 和 其左侧紧靠着它的位置上的数进行比较
50 // 对调
51 int temp = arr[j];
52 arr[j] = arr[j - 1];
53 arr[j - 1] = temp;
54 }
55 }
56
57 // 写法二
58 // for (int j = 0; j < i; j++) { // 内层循环的j表示从第1个位置开始配合进行比较
59 // if (arr[j] > arr[i]) {
60 // // 对调
61 // int temp = arr[i];
62 // arr[i] = arr[j];
63 // arr[j] = temp;
64 // }
65 // }
66 }
67
68 System.out.println("排序后：");
69 printArray(arr);
70 }
71
72 /**
73 * 打印数组
74 * @param arr：int数组
75 */
76 public static void printArray(int[] arr) {
77 System.out.print("[");
78
79 // 遍历数组
80 for (int i = 0; i < arr.length; i++) {
81 if (i == arr.length - 1) {
82 System.out.print(arr[i] + "]");
83 } else {
84 System.out.print(arr[i] + ",");
85 }
86 }
87
88 // 换行
89 System.out.println();
90 }
91 }
1 package cn.temptation;
2
3 import java.util.Arrays;
4
5 public class Sample10 {
6 public static void main(String[] args) {
7 // 初始化数组
8 int[] arr = { 2, 1, 0, 4, 3 };
9
10 System.out.println("排序前：");
11 printArray(arr);
12
13 // 可以调用Arrays类的sort方法进行排序
14 // 类 Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法。
15 // 常用的成员方法：
16 // static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
17 Arrays.sort(arr);
18
19 System.out.println("排序后：");
20 printArray(arr);
21 }
22
23 /**
24 * 打印数组
25 * @param arr：int数组
26 */
27 public static void printArray(int[] arr) {
28 System.out.print("[");
29
30 // 遍历数组
31 for (int i = 0; i < arr.length; i++) {
32 if (i == arr.length - 1) {
33 System.out.print(arr[i] + "]");
34 } else {
35 System.out.print(arr[i] + ",");
36 }
37 }
38
39 // 换行
40 System.out.println();
41 }
42 }
