一、知识点（必做）:

ArrayDemo4.java（重点）

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

步骤：

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

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

（3）遍历数组

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

  1. package _text_day06;
  3. /*需求：找出数组值元素22,在数组中第一次出现的索引位置
  4. 步骤：
  5. （1）定义一个数组nums，并初始化该数组
  6. （2）定义一个变量key，表示被搜索的元素
  7. （3）遍历数组
  8. （4）判断如果当前元素和key相等，证明找到元素，打印并结束循环*/
  9. public class ArrayDemo4 {
  10.     public static void main(String[] args) {
  11. //       定义一个数组nums，并初始化该数组
  12.         int[] nums = {1, 22, 5, 4, 5, 7};
  13. //        定义一个变量key，表示被搜索的元素
  14.         int key = 22;
  15. //        遍历数组
  16.         for (int i = 0; i < nums.length; i++) {
  17.             if (nums[i] == 22) {
  18.                 System.out.println("数组值元素22,在数组中第一次出现的索引位置"+i);
  19.                 break;
  20.             }
  21.         }
  22.     }
  23. }
  24. //总结:关键就是要会数组的遍历，其他没什么

ArrayDemo5.java

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

步骤：

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

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

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

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

（5）遍历完成打印max

  1. package _text_day06;
  3. /*需求：求出int类型数组中最大元素值
  4. 步骤：
  5. （1）定义并初始化数组nums
  6. （2）定义一个变量max表示最大的元素，并假设nums的第一个元素为最大值
  7. （3）使用foreach循环遍历nums数组
  8. （4）判断如果遍历的元素和max比较，遍历的元素比较大，就将当前元素赋值给max
  9. （5）遍历完成打印max*/
  10. public class ArrayDemo5 {
  11.     public static void main(String[] args) {
  12. //定义并初始化数组nums
  14.         int[] nums = new int[]{1, 2, 4, 7, 8, 2};
  15. //定义一个变量max表示最大的元素，并假设nums的第一个元素为最大值
  16.         int max = nums[0];
  17. //使用foreach循环遍历nums数组
  18.         for (int item : nums)
  19.         //判断如果遍历的元素和max比较，遍历的元素比较大，就将当前元素赋值给max
  20.         {
  21.             if (item > max) {
  22.                 max = item;
  23.             }
  24.         }
  25. //遍历完成打印max
  26.         System.out.println(max);
  27.     }
  28. }

ArrayDemo6.java

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

步骤：

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

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

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

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

（5）打印str

  1. package _text_day06;
  2. /*需求：按照某种格式来打印出数组中的元素，打印效果为：[11,22,33,44,22,55]
  3. 步骤：
  4. （1）定义并初始化数组nums
  5. （2）定义一个字符串类型的变量str，用于拼接字符串
  6. （3）遍历数组并拼接元素到str
  7. （4）判断为最后一个元素拼接“]”，否则拼接“，”
  8. （5）打印str*/
  9. public class ArrayDemo6 {
  10.     public static void main(String[] args) {
  11. //定义并初始化数组nums
  12.         int[] nums=new int[]{11,22,33,44,22,55};
  13. //定义一个字符串类型的变量str，用于拼接字符串
  14.         String str="[";
  15. //遍历数组并拼接元素到str
  16.         int item;
  17.         for (int i =0;i<nums.length;i++){
  18.             item=nums[i];
  19.             str+=item;
  20.             if (i==nums.length-1){
  22.                 str+="]";
  23.             }else {
  24.                 //判断为最后一个元素拼接“]”，否则拼接“，”
  25.                  str+=",";
  26.             }
  27.         }
  29. //打印str*/
  30.         System.out.println(str);
  31.     }
  32. }
  33. //总结：注意遍历数组后需要判断才能得出最后输出结果

ArrayInArrayDemo.java

需求：演示二维数组的基本操作

步骤：

（1）定义一个二维数组

（2）静态初始化二维数组

（3）动态初始化二维数组

（4）获取二维数组的元素

（5）设置二维数组的元素

（6）for循环遍历并打印二维数组的元素

（7）foreach循环遍历并打印二维数组的元素

  1. package _text_day06;
  2. /*需求：演示二维数组的基本操作
  3. 步骤：
  4. （1）定义一个二维数组
  5. （2）静态初始化二维数组
  6. （3）动态初始化二维数组
  7. （4）获取二维数组的元素
  8. （5）设置二维数组的元素
  9. （6）for循环遍历并打印二维数组的元素
  10. （7）foreach循环遍历并打印二维数组的元素*/
  11. public class ArrayInArrayDemo {
  12.     public static void main(String[] args) {
  13. ////定义一个二维数组
  14.         int[][] arrInArr;
  15. //静态初始化二维数组
  16.         int[][] arr1={{},{},{}};
  17. //动态初始化二维数组
  18.         int[][] arr2=new int[3][4];
  19. //获取二维数组的元素
  20.         //for循环遍历并打印二维数组的元素
  21.          for (int i=0;i<arr1.length;i++){
  22.             System.out.println(arr1[i]);
  23.         }
  24. //设置二维数组的元素
  25. //foreach循环遍历并打印二维数组的元素
  26.         for (int[] i:arr2) {
  27.             System.out.println(i);
  28.         }
  29.     }
  30. }