【原】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]);        //

         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);                        //

         System.out.println(i);            //

         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);                //

         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();
     }
 }