Java 数组

前言

  • 数组是一个固定长度的,包含了相同类型数据的 容器。一旦分配好空间,是多长,就多长,不能增加也不能减少。

  • Java 数组 快速入门

1、创建数组

  • 创建数组的时候,要指明数组的长度。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    int[] a;                        // 声明一个数组
    int a[]; // 声明有时候也会写成这种样式,没有任何区别

    a = new int[5]; // 创建一个长度是 5 的数组,并且使用引用 a 指向该数组

    int[] a = new int[5]; // 声明的同时,指向一个数组
    int a[] = new int[5];
    int[] a = new int[]{1, 2, 3};
    int[] a = {100, 102, 444, 836, 3236};
  • 数组下标基 0,下标 0,代表数组里的第一个数。

    1
    2
    3
    4
    5
    6
    7
    int[] a = new int[5];

    a[0] = 1; // 下标 0,代表数组里的第一个数
    a[1] = 2;
    a[2] = 3;
    a[3] = 4;
    a[4] = 5;
  • 属性

属性 说明
length 获取数组的长度
  • .length 属性用于访问一个数组的长度,数组访问下标范围是 0 到长度 - 1,一旦超过这个范围,就会产生数组下标越界异常。

    1
    2
    3
    4
    5
    6
    int[] a = new int[5];

    System.out.println(a.length); // 打印数组的长度

    a[4] = 100; // 下标 4,实质上是 “第 5 个”,即最后一个
    a[5] = 101; // 下标 5,实质上是 “第 6 个”,超出范围,产生数组下标越界异常
  • 不同类型获取长度的方法

    • 数组获取长度的手段是 .length 属性。
    • String 获取长度的手段是 length() 方法。
    • 集合获取长度的手段是 size() 方法。
    • 文件获取长度的手段是 length() 方法。

2、初始化数组

  • 初始化数组时如果指定了数组的内容,就不能同时设置数组的长度。

  • 分配空间与赋值分步进行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    int[] a = new int[5];           // 分配了长度是 5 的数组,但是没有赋值

    System.out.println(a[0]); // 没有赋值,那么就会使用默认值,作为 int 类型的数组,默认值是 0

    a[0] = 100; // 进行赋值
    a[1] = 101;
    a[2] = 103;
    a[3] = 120;
    a[4] = 140;
  • 分配空间,同时赋值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    // 写法一:分配空间同时赋值
    int[] a = new int[]{100, 102, 444, 836, 3236};

    // 写法二:省略了 new int[],效果一样
    int[] b = {100, 102, 444, 836, 3236};

    // 写法三:同时分配空间,和指定内容,在这个例子里,长度是 3,内容是 5 个,产生矛盾了
    // 所以如果指定了数组的内容,就不能同时设置数组的长度
    int[] c = new int[3]{100, 102, 444, 836, 3236};

3、排序

  • Arrays 工具类提供了一个 sort 方法,只需要一行代码即可完成数组排序功能。

  • 选择法排序

    • 把第一位和其他所有的进行比较,只要比第一位小的,就换到第一个位置来,比较完后,第一位就是最小的。
    • 然后再从第二位和剩余的其他所有进行比较,只要比第二位小,就换到第二个位置来,比较完后,第二位就是第二小的。
    • 以此类推。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      int a[] = new int[]{18, 62, 68, 82, 65, 9};

      // 选择法排序
      for (int j = 0; j < a.length - 1; j++) {
      for (int i = j+1; i < a.length; i++) {
      if(a[i] < a[j]){
      int temp = a[j];
      a[j] = a[i];
      a[i] = temp;
      }
      }
      }
  • 冒泡法排序

    • 从第一位开始,把相邻两位进行比较,如果发现前面的比后面的大,就把大的数据交换在后面,循环比较完毕后,最后一位就是最大的。
    • 再来一次,只不过不用比较最后一位。
    • 以此类推。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      int a[] = new int[]{18, 62, 68, 82, 65, 9};

      // 冒泡法排序
      for (int j = 0; j < a.length; j++) {
      for (int i = 0; i < a.length - j - 1; i++) {
      if(a[i] > a[i+1]){
      int temp = a[i];
      a[i] = a[i+1];
      a[i+1] = temp;
      }
      }
      }

4、遍历

  • 增强型 for 循环在遍历一个数组的时候会更加快捷,只能用来取值,却不能用来修改数组里的值。

  • 常规遍历

    1
    2
    3
    4
    5
    6
    7
    int values[] = new int[]{18, 62, 68, 82, 65, 9};

    // 常规遍历
    for (int i = 0; i < values.length; i++) {
    int val = values[i];
    System.out.println(val);
    }
  • 增强型 for 循环遍历

    1
    2
    3
    4
    5
    6
    int values[] = new int[]{18, 62, 68, 82, 65, 9};

    // 增强型 for 循环遍历
    for (int val : values) {
    System.out.println(val);
    }

5、复制数组

  • 把一个数组的值,复制到另一个数组中。

  • System 提供了一个 arraycopy 方法进行复制。

    1
    2
    3
    4
    5
    6
    7
    System.arraycopy(src, srcPos, dest, destPos, length)

    src: 源数组
    srcPos: 从源数组复制数据的起始位置
    dest: 目标数组
    destPos: 复制到目标数组的启始位置
    length: 复制的长度
  • Arrays 提供了一个 copyOfRange 方法进行数组复制

    • System.arraycopy 复制需要事先准备好目标数组,并分配长度。
    • copyOfRange 只需要源数组就就可以了,通过返回值,就能够得到目标数组了。
  • 常规循环复制

    1
    2
    3
    4
    5
    6
    7
    int a[] = new int[]{18, 62, 68, 82, 65, 9};     // 通过数组复制,把 a 数组的前 3 位赋值到 b 数组
    int b[] = new int[3]; // 分配了长度是 3 的空间,但是没有赋值

    // for 循环复制
    for (int i = 0; i < b.length; i++) {
    b[i] = a[i];
    }
  • System.arraycopy 方法复制

    1
    2
    3
    4
    5
    int a[] = new int[]{18, 62, 68, 82, 65, 9};
    int b[] = new int[3];

    // System.arraycopy 方法复制
    System.arraycopy(a, 0, b, 0, 3);

6、二维数组

  • 二维数组里面的每一个元素,都是一个一维数组。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    // 初始化二维数组
    int[][] a = new int[2][3]; // 有两个一维数组,每个一维数组的长度是 3
    a[1][2] = 5; // 可以直接访问一维数组,因为已经分配了空间

    // 只分配了二维数组
    int[][] b = new int[2][]; // 有两个一维数组,每个一维数组的长度暂未分配
    b[0] = new int[3]; // 必须事先分配长度,才可以访问
    b[0][2] = 5;

    // 指定内容的同时,分配空间
    int[][] c = new int[][] {
    {1, 2, 4},
    {4, 5},
    {6, 7, 8, 9}
    };

7、Arrays 工具类

  • Arrays 是针对数组的工具类,可以进行 排序,查找,复制填充等功能。
关键字 简介
copyOfRange 数组复制
toString 转换为字符串
sort 排序
binarySearch 搜索
equals 判断是否相同
fill 填充

7.1 复制

  • copyOfRange 复制不需要事先准备好目标数组,并分配长度,只需要源数组就就可以了,通过返回值,就能够得到目标数组了。

    1
    2
    3
    4
    5
    copyOfRange(int[] original, int from, int to)

    original: 源数组
    from: 开始位置(取得到)
    to: 结束位置(取不到)
    1
    2
    3
    4
    int a[] = new int[]{18, 62, 68, 82, 65, 9};

    // 复制
    int[] b = Arrays.copyOfRange(a, 0, 3);

7.2 转换为字符串

  • 如果要打印一个数组的内容,就需要通过 for 循环来挨个遍历,逐一打印。

  • 但是 Arrays 提供了一个 toString() 方法,直接把一个数组,转换为字符串,这样方便观察数组的内容。

    1
    2
    3
    4
    int a[] = new int[]{18, 62, 68, 82, 65, 9};

    // 转换为字符串
    String content = Arrays.toString(a);

7.3 排序

  • Arrays 工具类提供了一个 sort 方法,只需要一行代码即可完成排序功能。

    1
    2
    3
    4
    int a[] = new int[]{18, 62, 68, 82, 65, 9};

    // 排序,升序
    Arrays.sort(a);

7.4 搜索

  • 查询元素出现的位置。

  • 需要注意的是,使用 binarySearch 进行查找之前,必须使用 sort 进行排序。

  • 如果数组中有多个相同的元素,查找结果是不确定的。

    1
    2
    3
    4
    5
    6
    7
    int a[] = new int[]{18, 62, 68, 82, 65, 9};

    // 使用 binarySearch 之前,必须先使用 sort 进行排序
    Arrays.sort(a);

    // 搜索位置
    System.out.println("数字 62 出现的位置: " + Arrays.binarySearch(a, 62));

7.5 判断是否相同

  • 比较两个数组的内容是否一样。

    1
    2
    3
    4
    5
    int a[] = new int[]{18, 62, 68, 82, 65, 9};
    int b[] = new int[]{18, 62, 68, 82, 65, 8};

    // 判断是否相同
    System.out.println(Arrays.equals(a, b));

7.6 填充

  • 使用同一个值,填充整个数组

    1
    2
    3
    4
    int a[] = new int[10];

    // 填充数组
    Arrays.fill(a, 5);

8、ArrayList 工具类

  • ArrayList 是数组的工具类,最常见的容器类。

  • 容器的容量会随着对象的增加,自动增长,不用担心会出现数组的边界问题。

    1
    List heros = new ArrayList();
文章目录
  1. 1. 前言
  2. 2. 1、创建数组
  3. 3. 2、初始化数组
  4. 4. 3、排序
  5. 5. 4、遍历
  6. 6. 5、复制数组
  7. 7. 6、二维数组
  8. 8. 7、Arrays 工具类
    1. 8.1. 7.1 复制
    2. 8.2. 7.2 转换为字符串
    3. 8.3. 7.3 排序
    4. 8.4. 7.4 搜索
    5. 8.5. 7.5 判断是否相同
    6. 8.6. 7.6 填充
  9. 9. 8、ArrayList 工具类
隐藏目录