相同类型数据的有序集合，长度是固定的

定义方式

数据类型[] 变量名; 首选是这个

数据类型 变量名[]; c跟c++的风格

int[] nums=new int[10];

获取数组长度：变量名.length

会有类型默认值：0，null

内存分析

堆：存放new的对象和数组（创建数组 array=new int[10]），数组对象保存在这

栈：存放具体值与基本数据类型（声明数组 int[] array=null）

初始化方式

//静态初始化：创建+赋值
int[] a={1,2,3,4};
//动态初始化：包含默认初始化
int[] b=new int[10];//这时里面所有值为0
b[0]=1;

Arrays类

数组的工具类：java.util.Arrays

Arrays.toString(数组变量)：数组转换成字符串，一般用于输出时

Arrays.sort(数组变量)：对数组进行排序

Arrays.fill(变量,0)：数组填充，后面是数组要填充的值

Arrays.fill(变量,2,4,0)：数组的2-3位（包前不包后）被0填充

冒泡排序

时间复杂度为O(n^2)

1. 比较数组中两个相邻的元素，如果第一个数比第二个大，交换位置

2. 每次比较，都会产生一个最大或最小的数字

3. 下一轮则可以少一次排序

4. 依次循环，直到结束

public static int[] sort(int[] array){
    //临时变量
    int temp=0;
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1; j++) {
            if (array[j + 1] > array[j]) {
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
    return array;
}

稀疏数组

一种数据结构

大部分数组元素为0，或同一值，就可以使用稀疏数组来保存该数组

第一行是原始数组有几行几列在了几个值，后面的每行就是数值的位置

创建稀疏数组

//模仿棋盘的二维数组,0未下，1黑棋，2白棋
int[][] array=new int[11][11];
array[1][2]=1;
array[2][3]=2;

//转为稀疏数组保存
//看有多少个有效的值
int sum=0;
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        if(array[i][j]!=0){
            sum++;
        }
    }
}
//创建稀疏数组
int[][] array2=new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;

//遍历二维数组，将非零的值，存放在稀疏数组中
int count=0;
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        if(array[i][j]!=0){
            count++;
            array2[count][0]=i;
            array2[count][1]=j;
            array2[count][2]=array[i][j];
        }
    }
}

读取稀疏数组

//读取稀疏数组
int[][] array3=new int[array2[0][0]][array2[0][1]];
//给其中元素还原它的值
for (int i = 1; i < array2.length; i++) {
    array3[array2[i][0]][array2[i][1]]=array2[i][2];
}