the fourth day 001

Ayyay

数组概述

• 相同类型所有数据的有序集合

• 每个数据都是数组的一个元素，每个元素都可通过下标访问

数组声明创建

int a = 1;
int b = 3;
int c = 56;
ar[0] = c;
ar[1] = b;
ar[2] = a;
System.out.println(ar.length);
for(int i:ar){
    System.out.println(i);
}
//java的堆中放对象和数组，栈中存放变量属性
//声明数组
int[] arr =null;//栈中放一个arr指向值
//创建数组
arr = new int[2];//堆中开辟一个空间存放了数组arr对象，被栈中arr指向
​
//数组的静态初始化
int [] aa = {3,4,5,};
//动态初始化
int [] bb = new int [10];//等号前声明变量(引用类型)，等号后创建数组

数组使用

public static void arrays(){
    //计算数组所有元素和，
    int sum = 0;
    int [] iarr = {4,9,5,4,0,88};
    for(int i:iarr){
        sum+=i;
    }
    //找到最大值
    int max = iarr[0];
    for(int j: iarr){
        if(j>max){
            max = j;
        }
    }
    System.out.println("数组的和"+sum+",数组中最大值："+max);
​
}
​
//反转数组
public static int[] reverse(int [] arr){
    int [] res = new int[arr.length];
    for(int i = 0,j = arr.length-1;i<arr.length;i++,j--){
        res[j] = arr[i];
    }
​
    for(int s:res){
        System.out.println(s);
    }
​
    System.out.println("reverse success");
    return res;
}

多维数组

int  [][] arr = {{5,0,99},{8,77},{2,64}};
System.out.println(arr[1][1]);//77 二维数组找到数组下标1的元素，找到元素数组下标1的元素

Arrays类

//Arrays工具类常用方法
int [] arrs = {0,33,-55,99};
int [] arrs1 = {10,33,-505,99};
int [] arrs2 = {10,33,-505,99};
System.out.println(Arrays.toString(arrs));//字符串输出
Arrays.sort(arrs);//升序
System.out.println(Arrays.toString(arrs));
System.out.println(Arrays.equals(arrs,arrs1));//false比较相同数组
System.out.println(Arrays.equals(arrs2,arrs1));//true比较相同数组
Arrays.fill(arrs,1000);//默认所有元素都被1000填充
System.out.println(Arrays.toString(arrs));//[1000, 1000, 1000, 1000]
Arrays.fill(arrs,1,2,99);//下标1 - 2的元素变为99 不包含下标为2的
System.out.println(Arrays.toString(arrs));//[1000, 99, 1000, 1000]

稀疏数组

用棋盘解释：6行*7列用6个数组表示

//六行七列的数组
int[] a = {0,0,9,0,0,0,0};
​
int[] b = {6,999,0,0,0,0,0};
​
int[] c = {0,0,0,0,0,0,0};
​
int[] d = {0,0,0,666,0,0,0};
​
int[] e = {8,0,0,0,0,0,0};
​
int[] f = {0,0,88,0,0,0,5};
int [][] mm = {a,b,c,d,e,f};//原生数组
for (int[] s : mm) {
    System.out.println(Arrays.toString(s));
}
//行 列  值  第0行 原二维数组包括几个数组元素，每个数组元素包含几个元素  ， 一共有多少个有效数字
​
//先找出多少个有效数字(稀疏数组包含的子数组数)
int num = 0;
for (int[] ints : mm) {
    for(int i =0;i<ints.length;i++){
        if(ints[i]!=0){//子数组中元素非默认值0证明是有效数字
            num++;
        }
    }
}
int[][] ss = new int[num+1][3];
ss[0]=new int[]{mm.length,mm[0].length,num};
int index = 1;//稀疏数组的下标，不会大于num
//将有效数字放进及行列信息放进稀疏数组
for(int i=0;i<mm.length;i++){
    for(int j=0;j<mm[i].length;j++){
        if(mm[i][j]!=0){
            ss[index] = new int[]{i,j,mm[i][j]};
            index++;
        }
    }
}
for (int[] s : ss) {
    System.out.println(Arrays.toString(s));
}
//还原数组
int[][] arr = new int[ss[0][0]][ss[0][1]];//稀疏数组第0行数据
for(int i=1;i<ss.length;i++){
    arr[ss[i][0]][ss[i][1]] = ss[i][2];
}
​
for (int[] ints : arr) {
    System.out.println(Arrays.toString(ints));
}
System.out.println("还原完毕");
//[0, 0, 9, 0, 0, 0, 0]
//[6, 999, 0, 0, 0, 0, 0]
//[0, 0, 0, 0, 0, 0, 0]
//[0, 0, 0, 666, 0, 0, 0]
//[8, 0, 0, 0, 0, 0, 0]
//[0, 0, 88, 0, 0, 0, 5]
//[6, 7, 7]
//[0, 2, 9]
//[1, 0, 6]
//[1, 1, 999]
//[3, 3, 666]
//[4, 0, 8]
//[5, 2, 88]
//[5, 6, 5]
//[0, 0, 9, 0, 0, 0, 0]
//[6, 999, 0, 0, 0, 0, 0]
//[0, 0, 0, 0, 0, 0, 0]
//[0, 0, 0, 666, 0, 0, 0]
//[8, 0, 0, 0, 0, 0, 0]
//[0, 0, 88, 0, 0, 0, 5]
//还原完毕