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 arr66      */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 arr83      */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 location13 //        System.out.println(arr[0]);14         15         // 产生异常：java.lang.NullPointerException  空指针异常16         // 有警告：Null pointer access: The variable arr can only be null at this location17 //        System.out.println(arr.length);18         19         // 下句语句执行时无异常20         System.out.println(arr);        // null21         22         // 注意：23         // 1、设置引用类型变量的值为null，其实就是让其栈中声明的引用类型变量 与 在堆中开辟的空间之间的联系断开24         // 2、堆中原来开辟的空间并不会立即消失25         26         // null是一个特殊值，类比boolean类型的特殊值true 和 false27         // null表示的是引用数据类型的空值，引用数据类型的默认值是null28         29         // 如下两种写法意义相同30 //        int[] arrExtend;31 //        int[] arrExtend = null;32         33         // null不能用于给基本数据类型（值类型）赋值，null只能用于引用数据类型34         // 语法错误：Type mismatch: cannot convert from null to int35 //        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 token18 //        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);                        // 312         13         System.out.println(i);            // 114         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);                // 118         19         System.out.println(ds);                // [D@15db974220         System.out.println(ds.length);        // 321         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 parameter31 //    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 parameter36 //    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 }