1、定义
-
相同数据类型的有序集合
-
其中，每一个数据称作为一个数组元素，每个数组元素可以通过一个下标来访问他们
2、数组的声明、创建、初始化
2.1、声明
-
语法：
-
数组类型[] 数组名;（首选）
-
数组类型 数组名[];
//示例
int[] intNums;
double doubleNums[]; -
2.2、创建
-
使用new操作符创建数组
-
语法：数组类型[] 数组名 = new 数组类型[数组长度];
//示例
int[] intNums = new int[8];
2.3、初始化
-
默认初始化
-
数组是引用类型，一经创建，也就是分配空间后，其中的每个元素会被隐式地初始化，有默认值
-
-
静态初始化
-
语法：数组类型[] 数组名 = {数组元素,数组元素,数组元素......};
//基本数据类型数组
int[] intNums = {1,2,3};
//Dog类
public class Dog {
String name;
public Dog(String name) {
this.name = name;
}
}
//引用类型数组
Dog[] dogs = {new Dog("豆包"),new Dog("旺财")};
-
-
动态初始化
-
语法：
-
数组类型[] 数组名 = new 数组类型[数组长度];
-
数组名[下标索引] = 值；
int[] intNums = new int[3];
intNums[0] = 1;
intNums[1] = 2;
intNums[2] = 3; -
-
2.4、从内存分析数组声明、创建、初始化的过程
-
简单认识Java内存
-
堆内存
-
存放new的对象和数组
-
可以被所有的线程共享
-
-
栈内存
-
存放基本变量类型（会包含这个基本对象类型的数值）
-
引用对象的变量（会存放这个变量存放在堆内存的地址）
-
-
方法区
-
包含了所有的class和static变量
-
可以被所有的线程共享
-
-
-
过程画图分析如下
3、二维数组
-
一维数组中的每一个数据元素分别又是一个数组
-
声明、创建、初始化的语法和以为数组一样，但是多了一个[]
//动态初始化
int[][] arrays = new int[2][3];
arrays[0][0] = 1;
arrays[0][1] = 2;
arrays[0][2] = 3;
arrays[1][0] = 4;
arrays[1][1] = 5;
arrays[1][2] = 6;
//静态初始化
int[][] arrays = {{1,2,3},{4,5,6}};
4、数组特点
-
数组长度确定，一旦被创建，其大小不可以被改变，下标的合法取值范围[0,length-1]
如果越界，就会报ArrayIndexOutOfBoundsException异常
-
数组中的元素可以是基本数据类型，也可以是引用类型，但必须是同一种类型
-
数组也是对象，数组中的元素相当于对象的成员变量
5、Arrays类常用方法
5.1、toString()
-
语法：Arrays.toString(数组名)
-
作用：直接输出数组，结果为[I@1540e19d，对象的hashcode，toString()方法可以打印数组中各个元素
//示例
int[] nums = {6,55,32,178,126,986,467,434,556};
//输出结果为：原数组：[6, 55, 32, 178, 126, 986, 467, 434, 556]
System.out.println("原数组：" + Arrays.toString(nums));
5.2、sort()
-
语法：Arrays.sort(数组名)
-
作用：对数组进行升序排序
//示例
int[] nums = {6,55,32,178,126,986,467,434,556};
Arrays.sort(nums);
//输出结果为：排序后的数组：[6, 32, 55, 126, 178, 434, 467, 556, 986]
System.out.println("排序后的数组：" + Arrays.toString(nums));
5.3、copyOf()
-
语法：Arrays.copyOf(数组名,新数组的长度)
-
作用：复制指定的数组，用0截取或填充，以达到指定的数组长度
//示例
int[] nums = {6,55,32,178,126,986,467,434,556};
int[] nums2 = Arrays.copyOf(nums,5);
//输出结果为：复制后的数组：[6, 32, 55, 126, 178]
System.out.println("复制后的数组：" + Arrays.toString(nums2));
int[] nums3 = Arrays.copyOf(nums,15);
//输出结果为：复制后的数组：[6, 32, 55, 126, 178, 434, 467, 556, 986, 0, 0, 0, 0, 0, 0]
System.out.println("复制后的数组：" + Arrays.toString(nums3));
5.4、fill()
-
语法：Arrays.fill(数组名)
-
作用：用0填充所有的数组元素
//示例
int[] nums = {6,55,32,178,126,986,467,434,556};
Arrays.fill(nums,0);
//输出结果为：填充后的数组：[0, 0, 0, 0, 0, 0, 0, 0, 0]
System.out.println("填充后的数组：" + Arrays.toString(nums));
5.5、equals()
-
语法：Arrays.equals(数组1,数组2)
-
作用：判断两个数组是否相同，相同的条件为：包含相同数量的元素，并且两个数组中对应的每个数组元素都相等
//示例
int[] i1 = new int[]{1,2,3};
int[] i2 = {1,2,3};
//输出结果为：true
System.out.println(Arrays.equals(i1,i2));
6、稀疏数组
-
在数组中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，可以用稀疏数组来保存该数组
//创建一个数组，把数组转换成稀疏数组，再把稀疏数组转换为原数组
public class SparseArray {
public static void main(String[] args) {
//一、创建一个数组并且输出
//1、创建一个数组
int[][] sArray1 = new int[11][11];
sArray1[1][2] = 1;
sArray1[2][3] = 2;
sArray1[10][10] = 11;
//2、输出
System.out.println("原数组为：");
for (int[] sInt : sArray1) {
for (int i : sInt) {
System.out.print(i + " ");
}
System.out.println();
}
//二、把数组转换成稀疏数组输出
//1、确定稀疏矩阵中有效字符的个数
int sum = 0;
for (int i = 0; i <11 ; i++) {
for (int j = 0; j <11 ; j++) {
if (sArray1[i][j] != 0){
sum++;
}
}
}
System.out.println("有效值的个数为：" + sum);
/*
2、创建一个稀疏矩阵
总共sum + 1行
第一行存放的是稀疏矩阵的信息，几行、几列、多少个有效字符
其余sum行存放的是有效字符的信息，位于第几行，第几列，值为多少
*/
int[][] sArray2 = new int[sum + 1][3];
//3、给稀疏矩阵赋值
//给第一行元素赋值
sArray2[0][0] = 11;
sArray2[0][1] = 11;
sArray2[0][2] = sum;
/*
给其余行赋值
遍历二维数组，将非零的值存放在稀疏矩阵中
第一层遍历控制横坐标，总共有多少行
第二层遍历控制纵坐标，每一行元素的个数
*/
int count = 0;
for (int i = 0; i <sArray1.length ; i++) {
for (int j = 0; j <sArray1[i].length ; j++){
if (sArray1[i][j] != 0){
count++;
//横坐标
sArray2[count][0] = i;
//纵坐标
sArray2[count][1] = j;