数组
动态初始化包含了默认初始化
array[]是早期为了迎合c语言和c++用户
int array[] = new int[10];
double[] nums = new double[5];
System.out.println(nums[4]);//0.0
//静态初始化
Demo01[] demo01s = {new Demo01(),new Demo01()};
底层原理:数组的栈堆内存图
数组本身就是对象,元素相当于成员变量
不要做越界的事情,学以致用
反转数组元素
int[] array = {1,2,3,4,5};
/**
* 将旧数组的元素"从高到低"
* 放进新数组"从低到高"的位置中
*/
int[] reverse = new int[array.length];
for (int i = 0, j = reverse.length - 1; i < array.length; i++,j--) {
reverse[i] = array[j];
}
不要重复造轮子
自己实现Arrays.toString方法
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
if(i == 0){
System.out.print("[");
}
if(i == array.length - 1){
System.out.print(array[i] + "]");
return;
}
System.out.print(array[i] + ", ");
}
}
sort排序:时间复杂度为O(n的2次方)
int[] array = {1,2343,5,54,65};
Arrays.sort(array);
System.out.println(Arrays.toString(array));
fill填充替换
Arrays.fill(array,2,4,0);
冒泡排序
public static void main(String[] args) {
double[] array = new double[]{45, 65,888, 89,1000,100.5, 32};
array = bubble(array);
System.out.println(Arrays.toString(array));
}
public static double[] bubble(double[] array){
/**
* i < array.length -1:5个数字只用比较4轮
* j < array.length - 1 - i:第三轮比较时,前两个数字已经排序好了
*
* if(flag):元素数据不用改变,就代表已经全部排序好了.
*/
for (int i = 0; i < array.length - 1; i++) {
boolean flag = true;
for (int j = 0; j < array.length - 1 - i; j++) {
if(array[j] < array[j+1]){
double temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = false;
}
}
if(flag){
break;
}
}
return array;
}
稀疏数组
稀疏数组只记录有效数据
- 一个10行10列的棋盘,只有第二行第三列和第三行第四列有效
- 实现这个棋盘
- 变成稀疏数组
- 再还原
/**
* 一个10行10列的棋盘,只有第二行第三列和第三行第四列有效
*/
int[][] arrays = new int[10][10];
arrays[1][2] = 1;
arrays[2][3] = 2;
arrays[5][3] = 1;
//sum记录所有有效数字的个数
int sum = 0;
for(int[] array:arrays){
for(int value:array){
System.out.print(value + "\t");
if(value != 0){
sum++;
}
}
System.out.println();
}
稀疏数组也是一个二维数组,也有行和列
- 第一行记录所有行,列和有效数字个数
- 往后记录有效数字的位置和值
int[][] sparse = new int[sum+1][3];
sparse[0][0] = arrays.length;
sparse[0][1] = arrays[0].length;
sparse[0][2] = sum;
int index = 1;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if(arrays[i][j] != 0){
/**
* 记录行,列和值
*/
sparse[index][0] = i;
sparse[index][1] = j;
sparse[index][2] = arrays[i][j];
index++;
}
}
}
System.out.println("稀疏数组:");
for(int[] array:sparse){
for(int value:array){
System.out.print(value + "\t");
}
System.out.println();
}
稀疏数组还原
第一种方法
- 一个新的二维数组,长度就是稀疏数组中记录的原数组的行和列
- 遍历稀疏数组:新数组对应位置上的值,就是稀疏数组中记录的值
int[][] oldArray = new int[sparse[0][0]][sparse[0][1]];
for (int i = 1; i < sparse.length; i++) {
/**
* 新数组要改变值的行和列
* 就是稀疏数组中记录的行和列
*/
oldArray[sparse[i][0]][sparse[i][1]] = sparse[i][2];
}
for(int[] array:oldArray){
for(int value:array){
System.out.print(value + "\t");
}
System.out.println();
}
第二种方法:直接打印
- 用稀疏数组存储的行,列来作为"无效数字"的for循环遍历
- 从1开始遍历稀疏数组
- 索引到达稀疏数组中记录的值时打印
System.out.println("还原:");
for (int j = 0; j < sparse[0][0]; j++) {
for (int k = 0; k < sparse[0][1]; k++) {
/**
* 遍历稀疏数组,等于值就打印
* k++:找到一个值后这一行就少打印一个数
*/
for (int i = 1; i < sparse.length; i++) {
if(j == sparse[i][0] && k == sparse[i][1]){
System.out.print(sparse[i][2] + "\t");
k++;
}
}
System.out.print("0\t");
}
System.out.println();
}
思考:有没有必要注意不能超出稀疏数组记录的有效值个数
- = 稀疏数组记录有效数字时多了或者少了
- 答:稀疏数组已经记录了行和列
- 实践后(增加或减少有效数字个数后,程序没有出错).
- 只要遍历原数组时不出错这里就不会出错