变量或者是常量, 只能用来存储一个数据, 例如: 存储一个整数, 小数或者字符串等.

如果需要同时存储多个同类型的数据, 用变量或者常量来实现的话, 非常的繁琐. 针对于

这种情况, 我们就可以通过数组来实现了.

　　例如: 假设某公司有50名员工, 现在需要统计该公司员工的工资情况, 例如计算平均

工资、获取最高工资等。针对于这个需求，如果用前面所学的知识实现，程序首先需要声

明50个变量来分别记住每位员工的工资，然后在进行操作，这样做非常繁琐，而且错误率

也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一

操作。数组, 就是一种容器.

解释:

1. 容器: 就是将多个数据存储到一起, 每个数据都是该容器的元素.
2. 现实生活中的容器: 水杯, 衣柜, 教室等…

数组概述

数组就是用来存储多个同类型元素的容器, 例如: 存储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 }