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 }