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
    int a[] = new int[]{18, 62, 68, 82, 65, 9};

    // 排序,升序
    Arrays.sort(a);
  • 选择法排序

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

      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、遍历

  • 常规遍历

    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);
    }
  • 增强型 for 循环遍历在一个数组的时候会更加快捷,只能用来取值,却不能用来修改数组里的值。

5、复制

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

    • System.arraycopy 复制需要事先准备好目标数组,并分配长度。
    • copyOfRange 只需要源数组就就可以了,通过返回值,就能够得到目标数组了。
  • System 提供了一个 arraycopy 方法进行复制。

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

    src: 源数组
    srcPos: 从源数组复制数据的起始位置
    dest: 目标数组
    destPos: 复制到目标数组的启始位置
    length: 复制的长度
    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);
  • Arrays 提供了一个 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);
  • 常规循环复制

    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];
    }

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 是针对数组的工具类,可以进行 排序、查找、复制、填充等功能。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package java.util;

    /**
    * This class contains various methods for manipulating arrays (such as
    * sorting and searching). This class also contains a static factory
    * that allows arrays to be viewed as lists.
    *
    * This class is a member of the Java Collections Framework.
    *
    * @author Josh Bloch, Neal Gafter, John Rose
    * @since 1.2
    */

    public class Arrays {

    }
  • 常用方法

关键字 简介
fill 填充
equals 判断是否相同
binarySearch 搜索
toString 转换为字符串
sort 排序
copyOfRange 数组复制

7.1 填充

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

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

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

7.2 判断是否相同

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

    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.3 搜索

  • 查询元素出现的位置。

  • 需要注意的是,使用 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.4 转换为字符串

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

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

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

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

7.5 排序

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

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

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

7.6 复制

  • 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);

8、ArrayList 工具类

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package java.util;

    /**
    * Resizable-array implementation of the <tt>List</tt> interface. Implements
    * all optional list operations, and permits all elements, including
    * <tt>null</tt>. In addition to implementing the <tt>List</tt> interface,
    * this class provides methods to manipulate the size of the array that is
    * used internally to store the list. (This class is roughly equivalent to
    * <tt>Vector</tt>, except that it is unsynchronized.)
    *
    * This class is a member of the Java Collections Framework.
    *
    * @author Josh Bloch, Neal Gafter
    * @see Collection, List, LinkedList, Vector
    * @since 1.2
    */

    public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

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

    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 工具类
隐藏目录