1 package cn.temptation; 2  3 public class Sample01 { 4     public static void main(String[] args) { 5         // 需求：一堆分数，要统计最高分、最低分、总分、平均分 6 //        int score1 = 80; 7 //        int score2 = 70; 8 //        int score3 = 90; 9 //        int score4 = 65;10 //        // ...11 //        // 以计算平均分为例12 //        double average = ((double)(score1 + score2 + score3 + score4)) / 4;13 //        System.out.println("平均分为：" + average);14         15         // 问题：相同意义的变量定义了一大堆，觉得这样一点都不简洁16         17         // 思考解决方案：运用抽象的思维，类比生活中使用的冰格，作为一个制作冰块的容器，其内部每一个格子中的冰块可以单独使用的，兼具了批量性 和 独立性18         //                那么考虑制作一个存放分数的容器，且在这个分数容器中的每一个分数也可以单独使用19         20         // 数组：Array，存储同一数据类型的多个元素的容器21         22         // 注意：【数组是引用数据类型（引用类型），基本数据类型是值类型】23         // 内存：根据处理的内容的不同，分为 堆栈（栈：stack）   和  堆（Heap）24         // 值类型：存储在栈中25         // 引用数据类型：声明存储在栈中，内容存储在堆中26         27         // 数组的格式：28         // 形式1：数据类型[]   数组名（硬性要求：大家使用这种形式）：声明了一个xxx数据类型的数组，名字叫yyy29         // 形式2：数据类型      数组名[]：声明了一个xxx数据类型，名字叫yyy的数组30         31         // 声明一个成绩数组32 //        int[] scoreArr;33 //        int scoreArr[];        // 语法OK，但是不建议这样写34         35         // 数组变量使用前必须进行初始化操作36         // 语法错误：The local variable scoreArr may not have been initialized37 //        System.out.println(scoreArr);38         39         // 数组初始化形式：40         // 1、动态初始化：由使用者设置数组的长度，再填充元素41         // 2、静态初始化：由使用者填充元素，由JDK计算数组的长度42         43         // 动态初始化的格式：new 数据类型[数组的长度];44         // A：new 关键字用来在内存的堆（Heap）中开辟一块空间45         // B：数组的长度由使用者设置46         // C：数组的下标（索引）用来表示数组中元素的位置，下标（索引）从0开始，到数组的长度-1结束47         48         // 对于已经声明过的数组变量，进行动态初始化并赋值49 //        scoreArr = new int[3];50         51         // 数组的初始化：可以把数组的声明 和 初始化 放在一行语句中执行52         int[] scoreArr = new int[3];53         54         // 下句输出  [I@15db9742 ，表示了scoreArr数组变量在内存中的类型  和  地址（以@符号作为分隔，前面是类型，后面是地址）55         System.out.println(scoreArr);        // [I@15db974256     }57 }

 1 package cn.temptation; 2  3 public class Sample02 { 4     public static void main(String[] args) { 5         // 数组的下标（索引）是从0开始的 6         // 数组的长度就是描述数组中元素的个数 7 //        int[] arr = new int[3]; 8 //        arr[0] = 90;        // 对数组中的第一个元素赋值为90 9 10         // 创建int类型的数组，向其中存放其他数据类型的元素，会发生什么现象？11         // 向int类型的元素存放boolean类型的内容，语法出错12         // 产生语法错误：Type mismatch: cannot convert from boolean to int13 //        arr[1] = true;        // 对数组中的第二个元素赋值为true14         15         // 向int类型的元素存放long类型的内容，语法出错16         // 产生语法错误：Type mismatch: cannot convert from long to int17 //        arr[1] = 12345678901L;18         19         // 向int类型的元素存放byte类型的内容，语法OK20 //        arr[1] = (byte)126;21         22         // 向int类型的元素存放short类型的内容，语法OK23 //        arr[1] = (short)130;24         25         // 【数组在内存中的存储形式】26         // 赋值号左边的是数组的声明，类比名片27         // 赋值号右边的是数组的内容，类比具体的家的位置28         // 通过名片找到具体的家的位置29         // 通过栈上声明的变量找到堆中具体存放内容的位置来使用数组30         31 //        System.out.println(arr);            // [I@15db974232         33         // 数组中元素的默认值34         // byte、short、int、long类型的数组的元素默认值为035 //        int[] arr1 = new int[3];36 //        System.out.println(arr1[0]);        // 037 //        System.out.println(arr1[1]);        // 038 //        System.out.println(arr1[2]);        // 039         40 //        byte[] arr2 = new byte[3];41 //        System.out.println(arr2[0]);        // 042 //        System.out.println(arr2[1]);        // 043 //        System.out.println(arr2[2]);        // 044 //        45 //        short[] arr3 = new short[3];46 //        System.out.println(arr3[0]);        // 047 //        System.out.println(arr3[1]);        // 048 //        System.out.println(arr3[2]);        // 049 //        50 //        long[] arr4 = new long[3];51 //        System.out.println(arr4[0]);        // 052 //        System.out.println(arr4[1]);        // 053 //        System.out.println(arr4[2]);        // 054         55         // double、float类型的数组的元素默认值为0.056 //        double[] arr5 = new double[3];57 //        System.out.println(arr5[0]);        // 0.058 //        System.out.println(arr5[1]);        // 0.059 //        System.out.println(arr5[2]);        // 0.060 //        61 //        float[] arr6 = new float[3];62 //        System.out.println(arr6[0]);        // 0.063 //        System.out.println(arr6[1]);        // 0.064 //        System.out.println(arr6[2]);        // 0.065         66         // char类型的数组的元素默认值为‘\u0000‘67 //        char[] arr7 = new char[3];68 //        System.out.println(arr7[0]);        // ‘\u0000‘69 //        System.out.println(arr7[1]);        // ‘\u0000‘70 //        System.out.println(arr7[2]);        // ‘\u0000‘71         72         // boolean类型的数组的元素默认值为false73         boolean[] arr8 = new boolean[3];74         System.out.println(arr8[0]);        // false75         System.out.println(arr8[1]);        // false76         System.out.println(arr8[2]);        // false77     }78 }

 1 package cn.temptation; 2  3 public class Sample03 { 4     public static void main(String[] args) { 5         int[] scoreArr = new int[3]; 6          7         System.out.println(scoreArr);        // [I@15db9742 8         System.out.println(scoreArr[0]);    // 0 9         System.out.println(scoreArr[1]);    // 010         System.out.println(scoreArr[2]);    // 011         12         System.out.println("-------------------------------------");13         14         // 对数组中的部分元素进行赋值15         scoreArr[0] = 80;16         scoreArr[2] = 55;17         18         // 1、数组的元素的值发生变化后，数组的地址没有变化19         // 2、数组的元素的值发生变化后，数组中没有发生变化的元素的值还是之前的值20         System.out.println(scoreArr);        // [I@15db974221         System.out.println(scoreArr[0]);    // 8022         System.out.println(scoreArr[1]);    // 023         System.out.println(scoreArr[2]);    // 5524     }25 }

 1 package cn.temptation; 2  3 public class Sample04 { 4     public static void main(String[] args) { 5         // 需求：把数组中的元素的值都显示出来 6         int[] scoreArr = new int[3]; 7          8         // 下面的写法可以实现需求，但是使用起来很不方便 9 //        System.out.println(scoreArr[0]);10 //        System.out.println(scoreArr[1]);11 //        System.out.println(scoreArr[2]);12         13         // 看到有重复的操作，就想到了循环14 //        for (int i = 0; i < 3; i++) {15 //            System.out.println(scoreArr[i]);16 //        }17         18         // 上面的写法不具备通用性，因为这里的数字3是硬编码，其实它应该表示为数组的长度（数组中元素的个数）19         20         // 通过使用    数组名.length 可以获取到数组的长度21 //        System.out.println("数组的长度为：" + scoreArr.length);22         23         // 下面的写法就具备通用性（注意：eclipse中提供的for语句块结构：iterate over array，即在数组上进行迭代）24 //        for (int i = 0; i < scoreArr.length; i++) {25 //            System.out.println(scoreArr[i]);26 //        }27         28         // 还有更加简单的写法，使用增强型for循环-----> foreach29         // 增强型for循环的格式：for(数据类型   遍历变量名(迭代变量名)   :   被遍历变量名(被迭代变量名)) { ... }30 //        for (int i : scoreArr) {31 //            System.out.println(i);32 //        }33         34         // 注意：遍历变量名(迭代变量名)可以由使用者自己定义名称35 //        for (int item : scoreArr) {36 //            System.out.println(item);37 //        }38         39         // 产生错误：Type mismatch: cannot convert from element type int to byte40 //        for (byte i : scoreArr) {41 //            System.out.println(i);42 //        }43         44         // 产生错误：Type mismatch: cannot convert from element type int to short45 //        for (short i : scoreArr) {46 //            System.out.println(i);47 //        }48         49         // 语法OK50 //        for (long i : scoreArr) {51 //            System.out.println(i);52 //        }53         54         // 总结：被遍历的变量名的数据类型，认为其内部的元素也是该数据类型的，那么用范围比它大的数据类型接收时是可以的55         //        用范围比它小的数据类型接收时就会抱语法错误56         57         // 需求：使用循环和数组长度等技术点，制作一个方法printArray，用来打印数组中的元素，要求显示为[元素1的值, 元素2的值, ... 元素n的值]58         printArray(scoreArr);59     }60     61     /**62      * 打印数组方法63      * @param arr：int类型的数组64      */65     public static void printArray(int[] arr) {66         // 最左边先打印出一个"["67         System.out.print("[");68         69         // 遍历数组70         for (int i = 0; i < arr.length; i++) {71             if (i == arr.length - 1) {        // 数组中的最后一个元素，加上"]"72                 System.out.print(arr[i] + "]");73             } else {                        // 数组中的其他元素，加上","74                 System.out.print(arr[i] + ",");75             }76         }77         78         // 换行79         System.out.println();80     }81 }

 1 package cn.temptation; 2  3 public class Sample05 { 4     public static void main(String[] args) { 5         int[] arr = new int[3]; 6         arr[0] = 10; 7         arr[1] = 21; 8         arr[2] = 30; 9         10         // 需求：制作一个方法getMaxItem，获取数组中的最大元素值11         int maxItem = getMaxItem(arr);12         System.out.println("数组中最大的元素为：" + maxItem);13         14         // 需求：制作一个方法getMinItem，获取数组中的最小元素值15         int minItem = getMinItem(arr);16         System.out.println("数组中最小的元素为：" + minItem);17         18         // 需求：制作一个方法getTotal，获取数组中的元素的总和19         int total = getTotal(arr);20         System.out.println("数组中元素的总和为：" + total);21         22         // 需求：制作一个方法getAverage，获取数组中的元素的平均值23         double average = getAverage(arr);24         System.out.println("数组中元素的平均值为：" + average);25     }26     27     /**28      * 获取数组中的最大元素值29      * @param arr：数组30      * @return：最大的元素值31      * 32      * 思路：使用穷举思路33      * 1、先设置一个作为比较的标杆，从数组中拿出一个元素认为它是最大的34      * 2、把数组中的其他元素与之进行比较35      * 3、如果有其他的元素比作为标杆的元素大，则替换之36      * 4、比较完成后，就可以得到数组中的最大元素37      */38     public static int getMaxItem(int[] arr) {39         int tempMax = arr[0];40         41         // 遍历数组42         for (int i = 0; i < arr.length; i++) {43             if (arr[i] > tempMax) {44                 tempMax = arr[i];45             }46         }47         48         return tempMax;49     }50     51     /**52      * 获取数组中的最小元素值53      * @param arr：数组54      * @return：最小的元素值55      */56     public static int getMinItem(int[] arr) {57         int tempMin = arr[0];58         59         // 遍历数组60         for (int i = 0; i < arr.length; i++) {61             if (arr[i] < tempMin) {62                 tempMin = arr[i];63             }64         }65         66         return tempMin;67     }68     69     /**70      * 获取数组中的元素值的总和71      * @param arr：数组72      * @return：数组中元素的总和73      */74     public static int getTotal(int[] arr) {75         int total = 0;76         77         // 遍历数组78         for (int i = 0; i < arr.length; i++) {79             total += arr[i];80         }81         82         return total;83     }84     85     /**86      * 获取数组中的元素值的平均值87      * @param arr：数组88      * @return：数组中元素的平均值89      */90     public static double getAverage(int[] arr) {91         double total = 0.0;92         93         for (int i = 0; i < arr.length; i++) {94             total += arr[i];95         }96         97         return total / arr.length;98     }99 }

 1 package cn.temptation; 2  3 public class Sample06 { 4     public static void main(String[] args) { 5         int[] arr1 = new int[3]; 6         arr1[0] = 80; 7         arr1[2] = 55; 8          9         int[] arr2 = new int[3];10         arr2[0] = 80;11         arr2[2] = 55;12         13         System.out.println("数组1的地址：" + arr1);        // [I@15db974214         printArray(arr1);15         16         System.out.println("数组2的地址：" + arr2);        // [I@6d06d69c17         printArray(arr2);18         19         System.out.println("----- 修改元素值 -----");20         21         arr2[0] = 38;22         arr2[1] = 100;23         24         System.out.println("数组1的地址：" + arr1);        // [I@15db974225         printArray(arr1);26         27         System.out.println("数组2的地址：" + arr2);        // [I@6d06d69c28         printArray(arr2);29         30         // 不同的数组，元素的值相同，修改后，对其他数组中的元素的值无影响31         // 因为不同的数组中的元素存放在内存的堆中不同的空间里32         33         // 从运行的结果得知：34         // 【只要使用了new关键字，就在内存的堆中开辟了新的空间】35     }36     37     /**38      * 打印数组方法39      * @param arr：int类型的数组40      */41     public static void printArray(int[] arr) {42         // 最左边先打印出一个"["43         System.out.print("[");44         45         // 遍历数组46         for (int i = 0; i < arr.length; i++) {47             if (i == arr.length - 1) {        // 数组中的最后一个元素，加上"]"48                 System.out.print(arr[i] + "]");49             } else {                        // 数组中的其他元素，加上","50                 System.out.print(arr[i] + ",");51             }52         }53         54         // 换行55         System.out.println();56     }57 }

 1 package cn.temptation; 2  3 public class Sample07 { 4     public static void main(String[] args) { 5         int[] arr1 = new int[3]; 6         arr1[0] = 80; 7         arr1[2] = 55; 8          9         // 注意：下句语句体现了引用数据类型的特点10         int[] arr2 = arr1;11         12         System.out.println("数组1的地址：" + arr1);        // [I@15db974213         printArray(arr1);14         15         System.out.println("数组2的地址：" + arr2);        // [I@15db974216         printArray(arr2);17         18         System.out.println("----- 修改元素值 -----");19         20         arr2[0] = 38;21         arr2[1] = 100;22         23         System.out.println("数组1的地址：" + arr1);        // [I@15db974224         printArray(arr1);25         26         System.out.println("数组2的地址：" + arr2);        // [I@15db974227         printArray(arr2);28         29         // 从运行的结果得知：30         // 1、只要使用了new关键字，就在内存的堆中开辟了新的空间31         // 2、引用数据类型在做值传递时，传递的是引用32     }33     34     /**35      * 打印数组方法36      * @param arr：int类型的数组37      */38     public static void printArray(int[] arr) {39         // 最左边先打印出一个"["40         System.out.print("[");41         42         // 遍历数组43         for (int i = 0; i < arr.length; i++) {44             if (i == arr.length - 1) {        // 数组中的最后一个元素，加上"]"45                 System.out.print(arr[i] + "]");46             } else {                        // 数组中的其他元素，加上","47                 System.out.print(arr[i] + ",");48             }49         }50         51         // 换行52         System.out.println();53     }54 }

 1 package cn.temptation; 2  3 public class Sample08 { 4     public static void main(String[] args) { 5         // 值类型的特点 6          7 //        int i = 2; 8 //        int j = 2; 9 //        10 //        System.out.println("i的值为：" + i);11 //        System.out.println("j的值为：" + j);12 //        13 //        System.out.println("----- 修改元素值 -----");14 //        15 //        j = 3;16 //        17 //        System.out.println("i的值为：" + i);18 //        System.out.println("j的值为：" + j);19         20         int i = 2;21         int j = i;22         23         System.out.println("i的值为：" + i);24         System.out.println("j的值为：" + j);25         26         System.out.println("----- 修改元素值 -----");27         28         j = 3;29         30         System.out.println("i的值为：" + i);31         System.out.println("j的值为：" + j);32         33         // 值类型的特点34         // 存储在栈上，没有栈和堆之间的指向引用，变化只影响自身35     }36 }

 1 package cn.temptation; 2  3 public class Sample09 { 4     public static void main(String[] args) { 5         // 数组初始化 6         // 静态初始化：由使用者填充数组的元素，由JDK自动判定数组的长度 7          8         // 静态初始化的格式： 9         // 1、简写形式：{ 元素1, 元素2, ... 元素n}10         // 2、完整形式：new 数据类型[] { 元素1, 元素2, ... 元素n}11         12         // 简写形式13         int[] arr1 = { 10, 20, 30 };14         System.out.println("数组的长度为：" + arr1.length);15         16         // 完整形式17         int[] arr2 = new int[] { 10, 20, 30 };18         System.out.println("数组的长度为：" + arr2.length);19         20         // 遍历数组中的元素21         // 方式1：一般for循环22         for (int i = 0; i < arr1.length; i++) {23             System.out.println(arr1[i]);24         }25         26         // 方式2：增强型for循环27         for (int item : arr2) {28             System.out.println(item);29         }30         31         // 注意：32         // 1、静态初始化的简写形式看起来没有new，但是实际上还是做了new的操作，还是在内存的堆上开辟了空间33         // 2、数组的初始化有两种形式，使用时只能选择一种形式使用，不能混搭34         35         // 混搭动态初始化和静态初始化会产生语法错误36         // 产生语法错误：Cannot define dimension expressions when an array initializer is provided37 //        int[] arr3 = new int[3] { 10, 20, 30 };38     }39 }

 1 package cn.temptation; 2  3 public class Sample10 { 4     public static void main(String[] args) { 5         // 1、下面语句是否在内存的堆中开辟了空间？        答：new出了空间，地址为15db9742 6         // 2、下面这个数组长度是多少？                    答：数组长度为0 7         // 3、如何为这个数组填充元素并给元素赋值？ 8         int[] arr = {}; 9         10         System.out.println(arr);            // [I@15db974211         System.out.println("数组的长度为：" + arr.length);        // 012         13         // 遍历数组14         for (int i = 0; i < arr.length; i++) {15             System.out.println(arr[i]);16         }17         18         for (int item : arr) {19             System.out.println(item);20         }21         22         // 下句执行时会产生异常：java.lang.ArrayIndexOutOfBoundsException: 0，数组索引越界异常23         // 因为当前arr数组中一个元素都没有，而下句语句要给第一个元素进行赋值，自然出现数组索引越界异常24 //        arr[0] = 10;25         // 下句执行时会产生异常：java.lang.ArrayIndexOutOfBoundsException: 10，数组索引越界异常26 //        arr[10] = 99;27         // 由上面的语句得知java.lang.ArrayIndexOutOfBoundsException后的数字指的是越界元素对应的索引28         29         // 考虑1、考虑设置数组arr的length属性30         // 语法错误：The final field array.length cannot be assigned31         // 数组的length属性可以被读取，但是不可以被修改32 //        arr.length = 3;33         34         // 考虑2、张冠李戴35         // 通过创建一个新的数组，在堆中开辟一块新的空间，然后把指向之前开辟出的空间的引用（arr的栈堆之间的引用）改为指向新开辟的空间的引用36         int[] arrExtend = { 10, 20, 30 };37         arr = arrExtend;38         39         // 遍历数组40         for (int i = 0; i < arr.length; i++) {41             System.out.println(arr[i]);42         }43         44         for (int item : arr) {45             System.out.println(item);46         }47     }48 }