一、数组

  • 基本介绍

    • 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数组就是一组数据

      1. 基本语法

  • 初始化数组

    1. 动态初始化 1
      • 数组的定义
        • 数组类型 数组名[] = new 数据类型[大小]
        • 如：int a[] = new int[5] // 创建一个数组，名字a，存放5个int
      • 数组的引用(使用/访问/获取)
        • 数组名[下标/索引/index] // 下标从0开始
      • 案例演示 ```java // 循环输入5个成绩，保存到double数组，并输出

// 第一种动态分配方式 double scores[] = new double[5]; // 初始化数组

Scanner scanner = new Scanner(System.in); for (int i = 0; i < scores.length; i++) { // .length表示数组的长度 System.out.print(“请输入第” + (i + 1) + “个元素的值：”); scores[i] = scanner.nextDouble(); // scores[i] 用来接收输入 } // 输出，遍历数组 for (int i = 0; i < scores.length; i++) { System.out.println(“第” + (i + 1) + “个元素为：” + scores[i]); }

  2.    2.  动态初始化 2 
  3.       -  声明数组 
  4.          - `数据类型 数组名[];` 或者 `数据类型[] 数组名;`
  5.          - `int a[];` 或者 `int[] a;`
  6.       -  创建数组 
  7.          - `数组名 = new 数据类型[大小];`
  8.          - `a = new int[10];`
  9.       -  案例演示 
  10. ```java
  11. // 循环输入5个成绩，保存到double数组，并输出
  13. // 第二种动态分配方式，先声明数组，再new分配空间
  14. double scores[]; // 声明数组，这时scores为null
  15. scores = new double[5]; // 分配内存空间，可以存放数据
  17. Scanner scanner = new Scanner(System.in);
  18. for (int i = 0; i < scores.length; i++) { // .length表示数组的长度
  19.     System.out.print("请输入第" + (i + 1) + "个元素的值：");
  20.     scores[i] = scanner.nextDouble(); // scores[i] 用来接收输入
  21. }
  22. // 输出，遍历数组
  23. for (int i = 0; i < scores.length; i++) {
  24.     System.out.println("第" + (i + 1) + "个元素为：" + scores[i]);
  25. }
  1. 静态初始化
    • 初始化数组
      • 数据类型 数组名[] = { 元素值, 元素值, ... }
      • int a[] = { 2, 5, 6, 7, 8, 89, 90}
    • 案例演示 ```java // 定义一个数组 // 1. double[] 表示是double类型的数组，数组名 hens // 2. {3, 5, 1, 3.4, 2, 50} 表示数组的值/元素 double[] hens = { 3, 5, 1, 3.4, 2, 50 };

// 遍历数组得到数组的所有元素的和 // 1. 我们可以通过 hens[下标] 来访问数组的元素，下标是从0开始编号的 // 2. 通过for就可以循环的访问数组的元素/值 // 3. 使用一个变量将各个元素累计 // 4. 数组名.length 返回数组的长度 double total = 0; for (int i = 0; i < hens.length; i++) { // System.out.println(“第” + (i + 1) + “个元素的值 = “ + hens[i]); total += hens[i]; } System.out.println(“总数 = “ + total + “ 平均数 = “ + total / 6);

  2. -  注意事项 
  3.    1. 数组是多个**想同类型**数据的组合，实现对这些数据的统一管理
  4.    1. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
  5.    1. 数组创建后，如果没有赋值，有默认值 
  6.       - `int 0, short 0, byte 0, long 0, float 0.0, double 0.0, char \u0000, boolean false, String null`
  7.    4. 使用数组的步骤 
  8.       1. 声明数组并开辟空间
  9.       1. 给数组各个元素赋值
  10.       1. 使用数组
  11.    5. 数组的下标是从0开始的
  12.    5. 数组下标必须在指定范围内使用，否则报：下标越界异常
  13.    5. 数组属于引用类型，数组型数据是对象(object)
  14. -  案例演示 
  15. ```java
  16. public static void main(String[] args) {
  17.     /*
  18.      * 创建一个char类型的26个元素的数组，分别放置'A'-'Z'
  19.      * 使用for循环访问所有元素并打印出来
  20.      * 提示：char类型数据运算 'A' + 1 = 'B'
  21.      * 
  22.      * 思路分析：
  23.      * 1. 创建数组，遍历字母写入数组
  24.      * 2. for循环打印数组
  25.      */
  26.     char letter[] = new char[26];
  27.     // 第一种写法
  28.     // for (char c = 'A', i = 0; c <= 'Z'; c++, i++) {
  29.     //     letter[i] = c;
  30.     // }
  31.     // 第二种写法
  32.     for (int i = 0; i < letter.length; i++) { // 循环
  33.         letter[i] = (char) ('A' + i); // 'A' + i 是int，需要强制转换
  34.     }
  35.     for (int i = 0; i < letter.length; i++) {
  36.         System.out.print(letter[i] + " ");
  37.     }
  38. }

2. 数组的赋值机制

  1. 基本数据类型赋值，这个值就是具体的数据，而且互相不影响 ```java // 基本数据类型赋值 // n2的变化不会影响到n1的值 int n1 = 2; int n2 = n1;

n2 = 80; // n2的变化不会影响到n1的值 System.out.println(“n1 = “ + n1 + “, n2 = “ + n2); // n1 = 10, n2 = 80

  2. 2.  数组在默认情况下是引用传递，赋的是**地址值** 
  3. ```java
  4. // 数组在默认情况下是引用传递，赋的是地址值，赋值方式为引用赋值
  5. // arr2的变化会影响到arr1的值
  6. int[] arr1 = { 1, 2, 3 };
  7. int[] arr2 = arr1;
  9. arr2[0] = 10; // 更改arr2的元素
  11. // arr1 的元素
  12. for (int i = 0; i < arr1.length; i++) {
  13.     System.out.print(arr1[i] + " ");// { 10, 2, 3 }
  14. }
  15. System.out.println();
  17. // arr2 的元素
  18. for (int i = 0; i < arr2.length; i++) {
  19.     System.out.print(arr2[i] + " "); // { 10, 2, 3 }
  20. }
  1. 值传递/值拷贝和引用传递/地址拷贝的区别
    第五章 数组、排序和查找 - 图1

    3. 数组拷贝

  • 将int[] arr1 = {10, 20, 30}拷贝到arr2数组
  • 要求数据空间独立 ```java // 将int[] arr1 = {10, 20, 30} 拷贝到arr2数组 // 要求数据空间独立

int[] arr1 = { 10, 20, 30 };

// 创建arr2数组，开辟新的数据空间，大小为arr1.length int[] arr2 = new int[arr1.length];

// 遍历把arr1的元素依次拷贝到arr2 for (int i = 0; i < arr1.length; i++) { arr2[i] = arr1[i]; }

// 改变arr2的元素，不会改变arr1的元素 arr2[0] = 80;

// 遍历arr1 for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + “ “);// { 10, 20, 30 } } System.out.println();

// 遍历arr2 for (int i = 0; i < arr2.length; i++) { System.out.print(arr2[i] + “ “); // { 80, 20, 30 } }

  2. <a name="c74d5ebf"></a>
  3. #### 4. 数组反转
  5. -  要求把数组的元素内容反转 
  6. ```java
  7. // 把数组的元素内容反转
  8. // { 11, 22, 33, 44, 55, 66 } >> {66, 55, 44, 33, 22, 11 }
  10. /*
  11.  * 方法1：通过找规律反转
  12.  * 思路分析：
  13.  * 1. 把 arr[0] 和 arr[5] 进行交换 { 66, 22, 33, 44, 55, 11 }
  14.  * 2. 把 arr[1] 和 arr[4] 进行交换 { 66, 55, 33, 44, 22, 11 }
  15.  * 3. 把 arr[2] 和 arr[3] 进行交换 { 66, 55, 44, 33, 22, 11 }
  16.  * 4. 一共要交换 3 次 = arr.length / 2
  17.  * 5. 每次交换时，对应的下标是 arr[i] 和 arr[arr.length - 1 - i]
  18.  */
  19. int[] arr = { 11, 22, 33, 44, 55, 66 };
  20. int len = arr.length; // 定义变量len等于数组的的长度
  21. for (int i = 0, temp; i < len / 2; i++) {
  22.     temp = arr[i];
  23.     arr[i] = arr[len - 1 - i];
  24.     arr[len - 1 - i] = temp;
  25. }
  27. // 遍历arr
  28. System.out.println("====== arr ======");
  29. for (int i = 0; i < arr.length; i++) {
  30.     System.out.print(arr[i] + " "); // {66, 55, 44, 33, 22, 11 }
  31. }
  32. System.out.println();
  34. /*
  35.  * 方法2：使用逆序赋值方式
  36.  * 思路分析：
  37.  * 1. 创建一个新数组
  38.  * 2. for循环依次遍历
  39.  * 3. 倒序将每个元素拷贝到第二个数组
  40.  */
  41. int[] arr1 = { 11, 22, 33, 44, 55, 66 };
  42. int[] arr2 = new int[arr1.length];
  43. int len1 = arr1.length; // 定义变量len1等于数组的的长度
  45. for (int i = 0; i < len1; i++) {
  46.     arr2[i] = arr1[len1 - 1 - i];
  47. }
  49. // 让arr1指向arr2的数据空间
  50. // 此时arr1原来的数据空间没有变量引用，会被当做垃圾销毁
  51. arr1 = arr2;
  53. // 遍历arr1
  54. System.out.println("====== arr1 ======");
  55. for (int i = 0; i < arr1.length; i++) {
  56.     System.out.print(arr1[i] + " ");
  57. }

5. 数组添加

  • 实现动态给数组添加元素效果，实现对数组扩容

    1. 原始数组使用静态分配 int[] arr = { 1, 2, 3 }
    2. 增加的元素，直接放在数组的最后 arr = { 1, 2, 3 , 4}

    3. 用户可以通过如下方法来决定是否继续添加 添加成功，是否继续？y/n

      1. public static void main(String[] args) {
      2. /*
      3. * 要求：实现动态给数组添加元素效果，实现对数组扩容
      4. * 1. 原始数组使用静态分配 int[] arr = { 1, 2, 3 }
      5. * 2. 增加的元素，直接放在数组的最后 arr = { 1, 2, 3, 4 }
      6. * 3. 用户可以通过如下方法来决定是否继续添加 添加成功，是否继续？y/n
      7. * 
      8. * 思路分析：
      9. * 1. 定义初始数组 int[] arr = { 1, 2, 3 }
      10. * 2. 定义一个新数组 int[] arrNew = new int[arr.length + 1]
      11. * 3. 遍历 arr 数组，一次将arr的元素拷贝到 arrNew 数组
      12. * 4. 将需要添加的元素赋给arrNew最后一个元素
      13. * 5. 让arr指向arrNew，那么原来的arr数组就会被销毁
      14. * 6. 创建Scanner对象接收用户输入
      15. * 7. 创建变量holdOn判断是否继续，默认为y
      16. * 8. while循环接收判断用户是否继续
      17. */
      18. Scanner scanner = new Scanner(System.in);
      19. int addNum;
      20. char holdOn = 0;
      21. int[] arr = { 1, 2, 3 };
      22. int[] arrNew;
      24. do {
      25.   // 定义一个新数组
      26.   arrNew = new int[arr.length + 1];
      28.   // 将arr的元素拷贝到 arrNew 数组
      29.   for (int i = 0; i < arr.length; i++) {
      30.       arrNew[i] = arr[i];
      31.   }
      33.   System.out.print("请输入要添加的元素：");
      34.   addNum = scanner.nextInt();
      36.   // 把addNum赋给arrNew最后一个元素
      37.   arrNew[arrNew.length - 1] = addNum;
      38.   arr = arrNew; // 让arr指向arrNew
      40.   System.out.println("添加后的数组为：");
      41.   for (int i = 0; i < arr.length; i++) {
      42.       System.out.print(arr[i] + " ");
      43.   }
      44.   System.out.println();
      46.   // 接收用户输入是否继续添加
      47.   System.out.print("添加成功，是否继续？y/n：");
      48.   holdOn = scanner.next().charAt(0);
      49.   // if (holdOn == 'n') {
      50.   //     break;
      51.   // }
      52. } while (holdOn != 'n');
      54. // 打印扩容后的数组
      55. System.out.println("程序退出，扩容后的数组为：");
      56. for (int i = 0; i < arr.length; i++) {
      57.   System.out.print(arr[i] + " ");
      58. }
      59. }

  • 实现数组缩减

    • 有一个数组 { 1, 2, 3, 4, 5 }，将该数组进行缩减
    • 提示用户是否继续缩减，每次缩减最后那个元素。

    • 当只剩下最后一个元素时，提示：不能再缩减 

      1. public static void main(String[] args) {
      2. /*
      3. * 实现数组的缩减
      4. * 1. 有一个数组{ 1, 2, 3, 4, 5 }
      5. * 2. 可以将该数组进行缩减
      6. * 3. 提示用户是否继续缩减，每次缩减最后那个元素。
      7. * 4. 当只剩下最后一个元素时，提示：不能再缩减
      8. * 
      9. * 思路分析：
      10. * 1. 创建数组 int[] arr = { 1, 2, 3, 4, 5 };
      11. * 2. 创建新数组 int[] arrNew = new int[arr.length - 1];
      12. * 3. 将arr从第0个到倒数第二个遍历赋给arrNew
      13. * 4. arr = arrNew
      14. * 5. 创建Scanner对象，接收用户输入
      15. * 6. do-while 判断用户是否继续
      16. * 7. 判断 arr.length 是否等于1
      17. */
      18. Scanner scanner = new Scanner(System.in);
      19. char holdOn = '0';
      20. int[] arr = { 1, 2, 3, 4, 5 };
      21. int[] arrNew;
      23. do {
      24.   arrNew = new int[arr.length - 1]; // 初始化arrNew
      26.   // 将arr从第0个到倒数第二个遍历赋给arrNew
      27.   for (int i = 0; i < arr.length - 1; i++) {
      28.       arrNew[i] = arr[i];
      29.   }
      31.   arr = arrNew; // 让arr指向arrNew
      33.   System.out.println("缩减后的数组为：");
      34.   for (int i = 0; i < arr.length; i++) {
      35.       System.out.print(arr[i] + " ");
      36.   }
      38.   if (arr.length == 1) {
      39.       System.out.println("提示：不能再缩减");
      40.       break;
      41.   }
      43.   // 判断用户输入
      44.   System.out.print("是否继续缩减？y/n：");
      45.   holdOn = scanner.next().charAt(0);
      47. } while (holdOn != 'n');
      49. System.out.println("程序退出...");
      50. }

二、排序

  • 排序的介绍
    • 排序是将一群数据，以指定的顺序进行排列的过程

  • 排序的分类

    1. 内部排序法
      • 指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法);
    2. 外部排序法
      • 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)

        1. 冒泡排序法

  • 冒泡排序 (Bubble Sorting) 的基本思想是：通过对待排序序列从后向前 (从下表较大的元素开始)，依次比较相邻元素的值，若发现逆序则交换，时值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒

  • 冒泡排序动图演示
    第五章 数组、排序和查找 - 图2

  • 冒泡排序法案例

    • 五个无序数字：24, 69, 80, 57, 13
    • 使用冒泡排序法将其排成一个从小到大的有序数列
    1. 冒泡排序分析
      第五章 数组、排序和查找 - 图3
    2. 总结特点
      1. 一共有5个元素
      2. 一共进行4轮排序，可以看成外层循环
      3. 每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数，第2轮排序，确定第2大的数位置
      4. 当进行比较时，如果前面的数大于后面的数，就交换
      5. 每轮比较在减少 4->3->2->1 ```java /*
    • 五个无序数字：24, 69, 80, 57, 13
    • 使用冒泡排序法将其排成一个从小到大的有序数列
    • 思路分析：
      1. 先完成第一轮排序
      1. 将多轮排序使用外层循环包括起来即可
      1. 优化：设置一个boolean swap，如果发生交换就true，没发生就为false */ public static void main(String[] args) { int[] arr = { 10, 13, 24, 80, 57, 23 }; int temp = 0; // 用于交换的临时变量 boolean swap = false;

      // 一共进行 arr.length-1 轮排序 for (int i = 0; i < arr.length - 1; i++) { // 每1轮排序可以确定一个数的位置 for (int j = 0; j < arr.length - 1 - i; j++) {

      1.    // 进行比较，如果前面的数大于后面的数，就交换
      2.    // 如果没有发生交换，说明默认从小到大排序，程序退出
      3.    if (arr[j] > arr[j + 1]) {
      4.        temp = arr[j];
      5.        arr[j] = arr[j + 1];
      6.        arr[j + 1] = temp;
      7.        swap = true; // 成功交换
      8.    } else {
      9.        swap = false; // 没有发生交换
      10.    }

      } // 如果没有发生交换，退出程序 if (swap == false) {

      1.    break;

      } System.out.println(“第” + (i + 1) + “轮排序：”); for (int k = 0; k < arr.length; k++) {

      1.    System.out.print(arr[k] + " ");

      } System.out.println(); } }

      1. ```java
      2. public class BubbleSort {
      3. public static void main(String[] args) {
      5.    BubbleSort bubble = new BubbleSort();
      6.    int[] arr = bubble.randomArr();
      8.    // 排序前
      9.    for (int i : arr) {
      10.        System.out.print(i + " ");
      11.    }
      12.    System.out.println("\n============");
      14.    bubble.sort(arr);
      16.    // 排序后
      17.    for (int i : arr) {
      18.        System.out.print(i + " ");
      19.    }
      20. }
      22. // 随机生成数组，内容为10个100以下的整数
      23. public int[] randomArr() {
      24.    Random random = new Random();
      25.    int[] arr = new int[10];
      26.    for (int i = 0; i < arr.length; i++) {
      27.        arr[i] = random.nextInt(100);
      28.    }
      29.    return arr;
      30. }
      32. // 冒泡排序方法
      33. public int[] sort(int[] arr) {
      34.    int temp = 0;
      35.    for (int i = 1; i < arr.length; i++) {
      36.        for (int j = 0; j < arr.length - i; j++) {
      37.            if (arr[j] > arr[j + 1]) {
      38.                temp = arr[j];
      39.                arr[j] = arr[j + 1];
      40.                arr[j + 1] = temp;
      41.            }
      42.        }
      43.    }
      44.    return arr;
      45. }
      46. }

三、查找

  • 介绍

    • 在java中，常用的查找有两种
      1. 顺序查找
      2. 二分查找

      1. 顺序查找

  • 案例演示

    1. 有一个数列，白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王
    2. 从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】

    3. 如果找到了，就提示找到，并给出下标值，没有找到则提示没有找到

      1. public static void main(String[] args) {
      2. /*
      3. * 思路分析：
      4. * 1. 创建数列
      5. * 2. 创建Scanner
      6. * 4. for循环遍历，if判断是否相同
      7. * 5. 字符串比较用 .equals() 方法
      8. * 6. 判断成功，打印下标值，退出
      9. */
      10. String[] strs = { "白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王" };
      11. Scanner scanner = new Scanner(System.in);
      12. System.out.print("请输入要查找的名字：");
      13. String findName = scanner.next(); // 接收用户输入
      15. System.out.println("正在查找...");
      16. // for循环遍历，if判断是否相同
      17. // 字符串比较用 .equals() 方法
      18. int index = -1; // 定义一个index，判断有没有找到
      19. for (int i = 0; i < strs.length; i++) {
      20.   if (findName.equals(strs[i])) {
      21.       System.out.println("找到了，下标值为：" + i);
      22.       index = i;
      23.       break;
      24.   }
      25. }
      26. if (index == -1) {
      27.   System.out.println("没有找到！");
      28. }
      29. }

2. 二分查找

  1. 二分查找法是一种在有序数组中查找某一特定元素的搜索算法。
  2. 搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束。
  3. 如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
  4. 如果在某一步骤数组为空，则代表找不到。
  5. 这种搜索算法每一次比较都使搜索范围缩小一半。

四、二维数组

1. 二维数组入门

  • 二维数组本质上是以数组作为数组元素的数组，即“数组的数组”
  • 基本语法
    • int[][] a = { { 0, 0, 0 }, { 1, 2, 3 } };
  • 案例演示 ```java /*
    • 请用二维数组输出如下图形
    • 000000
    • 001000
    • 020300
    • 000000 */ int[][] arr = { { 0, 0, 0, 0, 0, 0 },
      1.    { 0, 0, 1, 0, 0, 0 },
      2.    { 0, 2, 0, 3, 0, 0 },
      3.    { 0, 0, 0, 0, 0, 0 } };

// 输出二维数组 for (int i = 0; i < arr.length; i++) { // 遍历二维数组的每个数组元素 // 遍历二维数组的每个元素(数组) // arr[i].length 得到对应的每个一维数组的长度 for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j]); // 输出一个一维数组 } System.out.println(); // 换行 }

  3. -  二维数组内存布局<br />![](img/mk-2022-04-18-14-41.png#crop=0&crop=0&crop=1&crop=1&id=zcKyQ&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
  4. <a name="0935424e"></a>
  5. #### 2. 二维数组的使用
  7. 1.  动态初始化 1 
  8.    1.  语法：`类型[][] 数组名 = new 类型[大小][大小]` 
  9.    1.  比如：`int arr[][] = new int[2][3]` 
  10.    1.  使用演示 
  11. ```java
  12. int arr[][] = new int[2][3];
  13. arr[1][1] = 8;
  15. for (int i = 0; i < arr.length; i++) {
  16.     for (int j = 0; j < arr[i].length; j++) {
  17.         System.out.print(arr[i][j] + " ");
  18.     } // 000 080
  19.     System.out.println();
  20. }
  1. 动态初始化 2
    1. 先声明：类型 数组名[][]
    2. 再定义(开辟空间)：数组名 = new 类型[大小][大小]
    3. 赋值(有默认值，比如int类型默认值0)
    4. 使用演示 
      1. int arr[][];
      2. arr = new int[2][3];
      3. arr[1][1] = 8;
      4. 此时arr为：{ { 0, 0, 0 }, { 0, 8, 0 } }

  1. 动态初始化 3：列数不确定

    1. 需求：动态创建下面二维数组，并输出
      • { { 1 }, { 2, 2 }, { 3, 3, 3 } }
    2. 完成案例 ```java /*
    • { { 1 }, { 2, 2 }, { 3, 3, 3 } }

    • 一共有三个一维数组，每个一维数组的元素是不一样的 */ public static void main(String[] args) { // 创建二维数组，一共有3个一维数组， // 但是每个一维数组还没有开辟空间 int[][] arr = new int[3][]; // 遍历arr每个一维数组 for (int i = 0; i < arr.length; i++) { // 给每个一维数组开辟空间 new // 如果没有给一维数组new，那么arr[i]就是null空值 arr[i] = new int[i + 1];

      // 遍历一维数组，并给一维数组的每个元素赋值 for (int j = 0; j < arr[i].length; j++) {

      1.   arr[i][j] = i + 1;

      } } // 遍历arr数组 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) {

      1.   System.out.print(arr[i][j] + " ");

      } System.out.println(); } } ```

  1. 静态初始化
    1. 定义：类型 数组名[][] = { { 值1, 值2.. }, { 值1, 值2.. }.. }
    2. 比如：int[][] arr = { { 1, 2, 3 }, { 4 } };
    3. 这样也是正确的：String[] strs = new String[] { "a", "b", "c" };
    4. 定义了一个二维数组arr
    5. arr有2个元素(每个元素都是一维数组)
    6. 第一个一维数组有3个元素，第二个一维数组有1个元素

5. 二维数组的遍历

  • 遍历下面的二维数组，并得到和
  • int arr[][] = { {4, 6}, {1, 4, 5, 7}, {-2} }; 
    1. /*
    2. * 遍历下面的二维数组，并得到和
    3. * int arr[][] = { {4, 6}, {1, 4, 5, 7}, {-2} }
    4. */
    5. int arr[][] = { { 4, 6 }, { 1, 4, 5, 7 }, { -2 } };
    6. int sum = 0;
    7. for (int i = 0; i < arr.length; i++) {
    8.  for (int j = 0; j < arr[i].length; j++) {
    9.      System.out.print(arr[i][j] + " ");
    10.      sum += arr[i][j];
    11.  }
    12.  System.out.println();
    13. }
    14. System.out.println("sum = " + sum);

6. 应用案例

  • 使用二维数组打印一个10行的杨辉三角 

    1. public static void main(String[] args) {
    2.  /*
    3.   * 使用二维数组打印一个10行的杨辉三角
    4.   * 1
    5.   * 1 1
    6.   * 1 2 1
    7.   * 1 3 3 1
    8.   * 1 4 6 4 1
    9.   * 1 5 10 10 5 1
    10.   * ......
    11.   * 提示：
    12.   * 1. 第一行有1个元素，第n行有n个元素
    13.   * 2. 每一行的第一个元素和最后一个元素都是1
    14.   * 3. 从但三行开始，对于非第一个元素和最后一个元素的元素的值。
    15.   * 4. arr[i][j] 规律：
    16.   * arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
    17.   * 
    18.   */
    19.  int[][] arr = new int[10][];
    21.  for (int i = 0; i < arr.length; i++) {
    22.      // 给每个一维数组开辟空间
    23.      arr[i] = new int[i + 1];
    25.      for (int j = 0; j < arr[i].length; j++) {
    26.          // 如果是第一个元素或最后一个元素，就是1
    27.          if (j == 0 || j == arr[i].length - 1) {
    28.              arr[i][j] = 1;
    29.          } else {
    30.              // 杨辉三角规律
    31.              arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
    32.          }
    33.      }
    34.  }
    35.  // 输出杨辉三角
    36.  for (int i = 0; i < arr.length; i++) {
    37.      for (int j = 0; j < arr[i].length; j++) {
    38.          System.out.print(arr[i][j] + " ");
    39.      }
    40.      System.out.println();
    41.  }
    42. }

7. 注意事项

  1. 一维数组的声明方式有：
    int[] x 或 int x[]
  2. 二维数组的声明方式有：
    int[][] y 或 int[] y[] 或 int y[][]
  3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同
    比如 int map [][] = { { 1, 2 }, { 3, 4, 5 } };
    map[0]是一个含有两个元素的一位数组，map[1]是一个含有三个元素的一维数组构成，也称为列数不等的二维数组

  4. int[] x, y[]; 中x是一维数组，y是二维数组

    五、二维数组课后练习

  5. 已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序
    比如：[10, 12, 45, 90]，添加23后，数组为：[10, 12, 23, 45, 90] 

    1. public static void main(String[] args) {
    2. /*
    3.  * 已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序
    4.  * 比如：[10, 12, 45, 90]
    5.  * 添加23后数组为：[10, 12, 23, 45, 90]
    6.  * 
    7.  * 思路分析：(扩容 + 定位)
    8.  * 1. 先确定添加数应该插入到哪个索引
    9.  * 2. 然后扩容
    10.  * 3. 遍历arr数组，如果发现 addNum <= arr[i]，说明i就是要插入的位置
    11.  * 4. 使用index保留 index = i;
    12.  * 5. 如果遍历完后，没有发现 addNum <= arr[i]，说明index = arr.length
    13.  */
    15. // 定义原数组
    16. int[] arr = { 10, 12, 45, 90 };
    17. int index = -1;
    18. int[] arrNew = new int[arr.length + 1]; // 定义一个临时数组
    20. Scanner scanner = new Scanner(System.in);
    21. System.out.println("请输入要添加的数组：");
    22. int addNum = scanner.nextInt();
    24. // 遍历arr数组，如果发现 addNum <= arr[i]，说明i就是要插入的位置
    25. // 如果没有发现，则添加到arr的最后
    26. for (int i = 0; i < arr.length; i++) {
    27.     if (addNum <= arr[i]) {
    28.         index = i; // 找到位置后，就退出
    29.         break;
    30.     }
    31. }
    33. // 判断index的值
    34. if (index == -1) { // 说明没找到位置
    35.     index = arr.length;
    36. }
    38. // 添加arr的元素到arrNew并跳过index
    39. // i 用来控制arrNew的下标，j 用来控制arr数组的下标
    40. for (int i = 0, j = 0; i < arrNew.length; i++) {
    41.     if (i != index) { // 说明可以把arr的元素拷贝到arrNew
    42.         arrNew[i] = arr[j];
    43.         j++;
    44.     } else {
    45.         arrNew[i] = addNum;
    46.     }
    47. }
    48. arr = arrNew; // 让arr指向arrNew
    50. for (int i = 0; i < arrNew.length; i++) {
    51.     System.out.print(arrNew[i] + " ");
    52. }
    53. }

  1. 随机生成10个整数(1-100)保存到数组，并倒序打印以及求平均值、最大值和最大值的下标，并查找里面是否有8 

    1. public static void main(String[] args) {
    2. /*
    3.  * 随机生成10个整数(1-100)保存到数组，
    4.  * 并倒序打印以及求平均值、最大值和最大值的下标
    5.  * 并查找里面是否有8
    6.  */
    7. int[] arr = new int[10];
    8. double sum = 0; // 定义变量sum存储数组的和
    9. int findNum = 8; // 要查找的数字为 8
    10. int index = -1; // 如果找到，就把下标记录到index
    12. for (int i = 0; i < arr.length; i++) {
    13.     arr[i] = (int) (Math.random() * 100) + 1;
    15.     sum += arr[i]; // 叠加
    16.     if (arr[i] == findNum) { // 查找是否有8
    17.         index = i;
    18.     }
    19. }
    21. System.out.println("=====arr的元素情况=====");
    22. for (int i = 0; i < arr.length; i++) {
    23.     System.out.print(arr[i] + " ");
    24. }
    26. System.out.println("\n=====arr的元素情况(倒序)=====");
    27. for (int i = arr.length - 1; i >= 0; i--) {
    28.     System.out.print(arr[i] + " ");
    29. }
    31. // 分别比较计算出最大值
    32. int maxIndex = 0;
    33. for (int i = 1; i < arr.length; i++) {
    34.     if (arr[maxIndex] < arr[i]) {
    35.         maxIndex = i;
    36.     }
    37. }
    38. System.out.printf("\n平均值：%.1f\n最大值：%d\n最大值下标：%d\n",
    39.         (sum / arr.length), arr[maxIndex], maxIndex);
    41. if (index == -1) {
    42.     System.out.println("数组内没有 " + findNum);
    43. } else {
    44.     System.out.println("数组内有 " + findNum + "下标为：" + index);
    45. }
    46. }

  1. 冒泡排序 

    1. public static void main(String[] args) {
    2. /*
    3.  * 冒泡排序
    4.  * 要求从小到大排序
    5.  */
    6. int[] arr = { 20, -1, 89, 2, 890, 7 };
    8. int temp = 0;
    9. for (int i = 0; i < arr.length - 1; i++) { // 外层循环(轮)
    10.     for (int j = 0; j < arr.length - 1 - i; j++) { // 每轮的比较次数
    11.         if (arr[j] > arr[j + 1]) { // 如果前面的数大，就交换
    12.             temp = arr[j];
    13.             arr[j] = arr[j + 1];
    14.             arr[j + 1] = temp;
    15.         }
    16.     }
    17. }
    18. for (int i = 0; i < arr.length; i++) {
    19.     System.out.print(arr[i] + " ");
    20. }
    21. }