Java 复习整理day03

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

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

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

　　例如: 假设某公司有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 }