Java基础笔记8（数组）

定义

• 数组是相同类型的数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 每一个数据称作一个数组元素，每个数组元素可以通过下标来访问

声明

• 必须声明数组变量，才能在程序中使用数组。

  dataType[] nums1; //推荐写法
  或
  dataType nums2[];

• Java语言中使用new来创建数组

  dataType[] nums = new dataType[arraySize];
  或
  dataType[] nums = new dataType[]{element1，element2，element3};
  (dataType[] nums = {element1，element2，element3};)

• 数组赋值

  nums[0] = 0;
  nums[1] = 23;
  nums[5] = 6;

数组特点

• 长度确定，数组一旦被创建，其大小就不可改变
• 元素可以使任意相同数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组也可以看成是对象，数组中每个元素相当于该对象的成员变量。
• 数组本身就是对象，Java对象保存在堆中，因此数组无论是保存原始类型还是其他数据类型，数组对象本身是在堆中的

Java内存

• 堆

  • 存放new的对象和数组
  • 可以被所有的线程共享，不会存放别的对象引用

• 栈

  • 存放基本数据类型（包含这个基本类型的具体数值）
  • 引用对象的变量（存放这个引用在堆里的具体地址）
• 方法区
  • 可以被所有线程共享
  • 包含所有的class和static变量

三种初始化状态

//静态初始化
int[] a = {1,2,3};
//动态初始化
int[] a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;
//默认初始化
//数组是引用类型，它的元素相当于类的示例变量
//因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化

数组边界

合法下标区间 [0,length-1] ,如果越界就会报错：ArrayIndexOutOfBoundsException（数组下标越界异常）

数组使用

for each循环

int[] arrays = {1,2,3,4,5};
//普通循环
for(int i = 0;i < arrays.length;i++){
    System.out.println(arrays[i]);
}
//for each循环
for(int array : arrays){
    System.out.println(array);
}

数组作为参数、返回值

//打印数组
public void print(int nums){
    for(int num : nums){
    	System.out.println(num);
	}
}

//生成反转数组
public int[] reverse(int[] nums) {
    int len = nums.length;
    int[] ans = new int[len];
    for (int i = 0,j = len - 1; i < len; i++,j--) {
        ans[j] = nums[i];
    }
    return ans;
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其中每一个元素都是一个一维数组

//二维数组 
int[][] a = new int[2][3];
int[][] b = {{1,2,3},{4,5,6}};
//a、b都可以看成一个两行三列的数组

稀疏数组（压缩）

//压缩以下数组
0 0 0 0 7
1 0 3 0 0
2 0 0 0 0

下标	行	列	值
[0]	3（原数组有几行）	5（原数组有几列）	4（除0以外其他数字总数）
[1]	0	4	7
[2]	1	0	1
[3]	1	2	3
[4]	2	0	2

public class Test {

    public static void main(String[] args) {
        //原始数组
        int row = 3;
        int col = 5;
        int array[][] = new int[row][col];
        array[0][4] = 7;
        array[1][0] = 1;
        array[1][2] = 3;
        array[2][0] = 2;

        System.out.println("打印原始数组");
        for (int[] ints : array) {
            for (int i : ints) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }

        //计算原始数组中非0的数的总数
        int sum = 0;
        for (int[] ints : array) {
            for (int i : ints) {
                if (i != 0) {
                    sum++;
                }
            }
        }

        //稀疏数组
        int[][] sparseArray = new int[sum + 1][3];

        sparseArray[0][0] = row;
        sparseArray[0][1] = col;
        sparseArray[0][2] = sum;

        int count = 1;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                    count++;
                }
            }
        }

        System.out.println("打印稀疏数组");
        for (int[] ints : sparseArray) {
            for (int i : ints) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }

        //还原稀疏数组
        int[][] array2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            array2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        System.out.println("打印还原数组");
        for (int[] ints : array2) {
            for (int i : ints) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }

    }

}
/*
输出：
打印原始数组
0	0	0	0	7	
1	0	3	0	0	
2	0	0	0	0	
打印稀疏数组
3	5	4	
0	4	7	
1	0	1	
1	2	3	
2	0	2	
打印还原数组
0	0	0	0	7	
1	0	3	0	0	
2	0	0	0	0	
*/