变量或者是常量, 只能用来存储一个数据, 例如: 存储一个整数, 小数或者字符串等.
如果需要同时存储多个同类型的数据, 用变量或者常量来实现的话, 非常的繁琐. 针对于
这种情况, 我们就可以通过数组来实现了.
例如: 假设某公司有50名员工, 现在需要统计该公司员工的工资情况, 例如计算平均
工资、获取最高工资等。针对于这个需求，如果用前面所学的知识实现，程序首先需要声
明50个变量来分别记住每位员工的工资，然后在进行操作，这样做非常繁琐，而且错误率
也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一
操作。数组, 就是一种容器.
解释:
- 容器: 就是将多个数据存储到一起, 每个数据都是该容器的元素.
- 现实生活中的容器: 水杯, 衣柜, 教室等...
数组概述
数组就是用来存储多个同类型元素的容器, 例如: 存储5个整数, 或者存储10个小数, 亦或
者存储3个字符串等...
1 package com.it.demo08_array; 2 3 /* 4 案例: 演示数组的定义格式. 5 6 数组简介: 7 概述: 8 数组就是用来 同时存储 多个 同类型元素 的容器. 9 定义格式: 10 动态初始化: 我们给长度, 由系统给出默认值. 11 格式1: 12 数据类型[] 数组名 = new 数据类型[长度]; 13 int[] arr = new int[3]; 14 15 格式2: 16 数据类型 数组名[] = new 数据类型[长度]; 17 int arr[] = new int[3]; 18 19 静态初始化: 我们给出默认值, 由系统决定长度. 20 格式1: 21 数据类型[] 数组名 = new 数据类型[]{值1, 值2, 值3...}; 22 int[] arr = new int[]{11, 22, 33}; 23 24 格式2: 25 数据类型[] 数组名 = {值1, 值2, 值3...}; 26 int[] arr = {11, 22, 33}; //属于格式1的简化版, 学名叫: 语法糖. 27 */ 28 public class Demo01 { 29 public static void main(String[] args) { 30 //1.创建int类型的数组, 用来存储3个元素. //我们给长度, 系统给默认值, 这个叫: 动态初始化. 31 //格式1: 定义一个int类型的数组, 数组名叫: arr1, 初始化长度为3. 32 int[] arr1 = new int[3]; //推荐使用. 33 34 //格式2: 定义一个int类型的arr数组, 数组名叫arr2, 初始化长度为3. 35 int arr2[] = new int[3]; 36 37 38 //2.创建int类型的数组, 存储数据11, 22, 33. //我们给值, 由系统决定长度, 这个叫: 静态初始化. 39 //格式1: 40 int[] arr3 = new int[]{11, 22, 33}; //推荐使用. 41 42 //格式2: 语法糖 43 int[] arr4 = {11, 22, 33}; //推荐使用. 44 } 45 }
1 /* 2 定义数组容器 3 定义数组容器,要素,强制数据类型的语言 4 必须有数据类型, 大小, 就是存储数据的个数 5 定义数组公式: 6 数据类型[] 变量名 = new 数据类型[存储元素的个数]; 7 8 数据类型: 数组中存储元素的数据类型 9 [] 表示数组的意思 10 变量名 自定义标识符 11 12 new 创建容器关键字 13 数据类型: 数组中存储元素的数据类型 14 [] 表示数组的意思 15 元素个数,就是数组中,可以存储多少个数据 (恒定, 定长) 16 17 数组是一个容器: 存储到数组中的每个元素,都有自己的自动编号 18 自动编号,最小值是0, 最大值,长度-1 19 自动编号专业名次, 索引(index), 下标, 角标 20 访问数组存储的元素,必须依赖于索引, 公式 数组名[索引] 21 22 Java提供一个属性,操作索引的 23 数组的一个属性,就是数组的长度, 属性的名字 length 24 使用属性: 数组名.length 数据类型 int 25 26 数组的最小索引是0, 最大索引数组.length-1 27 */ 28 public class ArrayDemo{ 29 public static void main(String[] args){ 30 //定义数组,存储整数,容器长度, 3个 31 // 数据类型[] 变量名 = new 数据类型[存储元素的个数]; 32 int[] arr = new int[3]; 33 System.out.println(arr); 34 35 //通过索引的方式,数组中的三个元素 36 System.out.println(arr[0]); 37 System.out.println(arr[1]); 38 System.out.println(arr[2]); 39 40 41 System.out.println(arr.length); 42 43 44 45 46 47 } 48 }
1 /* 2 数组的常用两个定义方式 3 数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3}; 4 注意事项: new 后面的中括号中,不允许写任何内容,写了就编译失败 5 6 数据类型[] 变量名 = {元素1,元素2,元素3}; 7 */ 8 public class ArrayDemo_2{ 9 public static void main(String[] args){ 10 //定义数组,定义的同时,对元素进行赋值 11 int[] arr = new int[]{1,2,4,5,7,9}; 12 System.out.println(arr.length); 13 System.out.println(arr[5]); 14 15 16 System.out.println("=================="); 17 //定义数组,直接大括号赋值 18 int[] arr2 = {0,2,4,6,8}; 19 System.out.println(arr2.length); 20 System.out.println(arr2[1]); 21 } 22 }
1 /* 2 数组的操作, 使用索引,对数组中的元素赋值 3 */ 4 public class ArrayDemo_1{ 5 public static void main(String[] args){ 6 //定义数组,存储int类型数组,长度就是5 7 int[] arr = new int[5]; 8 9 //将1索引上的元素,赋值3 10 arr[1] = 3; 11 System.out.println(arr[1]); 12 System.out.println(arr[2]); 13 } 14 }
1 /* 2 数组遍历: 3 将所有的数组元素,全获取 4 依靠索引, 规律从0开始,一直在自动增长1, 到达length-1 5 循环来实现 6 for 知道循环次数, 计数器思想 7 while 不确定循环次数 8 */ 9 10 public class ArrayDemo_3{ 11 public static void main(String[] args){ 12 int[] arr = {2,1,3,5,7,0,4}; 13 14 for(int i = 0 ; i < arr.length; i++){ 15 System.out.println(arr[i]); 16 } 17 } 18 }
1 /* 2 数组操作中,常见的两个异常 3 数组的索引越界异常 4 空指针异常 5 */ 6 public class ArrayDemo_4{ 7 public static void main(String[] args){ 8 //数组的索引越界异常 9 //int[] arr = {5,2,1}; 10 //数组中3个元素,索引 0,1,2 11 //System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3 12 13 //空指针异常 14 int[] arr2 = {1,5,8}; 15 System.out.println(arr2[2]); 16 arr2 = null; // arr2 不在保存数组的地址了 17 System.out.println(arr2[2]);//java.lang.NullPointerException 18 } 19 }
1 /* 2 计算数组中的最大值 3 数组 {4,1,7,5}; 做比较 4 */ 5 public class ArrayDemo_5{ 6 public static void main(String[] args){ 7 //定义数组,int类型 8 int[] arr = {5,1,12,4,6,8,0,3}; 9 //定义变量,记录数组中0索引上的元素 10 int max = arr[0]; 11 12 //遍历数组,获取所有的元素,和变量max比较 13 for(int i = 1; i < arr.length ; i++){ 14 //变量max,和数组中的每个元素进行比较 15 //如果max,小于了数组中的一个元素 16 if( max < arr[i] ){ 17 //较大的数组的元素,赋值给max 18 max = arr[i]; 19 } 20 } 21 // 遍历完成,变量max,就是数组最大值 22 System.out.println(max); 23 } 24 }
1 package com.it.demo08_array; 2 3 /* 4 案例: 演示数组的基本格式. 5 6 涉及到的知识点: 7 数组的各部分解释, 此处以 动态初始化举例, 例如: int[] arr = new int[3]; 8 int: 表示数组中存储元素的数据类型, int说明只能存储整数, 如果是String说明只能存储字符串, 如果是double, 说明只能存储小数. 9 []: 表示它是一个数组 10 arr: 表示数组名, 命名的规则和命名变量是一样的(遵循小驼峰命名法), 都要符合标识符的规范. 11 new: 表示创建对象, 该对象存储在 堆内存 空间. 12 3: 表示数组的长度, 即: 数组中最多只能存储几个数据. 13 14 数组的元素特点: 15 1. 数组中每个元素都是有索引(也叫: 编号, 角标, 下标)的, 且索引是从 0 开始的. 16 2. 数组中的每个元素都是有默认值的, 例如: 17 int[], 元素默认值为: 0 18 double[], 元素默认值为: 0.0 19 boolean[], 元素默认值为: false 20 String[], 元素默认值为: null 21 22 数组的基本格式: 23 数组名[索引] 根据索引值, 获取该索引对应的元素. 24 数组名[索引] = 值 修改指定索引处的元素为指定的值. 25 数组名.length 获取数组的长度. 26 数组名.length - 1 获取数组中最后一个元素的索引. 27 28 */ 29 public class Demo02 { 30 public static void main(String[] args) { 31 //1.定义一个长度为5的int类型的数组. 32 int[] arr = new int[5]; //11 0, 0, 0, 0 33 System.out.println(arr); //因为数组是对象, 所以直接打印数组, 打印的是: 该对象在内存中的地址值. 34 35 //2.打印数组中的第3个元素. 36 System.out.println(arr[2]); //索引从0开始. 37 38 //3.设置数组中的第一个元素值为11. 39 arr[0] = 11; 40 41 //4.获取数组中的第一个元素值, 并将其赋值给变量a, 然后打印. 42 int a = arr[0]; 43 System.out.println(a); //11 44 45 //5.打印数组的长度. 46 System.out.println(arr.length); 47 } 48 }
1 package com.it.demo08_array; 2 3 /* 4 JVM的内存划分: 5 1. 栈 6 作用: 7 存储局部变量以及所有代码的执行的. 8 //局部变量: 就是定义在方法中或者方法声明上的变量. 9 特点: 10 先进后出, 后进先出. //用完就释放. 11 2. 堆 12 作用: 13 存储所有new出来的内容(对象) 14 特点: 15 在不确定的时间, 被GC(Java中的垃圾回收机制)回收. 16 3. 方法区 17 作用: 18 用来存储 字节码文件, 静态成员, 常量, 具体的方法等内容. 19 分类: 20 代码区, 方法区, 常量池, 静态区. 21 4. 本地方法区 22 给本地方法(native修饰的方法)使用的, 我们了解即可. 23 5. 寄存器 24 给CPU使用的, 我们了解即可. 25 */ 26 27 //案例: 演示一个数组的内存图. 28 public class Demo03 { 29 public static void main(String[] args) { 30 int[] arr = new int[3]; 31 System.out.println(arr[0]); //打印数组中的第一个元素, 值为: 0 32 System.out.println(arr); //[I@1540e19d 33 } 34 }
1 package com.it.demo08_array; 2 3 //案例: 演示两个数组的内存图 4 public class Demo04 { 5 public static void main(String[] args) { 6 //1.定义一个长度为3的int类型的数组. 7 int[] arr = new int[3]; //0, 0, 0 8 //2.修改数组中的第一个元素为: 11 9 arr[0] = 11; //11, 0, 0 10 //3.打印数组中的第一, 第二个元素. 11 System.out.println(arr[0]); //11 12 System.out.println(arr[1]); //0 13 //4.打印数组对象. 14 System.out.println(arr); //地址值 15 //5.定义一个int类型的数组, 存储元素1, 2. 16 int[] arr2 = new int[]{1, 2}; //1, 2 17 //6.修改数组的第二个元素值为: 22. 18 arr2[1] = 22; //1, 22 19 //7.打印数组的第二个元素. 20 System.out.println(arr2[1]); //22 21 //8.打印数组对象. 22 System.out.println(arr2); //地址值 23 } 24 }
1 package com.it.demo08_array; 2 3 //案例: 演示两个数组指向同一个地址的内存图. 4 public class Demo05 { 5 public static void main(String[] args) { 6 //1.定义一个int类型的数组, 存储元素11, 22, 33. 7 int[] arr = new int[]{11, 22, 33}; 8 //2.打印数组对象. 9 System.out.println(arr); 10 //3.打印数组中的各个元素值. 11 System.out.println(arr[0]); 12 System.out.println(arr[1]); 13 System.out.println(arr[2]); 14 //4.定义第二个数组, 把第一个数组的地址值赋值给第二个数组. 15 int[] arr2 = arr; 16 //5.通过第二个数组, 修改第二个元素值为200. 17 arr2[1] = 200; 18 //6.打印数组对象. 19 System.out.println(arr2); 20 //7.打印数组中的各个元素值. 21 System.out.println(arr[0]); 22 System.out.println(arr[1]); 23 System.out.println(arr[2]); 24 25 System.out.println(arr2[0]); 26 System.out.println(arr2[1]); 27 System.out.println(arr2[2]); 28 29 } 30 }
1 /* 2 二维数组 3 数组中的数组,数组里面存储的还是数组 4 5 定义方式和一维数组很相似 6 7 int[][] arr = new int[3][4]; 8 定义一个二维数组 9 [3] 表示: 二维数组中,有三个一维数组 10 [4] 表示: 三个一维数组中,每个数组的长度是4 11 */ 12 public class ArrayArrayDemo{ 13 public static void main(String[] args){ 14 int[][] arr = new int[3][4]; 15 System.out.println(arr); 16 17 System.out.println(arr[1]); 18 System.out.println(arr[2][3]); 19 } 20 }
1 /* 2 int[][] arr = new int[3][] 不推荐 3 二维数组中定义三个一维数组,每个一维数组长度,没有指定 4 arr[0] 5 arr[1] 6 arr[2] 7 必须要new 8 arr[0] = new int[5]; 9 arr[1] = new int[4]; 10 11 最简单的二维数组定义方式 12 int[][] arr = { {1,4} ,{3,6,8}, {0,9,8} }; 13 */ 14 15 public class ArrayArrayDemo_1{ 16 public static void main(String[] args){ 17 int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} }; 18 19 //问题: 打印7,是数组中的元素0 20 21 System.out.println(arr[2][1]); 22 23 //问题: 输出结果 24 System.out.println(arr[3][0]); 25 } 26 }
1 /* 2 二维数组的遍历 3 二维数组中,存储4个一维数组,每个一维数组的长度不同 4 5 遍历: for循环,遍历二维数组 6 遍历过程中, for遍历一维数组 7 8 */ 9 public class ArrayArrayDemo_2{ 10 public static void main(String[] args){ 11 int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} }; 12 13 //外循环,遍历二维数组 14 for(int i = 0 ; i < arr.length ;i++){ 15 //内循环,遍历每个一维数组 arr[0] arr[1] arr[i] 16 for(int j = 0 ; j < arr[i].length; j++){ 17 System.out.print(arr[i][j]); 18 } 19 System.out.println(); 20 } 21 } 22 }
1 /* 2 二维数组的遍历求和 3 第一小组销售额为{11, 12}万元 4 第二小组销售额为{21, 22, 23}万元 5 第三小组销售额为{31, 32, 33, 34}万元。 6 每个小组就是一个数组, 三个数组存储到一个数组中,形成二维数组 7 求和: 8 每个小组求和 9 所有元素求和 10 */ 11 12 public class ArrayArrayDemo_3{ 13 public static void main(String[] args){ 14 int[][] arr = { {11,12} , {21,22,23} ,{31,32,33,34} }; 15 //定义变量,保存2个求和的值 16 int sum = 0 ; //所有元素的求和 17 int groupSum = 0 ; //每个一维数组的求和 18 19 for(int i = 0 ; i < arr.length ; i++){ 20 for(int j = 0 ; j < arr[i].length ; j++){ 21 //将一维数组的元素求和 22 groupSum += arr[i][j]; 23 } 24 System.out.println("每个小组总金额 "+groupSum); 25 26 //将每个一维数组的总和在相加 27 sum += groupSum; 28 //每个唯一数组求和,清空 29 groupSum = 0; 30 } 31 System.out.println("本公司总金额 "+sum); 32 } 33 }
1 /* 2 随机点名器: 3 1 存储姓名 4 2. 预览所有人的姓名 5 3. 随机出一个人的姓名 6 */ 7 import java.util.Random; 8 public class CallName{ 9 public static void main(String[] args){ 10 //存储姓名,姓名存储到数组中 11 //数组存储姓名,姓名的数据类型,String 12 String[] names = {"张三","李四","王五","李蕾","韩梅梅","小名","老王","小华","约翰逊","爱丽丝"}; 13 14 //预览: 遍历数组,打印所有姓名 15 for(int i = 0 ; i < names.length ; i++){ 16 System.out.println(names[i]); 17 } 18 System.out.println("============="); 19 20 //随机出一个人的名 21 //利用随机数,生成一个整数,作为索引,到数组中找到对应的元素 22 Random ran = new Random(); 23 //随机数,范围必须是0-数组的最大索引 24 int index = ran.nextInt(names.length);//index 就是随机数,作为索引 25 System.out.println(names[index]); 26 } 27 }
1 package com.it.demo01_array; 2 3 /* 4 案例: 数组内容回顾. 5 6 数组简介: 7 概述: 8 就是用来同时存储 多个 同类型元素的 容器. 9 特点: 10 1. 元素都有编号(下标, 角标, 索引), 且编号是从 0 开始的. 11 2. 数组的每个元素都有默认值. 12 int[] -> 0 13 double[] -> 0.0 14 boolean[] -> false 15 引用类型数组-> null 16 定义格式: 17 动态初始化: 我们给长度, 系统给默认值. 18 格式1: 19 int[] arr = new int[3]; 20 格式2: 21 int arr[] = new int[3]; 22 静态初始化: 我们给值, 由系统决定长度. 23 格式1: 24 int[] arr = new int[]{11, 22, 33}; 25 格式2: 26 int[] arr = {11, 22, 33}; 27 数组的基本使用格式: 28 数组名[索引] 根据索引, 获取数组中的该元素值. 29 数组名[索引] = 值 修改指定索引处的元素为指定的值. 30 数组名.length 获取数组的长度 31 数组名.length - 1 获取数组中元素的 最大索引值. 32 数组的内存图: 33 了解. 34 */ 35 public class Demo01 { 36 public static void main(String[] args) { 37 38 } 39 }
1 package com.it.demo01_array; 2 3 /* 4 案例: 演示使用数组时的两个小问题. 5 6 问题一: 数组索引越界异常(ArrayIndexOutOfBoundsException) 7 问题描述: 8 数组的长度为2, 但是我们却访问了数组中的第3个元素, 此时代码就有问题了, 会报: 数组索引越界异常(ArrayIndexOutOfBoundsException) 9 产生原因: 10 你访问了数组中不存在的元素. 11 解决方案: 12 访问数组中存在的元素即可. 13 */ 14 public class Demo02 { 15 public static void main(String[] args) { 16 //1.定义int类型的数组, 存储元素11, 22. 17 //int[] arr = new int[]{11, 22}; 18 int[] arr = {11, 22}; //int a = 10; 19 arr = new int[]{1, 2, 3, 4, 5}; //a = 20; 20 //arr = {1, 2, 3, 4, 5, 6}; //这样写会报错, 静态初始化的 语法糖只有在定义数组的时候有效. 21 22 //2.打印数组中的第2个元素. 23 System.out.println(arr[1]); //22 24 25 //3.尝试打印数组中的第3个元素. 26 System.out.println(arr[2]); //数组索引越界异常(ArrayIndexOutOfBoundsException) 27 } 28 }
1 package com.it.demo01_array; 2 3 /* 4 案例: 演示空指针异常. 5 6 问题二: 空指针异常(NullPointerException) 7 问题描述: 8 我们定义了数组对象, 初始化值为11, 22, 然后将null赋值给数组对象, 发现打印数组的第一个元素时, 程序报错: 空指针异常(NullPointerException) 9 产生原因: 10 null表示空, 即什么都没有, 所以你通过null去访问数组中的元素, 肯定找不到, 于是就报错. 11 解决方案: 12 new一个具体的数组, 然后来访问数组中存在的元素即可. 13 14 */ 15 public class Demo03 { 16 public static void main(String[] args) { 17 //1.定义int类型的数组, 存储元素11, 22. 18 int[] arr = {11, 22}; 19 //2.将null(空常量)赋值给数组. 20 arr = null; 21 //arr = new int[3]; 22 //3.尝试打印数组的第一个元素. 23 System.out.println(arr[0]); //空指针异常(NullPointerException) 24 } 25 }
1 package com.it.demo02_exercise; 2 3 /* 4 案例: 遍历数组. 5 6 大白话翻译: 即逐个获取数组中的元素, 并打印. 7 */ 8 public class Demo01 { 9 public static void main(String[] args) { 10 //1.定义int类型的数组arr, 存储元素11, 22, 33, 44, 55. 11 int[] arr = {11, 22, 33, 44, 55}; 12 13 //2.通过for循环, 遍历数组. 14 15 //方式二: 实际开发版 16 //2.1 通过for循环, 获取数组中所有元素的索引. 17 for (int i = 0; i < arr.length; i++) { 18 //i就是数组中每个元素的: 索引值. 19 20 //2.2 根据 数组名[索引] 的方式, 获取数组中的元素. 21 System.out.println(arr[i]); 22 } 23 24 System.out.println("------------------------"); 25 //方式一: 最Low版 26 System.out.println(arr[0]); 27 System.out.println(arr[1]); 28 System.out.println(arr[2]); 29 System.out.println(arr[3]); 30 System.out.println(arr[4]); 31 } 32 }
1 package com.it.demo02_exercise; 2 3 /* 4 案例: 获取数组元素的最大值. 5 6 需求: 7 已知各位美女的颜值如下图, 请求出下图中, 颜值最高的数字, 并打印到控制台上. 8 即:求数组int[] arr = {5, 15, 2000, 10000, 100, 4000};的最大值. 9 10 细节: 11 1. 假设数组的第一个元素值为最大(小)值, 这个值不能我们自定义, 否则可能会比数组中所有元素值都大, 或者都小. 12 2. 从数组的第二个元素开始遍历, 逐个比较, 可以减少一次比较次数, 从而节约资源, 提高效率. 13 */ 14 public class Demo02 { 15 public static void main(String[] args) { 16 //已知各位美女的颜值如下图, 请求出下图中, 颜值最高的数字, 并打印到控制台上. 17 //即:求数组int[] arr = {5, 15, 2000, 10000, 100, 4000};的最大值. 18 //1. 定义数组, 记录要获取最值的元素. 19 int[] arr = {5, 15, 2000, 10000, 100, 4000}; 20 21 //2. 定义变量, 用来记录数组元素的最大值. 22 int max = arr[0]; 23 24 //3. 遍历数组, 获取到每一个元素. 25 for (int i = 1; i < arr.length; i++) { 26 //arr[i]: 就是数组中的每个元素 27 //4. 依次比较当前遍历到的元素 是否大于 临时变量max的值, 如果大, 就将其值赋值给max. 28 if (arr[0] > max) 29 max = arr[i]; 30 } 31 //5. for循环结束后, max记录的就是数组元素的最大值, 打印结果即可. 32 System.out.println("数组元素最大值是: " + max); 33 } 34 }
1 package com.it.demo02_exercise; 2 3 /* 4 案例: 演示数组元素的反转. 5 6 解决方案: 7 思路一: 初始化条件定义一个. 8 细节一: 必须明确数组元素的交换次数, 即: 数组的长度 / 2 9 细节二: 必须明确谁和谁交换. arr[i] 和 arr[arr.length - 1 - i] 10 11 思路二: 初始化条件定义两个. 12 细节: 13 定义两个变量start, end, 分别记录交换双方的元素的索引值, 一个(start)从前往后, 一个(end)从后往前. 14 15 分析思路: 16 arr[0] arr[arr.length - 1 - 0] 17 第1次交换: 第一个元素11 和 倒数第一个元素44, 交换完毕后为: 44, 33, 22, 55, 11 18 19 arr[1] arr[arr.length - 1 - 1] 20 第2次交换: 第二个元素33 和 倒数第二个元素55, 交换完毕后为: 44, 55, 22, 33, 11 21 22 ... 23 arr[i] arr[arr.length - 1 - i] 24 第i次交换: 第i个元素 和 倒数第i个元素交换. 25 26 */ 27 public class Demo03 { 28 public static void main(String[] args) { 29 //1.定义int类型的数组, 存储数据: 11, 33, 22, 55, 44. 30 int[] arr = { 11, 33, 22, 55, 44}; 31 32 //2.反转数组 33 /* 34 思路一: 初始化条件定义一个. 35 36 细节一: 必须明确数组元素的交换次数, 即: 数组的长度 / 2 37 细节二: 必须明确谁和谁交换. arr[i] 和 arr[arr.length - 1 - i] 38 */ 39 /*for (int i = 0; i < arr.length / 2; i++) { 40 //arr[i] 和 arr[arr.length - 1 - i] 交换 41 int temp = arr[i]; 42 arr[i] = arr[arr.length - 1 - i]; 43 arr[arr.length - 1 - i] = temp; 44 }*/ 45 46 47 //思路二: 初始化条件定义两个. 48 for(int start = 0, end = arr.length - 1; start < end; start++, end--) { 49 //arr[start] 和 arr[end]交换 50 int temp = arr[start]; 51 arr[start] = arr[end]; 52 arr[end] = temp; 53 } 54 55 //3. 并打印反转后的结果. 56 for (int i = 0; i < arr.length; i++) { 57 System.out.println(arr[i]); 58 } 59 } 60 }
1 package com.it.demo02_exercise; 2 3 /* 4 案例: 计算数组的元素和. 5 6 需求: 7 1. 定义int类型的数组, 存储数据: 11, 33, 22, 55, 44. 8 2. 计算数组的元素和, 并打印结果. 9 */ 10 public class Demo04 { 11 public static void main(String[] args) { 12 //1. 定义int类型的数组, 存储数据: 11, 33, 22, 55, 44. 13 int[] arr = {11, 33, 22, 55, 44}; 14 //2. 定义求和变量sum, 用来记录所有元素的和. 15 int sum = 0; 16 //3. 遍历数组, 获取到每一个元素. 17 for (int i = 0; i < arr.length; i++) { 18 sum += arr[i]; 19 } 20 //4. 将获取到的值累加给遍历sum 21 System.out.println("数组元素和为: " + sum); 22 23 //5. 打印结果. 24 } 25 }
浙公网安备 33010602011771号