Java数组

数组的特点

• 数组可以存放多个数据
• 数组是一种引用数据类型
• 数组当中的数据类型必须统一
• 数组的长度在程序运行期间不可改变

数组的定义和初始化

声明数组语法：

数据类型[] 数组名;

获取数组长度：

数组名.length

数组的初始化：

• 静态初始化（指定内容）

  数组名 = new 元素的数据类型[]{元素的值列表}
  

  可以把数组的声明和初始化在同一行：

  数据类型[] 数组名 = new 元素的数据类型[]{元素的值列表}
  //简写形式
  数据类型[] 数组名 = {元素的值列表}
  

• 示例：

  public static void main(String[] args) {
      int[] scores;
      scores = new int[]{20, 40, 55, 70, 84, 96};
      for (int i = 0; i < scores.length; i++) {
          System.out.println(scores[i]);
      }
  
      //声明和初始化放在一起
      int[] scores2 = new int[]{10, 40, 60, 80};
      //简写形式
      int[] scores3 = {50, 60, 70, 80};
  }
  

• 动态初始化（指定长度）

  数据类型[] 数组名 = new 元素的数据类型[长度]
  数组名 = new 元素的数据类型[长度]
  

• 示例：

  public static void main(String[] args) {
      //声明数组
      char[] c;
      //动态初始化
      c = new char[10];
      for (int i = 0; i < c.length; i++) {
          System.out.println(c[i]);
      }
      int[] array1 = new int[30]
  }
  

访问数据的元素

数组名称[索引值]

• 索引从 0 开始，一直到 数组的长度-1 为止

示例：

public static void main(String[] args) {
    int[] a1 = {10, 20, 30};
    System.out.println(a1[0]); //10
    System.out.println(a1[1]); //20
    System.out.println(a1[2]); //30

    //动态初始化int类型的数组，如果没有赋值，默认0
    int[] a2 = new int[3];
    System.out.println(a2[0]); //0
    System.out.println(a2[1]); //0
    System.out.println(a2[2]); //0
}

注意：

• 如果访问的数据元素编号不存在，则会引发 ArrayIndexOutOfBoundsException 异常。

• 如果数组赋值为null，没有使用new创建则会引发 NullPointerException 异常

  int[] a1 = null;
  System.out.println(a1[0]);
  

案例：求出数组中的最大值

public static void main(String[] args) {
    int[] array = {7, 24, 15, 28, 10};
    int max = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }

    }
    System.out.println("最大值:" + max);
}

二维数组

二维数组的声明和初始化

public class ArrayTest {
    public static void main(String[] args) {
        //静态初始化，可用于不规则二维数组的初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        
        //动态初始化，方式1
        String[][] arr2 = new String[3][2];
        
        //动态初始化，方式2，声明一一个二维数组，用于存储3个一维数组，不指定每个一维数据存多少个数组
        String[][] arr3 = new String[3][];
    }
}

获取二维数组的长度和指定位置的元素

public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        System.out.println(arr1[0][1]);  //2
        System.out.println(arr1.length); //3
        System.out.println(arr1[1].length); //2
    }
}

遍历二维数组

public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

Arrays工具类

java.util.Arrays工具类包含了数组的各种操作。

常用方法：

方法	说明
boolean equals(int[] a, int[] b)	判断两个数组是否相等
String toString(int[] a)	将数组转换为字符串，并返回结果
void fill(int[] a,int val)	将指定值填充到数组中
void sort(int[] a)	对数组进行排序
int binarySearch(int[] a, int key)	对排序后的数组使用二分查找法查找指定元素的索引值

示例：

/**
 * java.util.Arrays：操作数组的工具类
 */
public class ArrayTest {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 4, 3, 5, 2};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals); //false

        System.out.println(Arrays.toString(arr1)); //[1, 2, 3, 4]

        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1)); //[10, 10, 10, 10]

        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4, 5]

        int[] arr3 = new int[]{-10, 2, 6, 18, 24, 45};
        int index = Arrays.binarySearch(arr3, 24); //4
        System.out.println(index);

    }
}