JAVA 数组的操作

数组赋值

     语法结构：

数组名称[元素的索引] = 元素值;

     语法示例：  

double[] douArr = {3.5d, 4};
douArr[0] = 7;

 

数组遍历

• 遍历：每个元素都要访问一遍。

• 方式：循环数组的索引，通过索引访问数组的值。

• 示例：

public static void main(String[] args) {
    double[] douArr = {3.5d, 4, 7, 4.6f};
    for (int i = 0; i < douArr.length; i++) {
        System.out.println(douArr[i]);
    }
}

增强for循环：

public static void main(String[] args) {
    double[] douArr = {3.5d, 4, 7, 4.6f};
    for (double dob : douArr) {
        System.out.println(dob);
    }
}

二维数组

概述

• 二维数组：数组的嵌套，数组里的每一个元素都是一个数组。

• 语法结构：

  元素的数据类型[][] 数组名称 = new 元素的数据类型[外层数组容器的大小][每个外层数组内包含的数组容器大小];

  语法示例： 

  int[][] arr = new int[3][5];

• 示例解释：

  • 创建一个int类型的二维数组，数组有3个元素。

  • 3个元素中，每个元素内都是另一个int类型一维数组，每个数组内有5个元素。

• 语法变型：

  • 变型1：

    • 语法示例：

      char[][] arr = new char[3][];

    • • 示例解释：

        • 创建char类型的二维数组，数组有3个元素。

        • 3个元素中，每个元素内都是另一个char类型一维数组，每个数组内元素个数不确定。

    • 变型2：

      • double[][] arr = {{}, {2, 4.5d}, {3, 6, 4.6f}, null};

        示例解释：

      • 创建一个double类型的二维数组，直接给数组进行赋值。

      • 二维数组的每个元素内的一维数组的元素个数均不相同。

        二维数组遍历

      • 方式：嵌套循环，先循环外层数组，再循环每个外层数组内的一维数组。

      • 示例：

        public static void main(String[] args) {
            // 声明一个int类型的二维数组,并赋值
            int[][] arr = {{2, 4}, {3, 6, 4}, {0, 2, 4, 10}};
            // 先循环外层的数组,变量i为数组的下角标
            for (int i = 0; i < arr.length; i++) {
                // 变量ins为外层数组的值,其本身就是一个int类型的一维数组
                int[] ins = arr[i];
                // 循环外层数组内的一维数组,变量j为一维数组的小角标
                for (int j = 0; j < ins.length; j++) {
                    // 变量in为外层数组内遍历的一维数组内的值
                    int in = ins[j];
                    // 打印该值,但不换行
                    System.out.print(in + "\t");
                }
                // 每循环一个外层数组后,进行换行的操作
                System.out.println();
            }
        }

        冒泡排序

      • 方式：循环遍历数组，临近的两个元素比较大小；升序（将较小的元素放置在左侧）；降序（将较大的元素放置在右侧）。

    • 升序代码示例： 

      public static void main(String[] args) {
          // 初始化一个数据顺序不规则的数组
          int[] ins = {10, 1, 37, 25, 8, 5, 46, 93, 2};
          // 依次循环数组元素,循环多少轮
          for (int i = 0; i < ins.length - 1; i++) {
              // 循环需要比较的数据,每轮比较的次数
              for (int j = 0; j < ins.length - 1 - i; j++) {
                  // 交换数据
                  if (ins[j] > ins[j + 1]) {
                      int temp = ins[j];
                      ins[j] = ins[j + 1];
                      ins[j + 1] = temp;
                  }
              }
          }
          for (int in : ins) {
            	System.out.println(in);
          }
      }

降序代码示例：

public static void main(String[] args) {
    // 初始化一个数据顺序不规则的数组
    int[] ins = {10, 1, 37, 25, 8, 5, 46, 93, 2};
    // 依次循环数组元素,循环多少轮
    for (int i = 0; i < ins.length; i++) {
        // 循环需要比较的数据,每轮比较的次数
        for (int j = 0; j < ins.length - 1 - i; j++) {
            // 交换数据
            if (ins[j] < ins[j + 1]) {
                int temp = ins[j];
                ins[j] = ins[j + 1];
                ins[j + 1] = temp;
            }
        }
    }
    for (int in : ins) {
      	System.out.println(in);
    }
}

 

总结：

• N个元素需要排序N-1轮

• 第i轮需要比较N-i次

• N个元素排序，需要比较(n-1)/2次

• 效率不高，实现最简单