【原】Java学习笔记011

package cn.temptation;

import java.util.Scanner;

public class Sample01 {
    public static void main(String[] args) {
        // 需求：定义一个数组存储星期一、星期二、...星期日，打印该数组形式为[星期一, 星期二, ...星期日]，根据用户输入的数字（1~7），显示是星期几？
        
        // 写法一、考虑使用字符串类型的数组
//        // 1、创建一个数组来存储星期一、星期二、...星期日
//        String[] weekDayArr = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
//        printArray(weekDayArr);
//        
//        // 2、接收键盘录入
//        System.out.println("输入一个数字就可以找到对应是星期几：");
//        Scanner input = new Scanner(System.in);
//        int weekDay = input.nextInt();
//        input.close();
//        
//        // 3、判断输入的数字和数组中某个元素的索引之间的关系
//        if (weekDay >= 1 && weekDay <= 7) {
//            System.out.println("选择的是：" + weekDayArr[weekDay - 1]);
//        } else {
//            System.out.println("输入的数字不在范围内！");
//        }
        
        // 写法二、考虑使用int类型的数组
        // 1、创建一个数组来存储星期一、星期二、...星期日
        int[] weekDayArr = { 1, 2, 3, 4, 5, 6, 7 };
        printArray(weekDayArr);
        
        // 2、接收键盘录入
        System.out.println("输入一个数字就可以找到对应是星期几：");
        Scanner input = new Scanner(System.in);
        int weekDay = input.nextInt();
        input.close();
        
        // 3、判断输入的数字和数组中某个元素的索引之间的关系
        if (weekDay >= 1 && weekDay <= 7) {
            System.out.println("选择的是：" + convertNumberToString(weekDayArr[weekDay - 1]));
        } else {
            System.out.println("输入的数字不在范围内！");
        }
    }
    
    /**
     * 打印数组
     * @param arr：字符串数组
     */
    public static void printArray(String[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
    
    /**
     * 打印数组（重载方法）
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
    
    /**
     * 数字转换为星期字符串的方法
     * @param i：数字
     * @return：星期字符串
     */
    public static String convertNumberToString(int i) {
        String result = "";
        
        switch (i) {
        case 1:
            result = "星期一";
            break;
        case 2:
            result = "星期二";
            break;
        case 3:
            result = "星期三";
            break;
        case 4:
            result = "星期四";
            break;
        case 5:
            result = "星期五";
            break;
        case 6:
            result = "星期六";
            break;
        case 7:
            result = "星期日";
            break;
        default:
            result = "输入错误！";
            break;
        }
        
        return result;
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 需求：给定一个int类型的数组，实现如下功能：将数组反转，比如：{1, 2, 3} -----> {3, 2, 1}, {1, 2, 3, 4} -----> {4, 3, 2, 1}
        
        // 思路：
        // 1、可能有两种情况，一种数组的长度为奇数，一种数组的长度为偶数
        // 2、如果长度为奇数，中间那个元素不动，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
        //        中间那个元素的前一个元素和中间那个元素的后一个元素对调
        // 3、如果长度为偶数，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
        //        中间位置的前一个元素和中间位置的后一个元素对调
        
        int[] arr1 = { 1, 2, 3 };
        System.out.println("反转前的数组：");
        printArray(arr1);
        
        // 调用方法
//        reversalArray1(arr1);
        reversalArray2(arr1);
        
        System.out.println("反转后的数组：");
        printArray(arr1);
        
        System.out.println("------------------------------");
        
        int[] arr2 = { 1, 2, 3, 4 };
        System.out.println("反转前的数组：");
        printArray(arr2);
        
//        reversalArray2(arr2);
        reversalArray1(arr2);
        
        System.out.println("反转后的数组：");
        printArray(arr2);
        
        // 注意：
        // 1、代码写完后，自己再考虑一下，不要抱着糊完任务的心态
        // 2、思考问题的时候是区分了数组为奇数长度和偶数长度的，在编写代码时，发现对于奇数长度，因为其中间元素不参与反转，相当于反转时把中间元素拿掉
        //        即其操作次数：(数组长度 - 1) / 2， 和 偶数长度数组的操作次数是一致的
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
    
    /**
     * 奇数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
     * @param arr
     */
    public static void reversalArray1(int[] arr) {
        // 下面写法逻辑错误，这样会对调两次，等于没有对调
//        for (int i = 0, j = arr.length - 1; i < arr.length; i++, j--) {
        for (int i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--) {
            // 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
            //        中间那个元素的前一个元素和中间那个元素的后一个元素对调
            // 定义临时变量接收
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    
    /**
     * 偶数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
     * @param arr
     */
    public static void reversalArray2(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            // 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
            //        中间位置的前一个元素和中间位置的后一个元素对调
            // 定义临时变量接收
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        int[] arr = { 10, 20, 30 };
        System.out.println(arr);        // [I@15db9742
        System.out.println(arr[0]);        // 10
        
        arr = null;
        
        // 产生异常：java.lang.NullPointerException  空指针异常
        // 有警告：Null pointer access: The variable arr can only be null at this location
//        System.out.println(arr[0]);
        
        // 产生异常：java.lang.NullPointerException  空指针异常
        // 有警告：Null pointer access: The variable arr can only be null at this location
//        System.out.println(arr.length);
        
        // 下句语句执行时无异常
        System.out.println(arr);        // null
        
        // 注意：
        // 1、设置引用类型变量的值为null，其实就是让其栈中声明的引用类型变量 与 在堆中开辟的空间之间的联系断开
        // 2、堆中原来开辟的空间并不会立即消失
        
        // null是一个特殊值，类比boolean类型的特殊值true 和 false
        // null表示的是引用数据类型的空值，引用数据类型的默认值是null
        
        // 如下两种写法意义相同
//        int[] arrExtend;
//        int[] arrExtend = null;
        
        // null不能用于给基本数据类型（值类型）赋值，null只能用于引用数据类型
        // 语法错误：Type mismatch: cannot convert from null to int
//        int i = null;
    }
}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
//        int[] arr = { 1, 2, 3 };
//        printArray(arr);
        
        // 匿名数组：没有显示定义数组名的数组
        // 这里匿名数组使用new关键字直接在内存的堆中开辟元素个数长度的空间，并存储这些元素，然后作为实参传递给方法的形参供方法使用
        
//        printArray(new int[] { 1, 2, 3 });
        
        // 匿名数组的优点：直接new出来使用，不用再做声明
        // 匿名数组的缺点：只能使用一次（因为没有声明数组变量，一次使用完毕后就找不到了）
        
        // 注意：匿名数组定义时，不能使用静态初始化的简写形式，语法出错
        // 语法错误：Syntax error on token "printArray", @ expected before this token
//        printArray({ 4, 5, 6 });
        
        // 注意：匿名数组定义时，可以使用动态初始化的形式，但是这样定义后，无法进行元素的填充
        printArray(new int[3]);
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        // 给方法传递值类型参数       和       给方法传递引用数据类型参数
        
        int i = 1;
        System.out.println(i);            // 1
        
        // 调用方法
        show(i);                        // 3
        
        System.out.println(i);            // 1
        
        System.out.println("------------------------------");
        
        int[] arr = { 1, 2, 3 };
        printArray(arr);                // [1,2,3]
        
        // 调用方法
        show(arr);                        // [3,4,5]
        
        printArray(arr);                // [3,4,5]
    }
    
    // 方法接收的是值类型的参数
    // i为形参，它接受show方法调用时传递过来的实参
    // show方法中使用的i叫做局部变量，声明该局部变量的地方是形参定义的地方，也是它的作用域开始的地方，作用域结束的地方是show方法右侧的大括号
    public static void show(int i) {
        i += 2;
        System.out.println("方法内的参数值为：" + i);
    }
    
    // 方法接收的是引用类型的参数
    // 传递引用类型的参数，其实传递的是堆内存中开辟的空间的地址（也就是所谓的把引用传递了过去）
    public static void show(int[] arr) {
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] += 2;
        }
        
        // 打印数组
        printArray(arr);
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
}

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        // 可变长参数：Java中当作数组处理
        // 可变长参数一般出现在方法的形参中
        
        // 调用方法
        show(1, new double[] { 2, 3, 4 });
        
        double[] arr = { 5, 6, 7 };
        show(9, arr);
    }
    
    // 正确形式使用可变长参数
    public static void show(int i, double... ds) {
        System.out.println(i);                // 1
        
        System.out.println(ds);                // [D@15db9742
        System.out.println(ds.length);        // 3
        
        // 遍历
        for (double item : ds) {
            System.out.println(item);
        }
    }
    
    // 注意：一个方法只能有一个可变长参数，且必须位于参数列表的最后位置
    
    // 语法错误：The variable argument type double of the method test must be the last parameter
//    public static void test(int i, double... ds, char... ch) {
//        // 想创建多个可变长参数的方法
//    }
    
    // 语法错误：The variable argument type double of the method test must be the last parameter
//    public static void test(int i, double... ds, boolean flag) {
//        // 想创建可变长参数不在最后位置的方法
//    }
}

package cn.temptation;

public class Sample07 {
    public static void main(String[] args) {
        // 排序
        
        // 冒泡排序（两两位置比较，每轮最大数字出现在右侧，依次向左）
        // 思路：
        // 1、第一轮，比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
        //             比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
        //            以此类推直到第一轮结束（最后一个位置不用参与比较，因为它的右侧没有位置了）,最大的数字在最右侧
        // 2、第二轮，还是比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
        //            比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
        //                以此类推直到第二轮结束（倒数第二个位置不用参与比较，因为它的右侧已经是最大的数了），第二大的数字在倒数第二个
        // 3、后续的轮以此类推
        
        int[] arr = { 2, 1, 0, 4, 3 };
        
        System.out.println("排序前：");
        printArray(arr);
        
        // 冒泡排序算法
        for (int i = 0; i < arr.length - 1; i++) {        // 外层循环的轮数是数组长度 - 1，i表示的是当前为第几轮
            for (int j = 0; j < arr.length - 1 - i; j++) {    // j表示的当前轮中的位置
                // 相邻的两个位置上的数做比较
                if (arr[j] > arr[j + 1]) {
                    // 对调
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            
            // 可以使用打印数组的方法查看当轮排序结果
            printArray(arr);
        }
        
        System.out.println("排序后：");
        printArray(arr);
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // 排序
        
        // 选择排序
        // 思路：
        // 1、第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
        //             第一轮操作完成后，在第一个位置上得到最小的那个元素
        // 2、第二轮，把在第二个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第二个位置上的元素小，就对调，直到比较到最后一个位置上的元素
        //             第二轮操作完成后，在第二个位置上得到次小的那个元素
        // 3、以此类推
        
        int[] arr = { 2, 1, 0, 4, 3 };
        
        System.out.println("排序前：");
        printArray(arr);
        
        // 选择排序算法
        for (int i = 0; i < arr.length - 1; i++) {        // 外层循环的i既表示轮数，又表示比较的位置
            // 第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
//            if (arr[0] > arr[1]) {
//                // 对调
//                int temp = arr[0];
//                arr[0] = arr[1];
//                arr[1] = temp;
//            }
//            if (arr[0] > arr[2]) {
//                // 对调
//                int temp = arr[0];
//                arr[0] = arr[2];
//                arr[2] = temp;
//            }
            
            // 归纳上述语句，可以得到规律
            for (int j = i + 1; j < arr.length; j++) {        // 内层循环的j表示其他被比较的位置
                if (arr[i] > arr[j]) {
                    // 对调
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
            
            // 可以使用打印数组的方法查看当轮排序结果
            printArray(arr);
        }
        
        System.out.println("排序后：");
        printArray(arr);
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
}

package cn.temptation;

public class Sample09 {
    public static void main(String[] args) {
        // 排序
        
        // 插入排序
        // 思路：
        // 1、第一轮，从第2个位置开始，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
        // 2、第二轮，从第3个位置开始，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
        //             再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
        // 3、第三轮，从第4个位置开始，和其左侧的紧靠着它的位置的数（第3个位置上的数）进行比较，小的数放前面，大的数放后面
        //             再看第3个位置，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
        //             再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
        // 4、以此类推
        
        int[] arr = { 2, 1, 0, 4, 3 };
        
        System.out.println("排序前：");
        printArray(arr);
        
        // 插入排序算法
        for (int i = 1; i < arr.length; i++) {            // 外层循环的i既表示轮数，又表示位置
//            // 第一轮操作
//            if (arr[0] > arr[1]) {
//                // 对调
//                int temp = arr[0];
//                arr[0] = arr[1];
//                arr[1] = temp;
//            }
//            
//            // 第二轮操作
//            if (arr[1] > arr[2]) {
//                // 对调
//                int temp = arr[1];
//                arr[1] = arr[2];
//                arr[2] = temp;
//            }
//            if (arr[0] > arr[1]) {
//                // 对调
//                int temp = arr[0];
//                arr[0] = arr[1];
//                arr[1] = temp;
//            }
            
            // 归纳上述操作，得到规律
            // 写法一
            for (int j = i; j > 0; j--) {        // 内层循环的j表示当前的这个位置
                if (arr[j] < arr[j - 1]) {        // // 内层循环的当前的这个位置上的数 和 其左侧紧靠着它的位置上的数进行比较
                    // 对调
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
            
            // 写法二
//            for (int j = 0; j < i; j++) {        // 内层循环的j表示从第1个位置开始配合进行比较
//                if (arr[j] > arr[i]) {
//                    // 对调
//                    int temp = arr[i];
//                    arr[i] = arr[j];
//                    arr[j] = temp;
//                }
//            }
        }
        
        System.out.println("排序后：");
        printArray(arr);
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
}

package cn.temptation;

import java.util.Arrays;

public class Sample10 {
    public static void main(String[] args) {
        // 初始化数组
        int[] arr = { 2, 1, 0, 4, 3 };
        
        System.out.println("排序前：");
        printArray(arr);
        
        // 可以调用Arrays类的sort方法进行排序
        // 类 Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法。
        // 常用的成员方法：
        // static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。 
        Arrays.sort(arr);
        
        System.out.println("排序后：");
        printArray(arr);
    }
    
    /**
     * 打印数组
     * @param arr：int数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        
        // 换行
        System.out.println();
    }
}