一、知识点（必做）:

ArrayDemo1.java（重点）

需求：定义数组和数组的静态初始化操作

步骤：

（1）先定义后初始化数组（不能使用简写方式）

（2）定义数组，同时初始化

（3）打印数组长度

（4）数组赋值为空，并演示空指针错误

（5）请在纸上画出以上代码的内存分析图

  1. public class ArrayDemo1 {
  2.     public static void main(String[] args) {
  3.         int[] a = {1, 2, 3};
  4.         int[] b = null;
  5.         System.out.println(a.length);
  6.         System.out.println(b.length);
  7.     }
  8. }
  9. //空指针错误Exception in thread "main" java.lang.NullPointerException: Cannot read the array length because "b" is null

ArrayDemo2java（重点）

需求：数组的动态初始化和内存分析

步骤：

（1）动态初始化数组，并打印数组长度

（2）重新初始化数组，并打印数组长度

（3）请在纸上画出以上代码的内存分析图

  1. public class ArrayDemo2 {
  2.     public static void main(String[] args) {
  3.          int[] nums = new int[4];;
  4.         System.out.println(nums.length);
  5.          nums = new int[7];
  6.         System.out.println(nums.length);
  8.     }
  9. }

ArrayDemo3.java（重点）

需求：数组的基本操作

步骤：

（1）定义一个数组nums,并静态初始化该数组

（2）定义一个变量size获取nums的数组长度

（3）获取数组元素

（4）设置数组元素

（5）遍历数组

  1. public class ArrayDemo3{
  2.     public static void main(String[] args){
  3.         int[] nums={1,2,3};
  4.         int size=nums.length;
  5.         for(int index=1;index<size;index++){
  6.             System.out.println("当前数是第"+index+"个数是"+nums[index]);
  7.         }
  9.     }
  10. }

ArrayDemo4.java（预习题）

需求：找出数组值元素22,在数组中第一次出现的索引位置

步骤：

（1）定义一个数组nums，并初始化该数组

（2）定义一个变量key，表示被搜索的元素

（3）遍历数组

（4）判断如果当前元素和key相等，证明找到元素，打印并结束循环

  1. public class ArrayDemo4{
  2. public static void main(String[] args){
  3. int[] nums = {1, 2, 3, 4, 22, 3, 22};
  4.         int key = 22;
  5.         for (int index = 0; index < nums.length; index++) {
  6.             if (nums[index] == 22) {
  7.                 System.out.println("数组值元素22，在数组中第一次出现的位置" + index);
  8.                 break;
  9.             }
  10.         }
  11. }
  12. }

ArrayDemo5.java（预习题）

需求：求出int类型数组中最大元素值

步骤：

（1）定义并初始化数组nums

（2）定义一个变量max表示最大的元素，并假设nums的第一个元素为最大值

（3）使用foreach循环遍历nums数组

（4）判断如果遍历的元素和max比较，遍历的元素比较大，就将当前元素赋值给max

（5）遍历完成打印max

  1. public class ArrayDemo5 {
  3.         public static void main(String[] args){
  4.             int[] nums= {26,1,23,4,5,7};
  5.             int max=26;
  6.             for(int index=0;index<nums.length;index++){
  7.                 if(nums[index]>26){
  8.                     nums[index]=max;
  9.                 }
  10.                 System.out.println(max);
  11.                 break;
  12.             }
  13.         }
  14.     }

ArrayDemo6.java（预习题）

需求：按照某种格式来打印出数组中的元素，打印效果为：[11,22,33,44,22,55]

步骤：

（1）定义并初始化数组nums

（2）定义一个字符串类型的变量str，用于拼接字符串

（3）遍历数组并拼接元素到str

（4）判断为最后一个元素拼接“]”，否则拼接“，”

（5）打印str

  1. public class ArrayDemo6 {
  2.     public static void main(String[] args) {
  3.         int[] nums = {11, 22, 33, 44, 22, 55};
  4.         String str = "[ ";//str 结果表示字符串，先拼一个符号"["
  5.         for (int index = 0; index < nums.length; index++) {
  6.             //把每一个元素拼接在src后面
  7.             str = str + nums[index];
  8.             //如果是最后一个元素，则不拼接，而是"]"
  9.             if (index == nums.length - 1) {
  10.                 str = str + "]";
  11.             } else {
  12.                 //如果不是最后一个元素拼接","
  13.                 str = str + ",";
  14.             }
  15.         }
  16.         System.out.println(str);
  17.     }
  18. }

二、综合练习（必做）：

LocationDemo.java

需求：定义一个 int 类型数组,求出该数组索引是偶数的元素之和

思路：注意区分索引和元素

数组 - 图1

  1. // step 1
  2. // step 2
  3. // step 3
  4. // step 4
  5. // step ...
  6. public class LocationDemo {
  7.     public static void main(String[] args) {
  8.           int[] numArr = new int[]{11, 22, 33, 44, 55};
  9.         int sum = 0;
  10.         for (int index = 0; index < numArr.length; index++) {
  11.             if (index % 2 == 0) {
  12.                 System.out.println("是第" + index + "个，元素为" + numArr[index]);
  13.                 sum += numArr[index];
  14.             }
  15.         }
  16.         System.out.println("该数组**索引是偶数**的元素之和" + sum);
  17.         //    item 是数组大括号里面的元素值
  18.         //    index是数组下标，最大值是数组值长度length-1，最小值是0
  19.     }
  20. }

ReversedDemo.java

需求：定义一个元素为String类型数组，按照逆序打印该数组的每个元素，例如

数组内容为：{“A”，”B”，”C”，”D”} , 打印效果为：D C B A

  1. // step 1
  2. // step 2
  3. // step 3
  4. // step 4
  5. // step ...
  7. //    item 是数组大括号里面的元素值
  8. //    index是数组下标，最大值是数组值长度length-1，最小值是0
  9. public class ReversedDemo {
  10.     public static void main(String[] args) {
  11. //        定义一个string数组，数组内容为｛"A","B","C","D"｝;
  12.         String[] sxx = {"A", "B", "C", "D"};
  13. //        数组的遍历
  14.         for (int index= sxx.length - 1; index>-1 ; index--) {
  15. //                打印数组的每个元素
  16.             System.out.println(sxx[index]);
  17.         }
  19.     }
  20. }

StatisticsDemo.java

需求：定义一个 int 类型,长度为2的数组，其索引 0 位置存放指定数组索引为偶数的元素之和，索引 1 位置存放指定数组索引为奇数元素之和。

参考图：

数组 - 图2

  1. // step 1
  2. // step 2
  3. // step 3
  4. // step 4
  5. // step ...
  6. public class StatisticsDemo {
  7.     public static void main(String[] args) {
  8.        //定义一个数组长度为2的int数组
  9.         //定义一个int数组
  10.         int[] axx = new int[]{10, 20, 30, 40, 50, 60, 70, 80};
  11.         int[] axx1 = new int[2];
  13.         int sum=0;
  14.         int sum2=0;
  15.         //数组的遍历
  16.         for (int i = 0; i < axx.length; i++) {
  17.             //if判断是否是偶数位
  18.             if (i % 2 == 0) {
  19.                 //求元素下标是偶数元素之和
  20.                 sum+=axx[i];
  21.             }else{
  22.                 //求元素下标是奇书元素之和
  23.                 sum2 +=axx[i];
  24.             }
  25.         }
  26.         //打印奇数和，偶数和
  27.         System.out.println(sum);
  28.         System.out.println(sum2);
  29.         axx1[0]=sum;
  30.         axx1[1]=sum1;
  31.         System.out.println("结果数组"+Arrays.toString(axx1));
  33.     }