原Java学习笔记010 - 数组
Posted iflytek
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了原Java学习笔记010 - 数组相关的知识，希望对你有一定的参考价值。
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数据类型的数组，名字叫yyy 29 // 形式2：数据类型 数组名[]：声明了一个xxx数据类型，名字叫yyy的数组 30 31 // 声明一个成绩数组 32 // int[] scoreArr; 33 // int scoreArr[]; // 语法OK，但是不建议这样写 34 35 // 数组变量使用前必须进行初始化操作 36 // 语法错误：The local variable scoreArr may not have been initialized 37 // 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 // 下句输出 [[email protected] ，表示了scoreArr数组变量在内存中的类型 和 地址（以@符号作为分隔，前面是类型，后面是地址） 55 System.out.println(scoreArr); // [[email protected] 56 } 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 int 13 // arr[1] = true; // 对数组中的第二个元素赋值为true 14 15 // 向int类型的元素存放long类型的内容，语法出错 16 // 产生语法错误：Type mismatch: cannot convert from long to int 17 // arr[1] = 12345678901L; 18 19 // 向int类型的元素存放byte类型的内容，语法OK 20 // arr[1] = (byte)126; 21 22 // 向int类型的元素存放short类型的内容，语法OK 23 // arr[1] = (short)130; 24 25 // 【数组在内存中的存储形式】 26 // 赋值号左边的是数组的声明，类比名片 27 // 赋值号右边的是数组的内容，类比具体的家的位置 28 // 通过名片找到具体的家的位置 29 // 通过栈上声明的变量找到堆中具体存放内容的位置来使用数组 30 31 // System.out.println(arr); // [[email protected] 32 33 // 数组中元素的默认值 34 // byte、short、int、long类型的数组的元素默认值为0 35 // int[] arr1 = new int[3]; 36 // System.out.println(arr1[0]); // 0 37 // System.out.println(arr1[1]); // 0 38 // System.out.println(arr1[2]); // 0 39 40 // byte[] arr2 = new byte[3]; 41 // System.out.println(arr2[0]); // 0 42 // System.out.println(arr2[1]); // 0 43 // System.out.println(arr2[2]); // 0 44 // 45 // short[] arr3 = new short[3]; 46 // System.out.println(arr3[0]); // 0 47 // System.out.println(arr3[1]); // 0 48 // System.out.println(arr3[2]); // 0 49 // 50 // long[] arr4 = new long[3]; 51 // System.out.println(arr4[0]); // 0 52 // System.out.println(arr4[1]); // 0 53 // System.out.println(arr4[2]); // 0 54 55 // double、float类型的数组的元素默认值为0.0 56 // double[] arr5 = new double[3]; 57 // System.out.println(arr5[0]); // 0.0 58 // System.out.println(arr5[1]); // 0.0 59 // System.out.println(arr5[2]); // 0.0 60 // 61 // float[] arr6 = new float[3]; 62 // System.out.println(arr6[0]); // 0.0 63 // System.out.println(arr6[1]); // 0.0 64 // System.out.println(arr6[2]); // 0.0 65 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类型的数组的元素默认值为false 73 boolean[] arr8 = new boolean[3]; 74 System.out.println(arr8[0]); // false 75 System.out.println(arr8[1]); // false 76 System.out.println(arr8[2]); // false 77 } 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); // [[email protected] 8 System.out.println(scoreArr[0]); // 0 9 System.out.println(scoreArr[1]); // 0 10 System.out.println(scoreArr[2]); // 0 11 12 System.out.println("-------------------------------------"); 13 14 // 对数组中的部分元素进行赋值 15 scoreArr[0] = 80; 16 scoreArr[2] = 55; 17 18 // 1、数组的元素的值发生变化后，数组的地址没有变化 19 // 2、数组的元素的值发生变化后，数组中没有发生变化的元素的值还是之前的值 20 System.out.println(scoreArr); // [[email protected] 21 System.out.println(scoreArr[0]); // 80 22 System.out.println(scoreArr[1]); // 0 23 System.out.println(scoreArr[2]); // 55 24 } 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循环-----> foreach 29 // 增强型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 byte 40 // for (byte i : scoreArr) { 41 // System.out.println(i); 42 // } 43 44 // 产生错误：Type mismatch: cannot convert from element type int to short 45 // for (short i : scoreArr) { 46 // System.out.println(i); 47 // } 48 49 // 语法OK 50 // 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); // [[email protected] 14 printArray(arr1); 15 16 System.out.println("数组2的地址：" + arr2); // [[email protected] 17 printArray(arr2); 18 19 System.out.println("----- 修改元素值 -----"); 20 21 arr2[0] = 38; 22 arr2[1] = 100; 23 24 System.out.println("数组1的地址：" + arr1); // [[email protected] 25 printArray(arr1); 26 27 System.out.println("数组2的地址：" + arr2); // [[email protected] 28 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); // [[email protected] 13 printArray(arr1); 14 15 System.out.println("数组2的地址：" + arr2); // [[email protected] 16 printArray(arr2); 17 18 System.out.println("----- 修改元素值 -----"); 19 20 arr2[0] = 38; 21 arr2[1] = 100; 22 23 System.out.println("数组1的地址：" + arr1); // [[email protected] 24 printArray(arr1); 25 26 System.out.println("数组2的地址：" + arr2); // [[email protected] 27 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 provided 37 // 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); // [[email protected] 11 System.out.println("数组的长度为：" + arr.length); // 0 12 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 assigned 31 // 数组的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 }
以上是关于原Java学习笔记010 - 数组的主要内容，如果未能解决你的问题，请参考以下文章
[原创]java WEB学习笔记61：Struts2学习之路--通用标签 property，uri，param,set,push,if-else,itertor,sort,date,a标签等(代码片段