数组

数组是相同类型数据的有序集合

数组创建

dataType[] arrayName 或者 dataType arraName[];
效果相同但是前者为首选

例如：

int[] a = new int[10];//声明+创建分配空间
int b[] = new int[10];
a[0] = 1;
//获取数组长度
array.length

内存分析

java内存：

1. 堆：存放new的对象和数组，可以被所有线程共享，不会存放别的对象应用
2. 栈：存放基本变量类型，引用对象的变量
3. 方法区：可以被所有的线程共享，包含所有class和static变量

声明：栈，new：堆

三种初始化

静态初始化

int[] a = {1,2,3,4,5};
//初始化后大小不可改变

动态初始化

int[] a = new int[10];//声明+创建分配空间
int b[] = new int[10];
a[0] = 1

默认初始化

数组是引用类型，分配空间后会被隐式初始化

默认初始化0，null

四个基本点

• 数组的长度是确定的。一旦被创建大小不可改变
• 类型必须相同，不能出现混合类型
• 数组变量可以看做引用类型或对象，每个元素相当于对象的成员变量，java中的对象都在堆里，数组也是在堆里

数组使用

for-each循环：array.for

可以作为方法的参数和返回值

多维数组

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

Arrays类

//toString方法:
int[] a = {1,2,5,9,6};
System.out.println(Arrays.toString(a));
//out:[1, 2, 5, 9, 6]
//sort:
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//out:[1, 2, 5, 6, 9]
//fill:
 Arrays.fill(a,0);
 System.out.println(Arrays.toString(a));
 Arrays.fill(a,2,4,1);//左闭右开
 System.out.println(Arrays.toString(a));
//out:[0, 0, 0, 0, 0]
//[0, 0, 1, 1, 0]
//其他方法自己看文档

冒泡排序

事件复杂度为O(n2)

稀疏数组

当一个数组大部分都是0或者同一值，需要稀疏数组

稀疏数组：

• 记录数组一共有几行几列，有多少不同值
• 把具有不同值的元素和行列值记录在一个小规模数组中，缩小程序的规模

int[][] array1 = new int[11][11];
array1[2][1]=1;
array1[3][2]=2;

int[][] array2 = new int[3][3];//总+有效数
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = 2;//有效数
//遍历数组，将有效值存入稀疏数组
int count = 0;
for (int i = 0; i < array1.length; i++) {
    for (int j = 0; j < array1[i].length; j++) {
        if(array1[i][j]!=0){
            count++;
            array2[count][0] = i;
            array2[count][1] = j;
            array2[count][2] = array1[i][j];
        }
    }
}
//稀疏数组还原
int[][] array3 = new int[array2[0][0]][array2[0][0]];
for (int i = 1; i < array2.length; i++) {
    array3[array2[i][0]][array2[i][1]]=array2[i][2];
}