参考价值：未完善，无错误、不建议参考，等待重置

什么是数组？

数组的基本属性：

  1. 类型：

    • 数组的类型：引用数据类型
    • 元素的类型：既可以是基本数据类型也可以是引用数据类型

  2. 数组名

  3. 索引（下标）

  4. 元素

  5. 长度：指数组在初始化时开辟的空间的个数。

数组的分类：

  • 按照维数：一维数组、二维数组（也可以有三维数组，但不常用）
  • 按照元素数据类型：整型数组、char型数组、String型数组等

一维数组：

  1. 数组的声明：

    1. 静态声明：

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

      静态声明是在声明的同时初始化了数组。

    2. 动态声明：

      1
      2
      int[] num;
      int num[];

  2. 数组的初始化：

    1. 静态声明的初始化：

      在声明的同时已经完成了初始化。

    2. 动态声明的初始化：

      1
      num = new int[3];

    3. 动态声明的同时初始化：

      1
      2
      int[] num = new int[3];
      int num[] = new int[3];

    4. 数组的初始化默认值：

      1. 整型：0
      2. 浮点型：0.0
      3. char型：0或者’\0’
      4. 布尔型：false
      5. String型：null

      检验代码：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      public static void main(String[] args) {
      		int[] num1 = new int[2];
      		System.out.println("*********");
      		for(int i = 0; i <= num1.length - 1; i ++) {
      			System.out.println("----" + num1[i] + "----");
      		}
      		short[] num2 = new short[2];
      		System.out.println("*********");
      		for(int i = 0; i <= num2.length - 1; i ++) {
      			System.out.println("----" + num2[i] + "----");
      		}
      		byte[] num3 = new byte[2];
      		System.out.println("*********");
      		for(int i = 0; i <= num3.length - 1; i ++) {
      			System.out.println("----" + num3[i] + "----");
      		}
      		long[] num4 = new long[2];
      		System.out.println("*********");
      		for(int i = 0; i <= num4.length - 1; i ++) {
      			System.out.println("----" + num4[i] + "----");
      		}
      		System.out.println("整型数组的初始化默认值是0吗？（yes/no）");
      		if(num1[0] == 0 && num2[0] == 0 && num3[0] == 0 && num4[0] == 0) 
      			System.out.println("yes");
      		else
      			System.out.println("no");
      		
      		double[] dou = new double[2];
      		System.out.println("*********");
      		for(int i = 0; i <= dou.length - 1; i ++) {
      			System.out.println("----" + dou[i] + "----");
      		}
      		float[] flo = new float[2];
      		System.out.println("*********");
      		for(int i = 0; i <= flo.length - 1; i ++) {
      			System.out.println("----" + flo[i] + "----");
      		}
      		System.out.println("浮点型数组的初始化默认值是0.0吗？（yes/no）");
      		if(flo[0] == 0 && dou[0] == 0) 
      			System.out.println("yes");
      		else
      			System.out.println("no");
      		boolean[] bool = new boolean[2];
      		System.out.println("*********");
      		for(int i = 0; i <= bool.length - 1; i ++) {
      			System.out.println("----" + bool[i] + "----");
      		}
      		System.out.println("布尔型数组的初始化默认值是false吗？（yes/no）");
      		if(bool[0] == false) 
      			System.out.println("yes");
      		else
      			System.out.println("no");
      		char[] chr = new char[2];
      		System.out.println("*********");
      		for(int i = 0; i <= chr.length - 1; i ++) {
      			System.out.println("----" + chr[i] + "----");
      		}
      		System.out.println("char型数组的初始化默认值是0或着是'\0'吗？（yes/no）");
      		if(chr[0] == 0 && chr[0] == '\0') 
      			System.out.println("yes");
      		else
      			System.out.println("no");
      		
      		String[] str = new String[2];
      		System.out.println("*********");
      		for(int i = 0; i <= str.length - 1; i ++) {
      			System.out.println("----" + str[i] + "----");
      		}
      		System.out.println("String型数组的初始化默认值是null吗？（yes/no）");
      		if(str[0] == null) 
      			System.out.println("yes");
      		else
      			System.out.println("no");
      	}

      运行结果：

  3. 数组的调用：

    通过索引(下标)调用。

    1
    2
    3
    num[0] = 1;//调用第一个元素并赋值
    num[1] = 2;//调用第二个元素并赋值
    num[2] = 2;//调用第三个元素并赋值

  4. 数组的长度：

    通过调用方法获取。

    1
    System.out.println("数组num的长度是：" + num.length);

  5. 数组的遍历：

    1
    2
    3
    for(int i = 0; i <= num.length - 1; i ++) {
    	System.out.printf("数组的第%d个元素是：%d\n",i + 1,num[i]);
    }

    通过循环语句进行遍历。

一维数组在内存中的解析：

首先我们要说一下内存的构成。

内存的构成：

内存并不是一个整块可以随意地存储数据。它分为栈、堆和其他结构（本次解析不涉及，暂且不提）。

就像这样：

其中，栈用来存储局部变量，也就是数组。堆用来储存new出来的变量，也就是数组元素。

当我们声明并初始化一个数组时，内存如此变化：

1
int[] num = new int[3];

其中，栈内的数组和堆内的元素通过数组元素的首地址关联。

那么，如果我们这样做，会发生什么？

1
int[] num = new int[2];

栈内的数组num会与堆内新数组元素关联，而没有与栈内关联的数组元素过一段时间后会被垃圾处理机制处理掉。

二维数组

先不搞，最近时间紧，暂时用不着

数组的相关算法：

按下不表，有时间再搞。