Array知识点总结（数组的创建、Array与Object的关系、数组的协变设计）

Array 知识点总结

Array数组是同一种类型数据的集合，是一种存储数据的方式，数组就是一个容器。

数组的基本操作

一维数组的创建

数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，而数组的定义语法如下。

声明

Type[] arrayName;

Type arrayName[];

两种声明方式有何区别，是否推荐使用某种？
---
两种声明方式实质上无区别，但推荐使用*第一种*。原因如下：
数组本身属于**引用数据类型**，即第一种声明方式中，表示`Type[]`是一种引用类型（即数组），而不是`Type`类型。
同时第一种声明方式具有更好的可读性，将类型`Type[]`与变量名`arrayName`区分开。

思考以下声明方式是否有误？

int[5] ints;

---

---

答：该种声明方式是错误的。

在Java语言中声明数组时不能指定其长度，因为数组是一种引用类型的变量。因此使用其定义一个变量时，仅仅定义了一个引用变量（可以理解为指针），这个引用变量还未指向任何有效的内存，所以定义其时不能指定长度。

同时因为其并未指向任何有效的空间，因此还没有内存空间用来存储元素，因此该数组不能被使用，只有在数据进行初始化后才可被使用。

初始化

数组的初始化分为静态初始化和动态初始化。

静态初始化

初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组的长度。

type[] arrayName;
arrayName = new type[]{
   element1, element2, element3, ...};

上述可简写为：type[] arrayName = {
   ele1, ele2, ele3, ele4, ...};

int[] intArray = new int[]{
   1,2,3,4,5};
int[] intArray = {
   1,2,3,4,5};

思考以下声明初始化方式是否有误？

int[] ints; ints = {1,2,3,4,5}

---

---

答：原声明方式的含义为，在声明时直接分配内存空间并赋值，不可将其拆分。

动态初始化

初始化时由程序员指定数组的长度，由系统初始化每个数组元素的默认值。

type[] arrayName;
arrayName = new type[length];

int[] intArray = new int[5];

思考以下数组的声明方式是否有误？

int[] intArray = new int[5]{1,2,3,4};

int[] intArray = new int[5]{1,2,3,4,5};

int[] intArray = new int[5]{1,2,3,4,5,6};

---

---

答：有误。

不能同时使用静态初始化和动态初始化。即不能在进行数组初始化时，既指定数组长度，又为每个数组元素分配初始值。
一旦数组初始化完成，数组在内存中所占的空间将被固定下来，数组的长度将不可变。

数组的循环遍历

for(int i : ints){
   
    System.out.println(i);
}

public static void main(String[] args) {
   
    int[] aInts = {
   1, 2, 3, 4, 5};
    System.out.print("aInts :: ");
    print(aInts);	// aInts :: 1	2	3	4	5

    int[] bInts = new int[5];
    System.out.print("bInts :: ");
    print(bInts);	// bInts :: 0	0	0	0	0	
}

public static void print(int[] ints ){
   
    for (int i : ints) {
   
        System.out.print(i + "\t");
    }
    System.out.println();
}

思考以下二维数组的打印结果是哪种？

int[][] aInts = { {1,2,3}, {4,5}, {6}};

1 2 3		 	1 2 3
4 5			 	4 5 0
6			 	6 0 0

int[][] bInts = new int[3][3];

(什么都没有)		 0 0 0 
				0 0 0
				0 0 0

其他操作

扩容

数组的扩容实际上也是数组的拷贝。

public static void reSize() {
   
    String[] aStrs = new String[]{
   "aaa", "bbb", "ccc"};
    String[] bStrs = new String[5];
    bStrs[3] = "aaa";
    bStrs[4] = "bbb";
    System.arraycopy(aStrs, 0, bStrs, 0, aStrs.length);
    for (String str : bStrs) {
   
        System.out.println(str);
    }
}

排序

Arrays类的静态sort()方法可以实现对数组的排序。

public static void sortArray() {
   
    int[] ints = {
   1, 3, 2, 5, 7, 9};
    System.out.println("原来的数组" + Arrays.toString(ints));
    //对数组排序
    Arrays.sort(ints);
    System.out.println("排序后的数组" + Arrays.toString(ints));
}

填充

Arrays类的静态方法fill()来对数组中的元素进行替换

public static void fillArray() {
   
    int[] ints = new int[]{
   1, 2, 3, 4};
    Arrays