Java一维和二维数组_9

一维数组

Java 中的一维数组是一种线性数据结构，用于存储相同类型的多个元素。数组在内存中是连续分配的，可以通过索引访问每个元素

• 数组的声明和初始化

声明数组：

数据类型[] 数组名;  // 推荐写法
或
数据类型 数组名[];  // 不推荐

int[] numbers;  // 声明一个整型数组
String[] names; // 声明一个字符串数组

初始化数组：

1. 静态初始化

   在声明数组的同时赋值

   数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, ..., 元素n};
   或者
   数据类型[] 数组名 = {元素1, 元素2, ..., 元素n};
   
   int[] numbers = {1, 2, 3, 4, 5}; // 静态初始化
   String[] names = {"Alice", "Bob", "Charlie"};
   
   int[] numbers = new int[]{1, 2, 3, 4, 5}; // 静态初始化
   String[] names = new String[]{"Alice", "Bob", "Charlie"};
   
   //下面写法是错误的
   String[] names = new String{"Alice", "Bob", "Charlie"};
   String[] names = new String[3]{"Alice", "Bob", "Charlie"};
   

2. 动态初始化

   先声明数组，再分配内存空间并赋值

   数据类型[] 数组名 = new 数据类型[数组长度];
   
   int[] numbers = new int[5]; // 动态初始化，长度为 5
   numbers[0] = 1; // 为数组元素赋值
   numbers[1] = 2;
   

数组的默认值

数组在创建时（使用new关键字）会自动初始化其元素为默认值。默认值的类型取决于数组的元素类型

数组的元素类型	默认值
整型数组（int、short、long）	0
浮点型数组（float、double）	0.0
布尔型数组（boolean）	false
字符型数组（char）	'\u0000'（空字符）
对象数组（如 String）	null

数组的常见操作

• 数组的复制

  复制数组是将一个数组的内容复制到另一个数组中

  1. 使用 System.arraycopy()

     System.arraycopy(源数组, 源起始位置, 目标数组, 目标起始位置, 复制长度);
     
     int[] source = {1, 2, 3, 4, 5};
     int[] target = new int[5];
     System.arraycopy(source, 0, target, 0, source.length);
     System.out.println(Arrays.toString(target)); // 输出 [1, 2, 3, 4, 5]
     

  2. 使用 Arrays.copyOf()

     目标数组 = Arrays.copyOf(源数组, 新数组长度);
     
     int[] source = {1, 2, 3, 4, 5};
     int[] target = Arrays.copyOf(source, source.length);
     System.out.println(Arrays.toString(target)); // 输出 [1, 2, 3, 4, 5]
     

• 数组的排序

  使用 Arrays.sort()

  Arrays.sort(数组);
  
  int[] numbers = {5, 3, 1, 4, 2};
  Arrays.sort(numbers);
  System.out.println(Arrays.toString(numbers)); // 输出 [1, 2, 3, 4, 5]
  

  自定义排序规则，使用 Arrays.sort() 的重载方法，传入 Comparator

  Integer[] numbers = {5, 3, 1, 4, 2};
  Arrays.sort(numbers, (a, b) -> b - a); // 降序排序
  System.out.println(Arrays.toString(numbers)); // 输出 [5, 4, 3, 2, 1]
  

• 数组的查找

  使用 Arrays.binarySearch()，适用于已排序数组

  int index = Arrays.binarySearch(数组, 目标值);
  
  int[] numbers = {1, 2, 3, 4, 5};
  int index = Arrays.binarySearch(numbers, 3);
  System.out.println("找到目标，索引为 " + index); // 输出 2
  

• Arrays中其他常用方法

  Arrays.fill(数组, 值);将数组的所有元素设置为指定值
  
  boolean isEqual = Arrays.equals(数组1, 数组2);比较两个数组是否相等
  
  目标数组 = Arrays.copyOfRange(源数组, 起始索引, 结束索引);截取数组的一部分
  
  Arrays.toString(数组);数组转换为字符串
  
  List<Integer> list = Arrays.asList(numbers);数组转列表
  

二维数组

二维数组相当于一维数组里面的元素为数组，每个元素通过两个索引（行索引和列索引）来访问

• 声明二维数组

  数据类型[][] 数组名;  // 推荐写法
  或
  数据类型 数组名[][];  // 不推荐
  
  int[][] matrix;  // 声明一个整型二维数组
  String[][] names; // 声明一个字符串二维数组
  

• 初始化二维数组

  1. 静态初始化

     数据类型[][] 数组名 = {
         {元素11, 元素12, ..., 元素1n},
         {元素21, 元素22, ..., 元素2n},
         ...
         {元素m1, 元素m2, ..., 元素mn}
     };
     
     int[][] matrix = {
         {1, 2, 3},
         {4, 5, 6},
         {7, 8, 9}
     };
     

  2. 动态初始化

     先声明数组，再分配内存空间并赋值

     数据类型[][] 数组名 = new 数据类型[行数][列数];
     
     int[][] matrix = new int[3][3]; // 3 行 3 列的二维数组
     matrix[0][0] = 1; // 为数组元素赋值
     matrix[0][1] = 2;
     matrix[0][2] = 3;
     

• 不规则二维数组

  二维数组的每一行可以有不同的长度

  int[][] matrix = {
      {1, 2},
      {3, 4, 5},
      {6}
  };
  
  所以可以在动态初始化时不指定列数
  数据类型[][] 数组名 = new 数据类型[行数][];
  int[][] matrix = new int[3][];
  matrix[0]=new int[2];// 单独指定列数
  matrix[1]=new int[1];
  

数组中的一些知识点

数组为引用数据类型，其本身是个对象

索引：数组中元素的编号，从 0 开始

如果使用sort的重载方法，则需要使用包装类来定义数组类型

在Arrays工具类的一些方法中用到了泛型T，所以要使用包装类比如数组转列表（集合本身中也不能存储基本类型）的方法

访问超出数组范围的索引会抛出 ArrayIndexOutOfBoundsException

如果数组未初始化，访问时会抛出 NullPointerException

int[] x,y[];其中x为一维数组，y为二维数组