Java学习笔记（三）——稀疏数组转换和还原

Java写法

稀疏数组： 
 Java写法： 
package methods;

public class SpareArray {
    public static void main(String[] args) {
        int [][] temp = new int [5][5];
        temp[2][3] = 6;
        temp[1][0] = 12;
        spareArray(temp);
    }
    public static void spareArray(int[][] temp){
//        稀疏数组的长度
        int tempLen = 0;

//        打印数组
        for(int i = 0; i< temp.length;i++){
            for(int j = 0; j< temp[i].length;j++){
                if(temp[i][j] != 0){
                    tempLen++;
                }
                System.out.print(temp[i][j]);
                System.out.print(" ");
            }
            System.out.println();
        }
        System.out.println(tempLen);
//        0 0 0 0 0
//        12 0 0 0 0
//        0 0 0 6 0
//        0 0 0 0 0
//        0 0 0 0 0

//       获取稀疏数组
        int index = 0;
        int [][] spareArr = new int [tempLen + 1][tempLen + 1];
        spareArr[0][0] = temp.length;
        spareArr[0][1] = temp.length;
        spareArr[0][2] = tempLen;
        for (int i = 0; i < temp.length;i++){
            for(int j = 0;j<temp[i].length; j++){
                if(temp[i][j] != 0){
                    index ++;
                    spareArr[index][0] = i;
                    spareArr[index][1] = j;
                    spareArr[index][2] = temp[i][j];
                }
            }
        }
        printArray(spareArr);
//        5 5 2
//        1 0 12
//        2 3 6

//       利用稀疏数组还原数组
        int  [][] originArr = new int [spareArr[0][0]][spareArr[0][1]];
        for (int i = 1; i< spareArr.length; i++ ){
            originArr[spareArr[i][0]][spareArr[i][1]] = spareArr[i][2];
        }
        printArray(originArr);
//        0 0 0 0 0
//        12 0 0 0 0
//        0 0 0 6 0
//        0 0 0 0 0
//        0 0 0 0 0


    }

    public static void printArray(int[][] temp){
        for (int [] item: temp ) {
            for (int i :item) {
                System.out.print(i);
                System.out.print(" ");
            }
            System.out.println();
        }
    }
}

JS写法

JS写法：
 test() {
    // 创建一个数组
      const arr = [0, 0, 0, 0, 0].map((item, index) => {
        const temp = [0, 0, 0, 0, 0]
        temp[index] = index
        return temp
      })
      console.log({ arr })
      //  获取稀疏数组
      let index = 0
      const sparseArr = []
      arr.forEach(item => {
        item.forEach(i => {
          i !== 0 ? index++ : ''
        })
      })
      sparseArr[0] = [arr.length, arr.length, index]
      for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr[i].length; j++) {
          if (arr[i][j]) {
            sparseArr.push([i, j, arr[i][j]])
          }
        }
      }
      console.log({ sparseArr })
      // 0: (3) [5, 5, 4]
      // 1: (3) [1, 1, 1]
      // 2: (3) [2, 2, 2]
      // 3: (3) [3, 3, 3]
      // 4: (3) [4, 4, 4]
      this.reTurnNewArray(sparseArr)
    },
    reTurnNewArray(sparseArr) {
      const len = sparseArr[0][0]
      const originArr = new Array(len).fill(0).map(item => new Array(len).fill(0))
      for (let i = 1; i < sparseArr.length; i++) {
        originArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2]
      }
      console.log({ originArr })
      // 0: (5) [0, 0, 0, 0, 0]
      // 1: (5) [0, 1, 0, 0, 0]
      // 2: (5) [0, 0, 2, 0, 0]
      // 3: (5) [0, 0, 0, 3, 0]
      // 4: (5) [0, 0, 0, 0, 4]
    },

简单写了一下记录一下问题：
Java的数组长度是固定的，而JS的数组长度是不定的。
Java的数组类型必须是统一的，而JS的数组中可以存放任意元素。
Java的数组在定义后就会有初始值，数值类型的值是0，boolean类型的值是false,其余类型的值是null,而JS声明空数组就是一个空数组。
Array.fill(): 接受三个参数，填充值，起始位置，终止位置；
注意的是，当填充的值是引用类型的时候，如果后续要对填充的值进行修改，会出现所有填充的值都会被修改，原因就是引用类型变量存储的是一个内存地址，而不是真正的值。