数据结构-数组
## Java 数组
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
数组
-
数组是相同类型数据的有序集合。
-
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
-
每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们
特点：
- 长度不可变
- 元素类型一致
- 可以声明任意类型的数组
- 数组变量属于引用类型，数组也可看成对象，元素视为成员变量
- 对象存放在JVM的堆中->数组是对象->数组对象本身放在堆中！
无论数组是基本类型还是引用类型，都存在堆中！
声明数组变量
dataType[] arrayRefVar; // java开发手册推荐
dataType arrayRefVar[]; // 兼容C/C++语法
创建数组
Java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。
数组边界
下标合法区间：[0,length -1]
java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常！
数组的内存
三种初始化状态
静态初始化
创建 + 赋值
int[] a = {1,2,3,4,5,6,7,8,9};
动态初始化
包含默认初始化
int[] b = new int[10];
b[0] = 1;
// 后面未赋值的元素初始化成int的默认值0
数组的默认初始化
数组是引用类型，相当于类的实例变量，因此一经分配空间，
其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组的使用
- 普通的For循环
- For-Each 循环
- 数组作方法入参
- 数组作返回值
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5, 6};
// For-Each 循环
for (int array : arrays) {
System.out.print(array+" ");
}
System.out.println("\n------------");
// 普通的For循环
int[] array2 = reverse(arrays);
for (int i = 0; i < array2.length; i++) {
System.out.print(array2[i]+" ");
}
}
// 数组作方法入参
public static int[] reverse(int a[]){
int length = a.length;
int[] result = new int[length];
for (int i = 0; i < length; i++) {
result[i] = a[length-i-1];
}
return result; // 数组作返回值
}
}
多维数组
多维数组可以看成数组内嵌套数组。（套娃）
比如二维数组就是一个特殊的一维数组，它的每一个元素都是一个一维数组。
int a[][] = new int[2][3] // 声明创建一个两行三列的二维数组
稀疏数组
import java.util.Arrays;
/**
* 稀疏数组->用小数组储存大数组
* 比如棋盘
*/
public class SparseArray {
public static void main(String[] args) {
// 1.首先创建一个二维数组10*10 -> 0:空 1：黑 2：白
int[][] chessboard = new int[10][10];
chessboard[1][2] = 1;
chessboard[2][3] = 2;
System.out.println("原始棋盘：");
for (int[] ints : chessboard) {
System.out.println(Arrays.toString(ints));
}
int[][] result = toSparse(chessboard);
System.out.println("稀疏数组：");
for (int[] ints : result) {
System.out.println(Arrays.toString(ints));
}
int[][] chessboard2 = toChess(result);
System.out.println("恢复棋盘：");
for (int[] ints : chessboard2) {
System.out.println(Arrays.toString(ints));
}
}
public static int[][] toSparse(int[][] ints) {
// 首先统计有效个数
int count = 0;
for (int[] anInt : ints) {
for (int i : anInt) {
if (i != 0) {
count++;
}
}
}
// 创建稀疏数组
int[][] result = new int[count + 1][3];
result[0][0] = ints.length;
result[0][1] = ints[0].length;
result[0][2] = count;
int k = 1;
// 遍历棋盘 储存坐标和值
for (int i = 0; i < ints.length; i++) {
for (int j = 0; j < ints[i].length; j++) {
if (ints[i][j] != 0) {
result[k][0] = i;
result[k][1] = j;
result[k][2] = ints[i][j];
k++;
}
}
}
return result;
}
public static int[][] toChess(int[][] ints) {
// 棋盘大小
int len = ints[0][0];
int heigh = ints[0][1];
int[][] result = new int[len][heigh];
for (int i = 1;i<ints.length;i++) {
int x = ints[i][0];
int y = ints[i][1];
int value = ints[i][2];
result[x][y] = value;
}
return result;
}
}
小结
数组是相同数据类型的有序集合
数组也是对象，数组元素相当于对象的成员变量
数组的长度确定固定，不可变。越界报错ArrayIndexOutOfBounds
