学习 Java 你必须要知道的东西（五）【数组】

十、数组

1. 数组的定义

数组是相同类型的数据的"有序"集合
数组中数据的顺序按照"先后次序排列"组合，先来的在前、后来的在后
数组中的每一个数据称之为数组元素，每个数组元素都可以通过一个"下标"访问(从0开始)
    
数组的声明和创建：
    数据类型[] 数组名 = {x1,x2,x3...};//首选创建方式
	或
    数据类型 数组名[] = {x1,x2,x3...};//C语言风格，仅是为了早期让C语言开发人员尽快掌握Java才存在
	或
    数据类型[] 数组名 = new 数据类型[x];//使用new的方式创建数组，x为数组初始化大小

2. 数组初始化

静态初始化：
	//声明 + 创建 + 赋值
	int[] array = {1,2,3}
动态初始化：
    //声明 + 创建 （包含默认初始化）
    int[] brray = new int[8];
默认初始化：
    当数组被"创建"或"指定大小"时，即进行默认初始化，初始化值为数组类型的默认值
    int 默认为0，引用数据类型默认为 null

3. 小结

·数组是相同类型的数据的"有序"集合
·数组变量本身属于"引用数据类型"
·数组长度是固定的，一旦创建其"大小不可变" (数组扩容=创建新数组)
·数组中元素不允许出现混合类型
·数组中元素可以是任意类型，即可为基本数据类型和引用数据类型

4. 多维数组

简言之，数组中的数据 也是数组 的数组，称之为"多维数组"
可以理解为 "数组的嵌套结构"

5. 冒泡排序

在乱序数组中，从"首位"开始，与下一位进行比较，将较大值前置或后置（也可以说"调换位置"，取决于排序规则：升序较大值后置，降序较大值前置）
如此反复若干次（数组长度-1）即可成功排序

public static int[] bubbleSort(int[] arr) {
        //临时容器变量（空杯子）
        int temp = 0;
        //外层循环 决定了外部需要大循环几次（次数为 数组长度-1）
        //  例：[1,2,3,4,5]
        // 第一次：12,23,34,45
        // 第二次：12,23,34
        // 第三次：12,23
        // 第四次：12
        for (int i = 0; i < arr.length - 1; i++) {
            //内部循环 进行比较（将较大值向后移）
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

6.稀疏数组

当一个数组中"大部分"元素为0或同一值时，就可以用稀疏数组来保存该数组
稀疏数组的处理方式：
	记录原数组内外部的个数（列和行），以及多少个不同值
	把具有不同值的行、列、值 记录在小规模数组中，从而缩小数组规模

	// 数组 转换 => 稀疏数组
        // 1.获取有效值的个数 以此为依据决定稀疏数组的长度 (稀疏数组长度=有效值个数+1)
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    count++;
                }
            }
        }
        // 2.创建一个稀疏数组   count+1 (稀疏数组 主体 +头部)
        int[][] brr = new int[count + 1][3];
        // 定义 number用于记录稀疏数组的索引，当稀疏数组多一条数据时，number++
        int number = 0;
        // 设置稀疏数组头部
        brr[0][0] = 8;
        brr[0][1] = 8;
        brr[0][2] = count;
        // 遍历二维数组 对稀疏数组添加数据
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    number++;
                    brr[number][0] = i;
                    brr[number][1] = j;
                    brr[number][2] = arr[i][j];
                }
            }
        }
        // 打印稀疏数组
        System.out.println("《行,列,值》");
        for (int[] b : brr) {
            System.out.println(Arrays.toString(b));
        }

还原稀疏数组

	// 还原稀疏数组
        // 1.新建二维数组 读取稀疏数组头部 => 得到二维数组长度信息
        int[][] crr = new int[brr[0][0]][brr[0][1]];
        // 2.遍历稀疏数组 将有值 赋值到二维数组中
        for (int i = 1; i < brr.length; i++) {
            crr[brr[i][0]][brr[i][1]] = brr[i][2];
        }
        System.out.println("还原稀疏数组：");
        for (int[] c : crr) {
            System.out.println(Arrays.toString(c));
        }