1 什么是数组
数组是相同类型数据的有序集合。
其中每一个数据成为数组元素，每个数组元素通过数组下标访问。
2 数组的声明和创建
2.1数组定义格式
（1）数据类型[] 数组名(常用）
int[] arr;
（2）数据类型 数组名[] （C/C++中继承来的定义格式）
int arr[];
2.2数组初始化
1.动态初始化：只给定数组的长度，由系统给出默认的初始值0.
int[] arr = new arr[10];//new来创建的都存储在堆内存（使用完毕后会在垃圾回收器空闲时回收）
2.静态初始化：在创建数组时，直接将元素确定.
int[] arr = new int[]{1,2,3,4,5,…};
//简化版格式为
int[] arr = {1,2,3,4,5,…};
2.3数组元素访问
数组名[索引];//索引从0开始
arr[0];
3 数组操作的两个常见问题
- 索引越界异常
int[] arr = new int[3];
System.out.println(arr[3]);
程序运行后会抛出ArrayIndexOutOfBoundsException异常！
数组索引的合法区间为：[0,arr.length - 1]
- 空指针异常
int[] arr = {
1,2,3];
arr = null;//arr将不会再保存数组的内存地址，即不允许再操作数组了
System.out.println(arr[0]);
程序运行后会抛出NullPointerException异常！
4 二维数组
定义:
int[][] arr;
例子，遍历二维数组：
public static void main(String[] args) {
//二维数组
int[][] arr = {
{
1,2},{
3,4},{
5,6},{
7,8}};
/*
1 2
3 4
5 6
7 8
*/
arrayPrint(arr);
}
//遍历二维数组
public static void arrayPrint(int[][] arr){
for(int i = 0;i < arr.length; i ++){
for(int j = 0; j < arr[i].length; j ++){
System.out.print(arr[i][j] +" ");
}
System.out.println();
}
}
5 Arrays类
常用方法
int[] arr = {
1,55,78,2,90,33,46,109,88};
//打印数组元素
System.out.println(Arrays.toString(arr));//[1, 55, 78, 2, 90, 33, 46, 109, 88]
//对数组元素排序
Arrays.sort(arr);//[1, 2, 33, 46, 55, 78, 88, 90, 109]
System.out.println(Arrays.toString(arr));
//数组填充
//Arrays.fill(arr,0);//[0, 0, 0, 0, 0, 0, 0, 0, 0]
Arrays.fill(arr,2,4,0);//[1, 2, 0, 0, 55, 78, 88, 90, 109]
//二分法排序
Arrays.binarySearch(arr,46);//[1, 2, 33, 46, 55, 78, 88, 90, 109]
6 冒泡排序
public class bubbleSort {
public static void main(String[] args) {
//冒泡排序
int[] arr = {
12,34,56,78,22,31,45,68,41};
sort(arr);
}
public static void sort(int[] arr){
int temp;
for(int i = 0;i < arr.length - 1;i ++){
boolean flag = false;//flag标志位，减少不必要的比较
for(int j = 0;j < (arr.length -1- i); j ++){
if(arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = true;
}
}
if(flag = false){
break;
}
}
System.out.println(Arrays.toString(arr));
}
}
时间复杂度为O(n²）
7 稀疏数组
6.1简介
当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，稀疏数组的处理方法是：
- 记录数组一共有几行几列，有多少个不同的值
- 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
举例
稀疏数组大小为(n+1)*3(n为数组中有效元素的个数，+1为第一行的记录数，3为行、列、值三列)
- 第一行第一列记录原始数组总行数，第一行第二列记录原始数组总列数，第一行第三列原始数组中的总有效元素个数
- 第二行记录第一个有效元素的行、列、值
- 第三行记录第二个有效元素的行、列、值
- ……
代码：
public class xishuArrayDemo {
public static void main(String[] args) {
//1.创建一个二维数组11*11，0没有棋子，1黑棋，2白棋
int[][] arr = new int[11][11];
arr[1][2] = 1;
arr[2][3] = 2;
//输出原始数组
System.out.println("原始二维数组为：");
for(int i = 0;i < arr.length; i ++){
for(int j = 0; j < arr[i].length; j ++){
System.out.print(arr[i][j] +" ");
}
System.out.println();
}
System.out.println("============");
//2.转换为稀疏数组
//获取有效值个数
int sum = 0;
for(int i = 0;i < arr.length; i ++) {
for (int j = 0; j < arr[i].length; j++) {
if (arr[i][j] != 0) {
sum++;
}
}
}
System.out.println("有效值个数为：" + sum);
//创建稀疏数组
int[][] arr2 = new int[sum + 1][3];
//定义稀疏数组第一行
arr2[0][0] = 11;
arr2[0][1] = 11;
arr2[0][2] = sum;
//遍历二维数组，将有效值存入稀疏矩阵
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 ++;
arr2[count][0] = i;
arr2[count][1] = j;
arr2[count][2] = arr[i][j];
}
}
}
//输出稀疏数组
System.out.println("原始矩阵对应的稀疏矩阵为：");
for(int x = 0; x < arr2.length; x ++){
System.out.println(arr2[x][0] + "\t" + arr2[x][1] + "\t" +arr2[x][2] + "\t" );
}
System.out.println("============");
//3.还原稀疏数组
int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
for(int y = 1; y < arr2.length; y ++){
arr3[arr2[y][0]][arr2[y][1]] = arr2[y][2];
}
//输出
System.out.println("稀疏矩阵还原为二维数组：");
for(int i = 0;i < arr3.length; i ++){
for(int j = 0; j < arr3[i].length; j ++){
System.out.print(arr3[i][j] +" ");
}
System.out.println();
}
}
}