04 - 数组

一、数组的介绍

数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

二、数组的使用

使用方式 1 - 动态初始化

语法：
数据类型 数组名[] = new 数据类型[大小]
int a[] = new int[5]; //创建了一个数组，名称为a，存放5个int类型数据

补充：
数组的引用（使用/访问/获取数组元素）
	数组名[下标/索引/index]
	比如：使用数组 a 的第三个数
	a[2] //数组的下标从0开始

使用方式 2 - 动态初始化

1）先声明数组 
	语法: 数据类型 数组名[];
	也可以 数据类型[] 数组名;
	int a[];
	或者 int[] a;

2）创建数组
	语法: 数组名 = new 数据类型[大小];
	a = new int[10];

定义时初始化数组

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

数组的使用细节

1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理。
2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3) 数组创建后，如果没有赋值，有默认值。
	int 0，short 0，byte 0，long 0
	float 0.0，double 0.0，char \u0000
	boolean false，String null
4) 使用数组的步骤：
	1. 声明数组并开辟空间
	2. 给数组各个元素赋值
	3. 使用数组
5) 数组的下标是从 0 开始的。
6) 数组下标必须在指定范围内使用，否则报错：下标越界异常，比如
	int [] arr = new int[5];
	则有效下标为 0-4 
7) 数组属于引用类型，数组型数据是对象(object)

数组赋值机制

1) 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
	int n1 = 2;
	int n2 = n1;
2) 数组在默认情况下是引用传递，赋的值是地址。

数组拷贝

package basicKnowledge.Array_;

public class ArrayCopy {

    //将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间相同
    public static void main(String[] args) {
        int[] arr1 = {10, 20, 30};
        int[] arr2 = new int[arr1.length];

        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        for (int j = 0; j < arr2.length; j++){
            System.out.println(arr2[j]);
        }
        System.out.println(arr1);
        System.out.println(arr2);
    }
}

数组反转

package basicKnowledge.Array_;

public class ArrayReverse {

    //要求：把数组的元素内容反转。 ArrayReverse.java
    //arr1 = {11,22,33,44,55,66} ------>  {66, 55,44,33,22,11}

    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33, 44, 55, 66,77};
        for (int i = 0; i <= (arr1.length / 2) - 1; i++) {
            int temp = arr1[i];
            arr1[i] = arr1[arr1.length - i - 1];
            arr1[arr1.length - i - 1] = temp;
        }
        for (int j = 0; j <= arr1.length - 1; j++) {
            System.out.print(arr1[j] + " ");
        }
    }
}

数组扩容/添加

package basicKnowledge.Array_;

public class ArrayAdd {

    //要求：实现动态的给数组添加元素效果，实现对数组扩容。
    //1) 原始数组使用静态分配 int[] arr = {1,2,3}
    //2) 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}

    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int addNum = 4;
//      Scanner scanner = new Scanner(System.in);
        int[] arrNew = new int[arr.length + 1];

            for (int j = 0; j < arr.length; j++) {
                arrNew[j] = arr[j];
            }
        arrNew[arr.length] = addNum;

        arr = arrNew;
        for (int j = 0; j < arr.length; j++) {
            System.out.print(arr[j] + " ");
        }
    }
}

三、二维数组

使用方式 1: 动态初始化

1) 语法:
	类型[][] 数组名 = new 类型[大小][大小];
2) 比如:
	int a[][] = new int[2][3];
	//声明一个名称为 a 的 两行三列的二维数组

使用方式 2: 动态初始化

1）先声明:
	类型 数组名[][];
	or 类型[][] 数组名;
2）再定义(开辟空间)
	数组名 = new 类型[大小][大小];
3）赋值(有默认值，比如 int 类型的就是 0)
	比如:
	int a[][]；
	a = new int[2][3];
	a[0][1] = 0;

使用方式 3: 动态初始化 - 列数不确定

实例：动态创建一个二维数组
 i/j 		j = 0	j = 1	j = 2
i = 0		 1
i = 1		 2	 2
i = 2		 3	 3	 3

创建一个 二维数组，一共有 3 个一维数组，但是每个一维数组还没有开辟数据空间：
	int[][] arr = new int[3][ ];

public static void main(String[] args) {
	int[][] arr = new int[3][];
	for(int i = 0; i < arr.length; i++) {
		//给每个一维数组开空间 new
		//如果没有开辟空间 arr[i]为 null
		arr[i] = new int[i + 1];
		
		//遍历一维数组，给一维数组的元素赋值
		for(int j = 0; j < arr[i].length; j++) {
			arr[i][j] = i + 1
		}
	}
}

使用方式 4: 静态初始化

定义:
	类型 数组名[][] = {{值 1,值 2..}, {值 1,值 2..}, {值 1,值 2..}};
使用即可 [ 固定方式访问 ]
比如:
	int[][] arr = {{1,1,1}, {8,8,9}, {100}};

注：本博客引用韩顺平老师Java课程