Java中普通二维数组转稀疏数组

前奏

 * 提示：稀疏数组是一种特殊的二维数组
 * 什么时候用到：当一个普通二维数组的默认值数量大于有效值得数量就可以用 稀疏数组进行压缩
 * 特点: 第一行第一列代表：普通数组的总行数
 *       第一行第二列代表：普通数组的总列数
 *       第一行第三列代表：普通数组的有效个数
 * 该演示整个流程： 普通二维数组---->稀疏数组---->文件----->稀疏数组----->普通二维数组

技术知识点：用到到了流对象 BufferedWriter(缓冲输出流) BufferedReader(缓冲输入流)

代码

public class SparseArrayDemo {

    public static void main(String[] args) {

        //顶一个普通二维数组
        int [][] commonArray=new int [10][4];
        commonArray[0][1]=777;
        commonArray[1][1]=777;
        commonArray[2][1]=777;

        //转换前的样子
        System.out.println("============转换前的样子============");
        for(int [] arr:commonArray){
            for(int arr2: arr){
                System.out.print(arr2+"\t\t");
            }
            System.out.println();
        }

        System.out.println("============转换后的样子============");
        int[][] ints = commonArrayConverSparseArray(commonArray);
        for(int [] arr:ints){
            for(int arr2: arr){
                System.out.print(arr2+"\t\t");
            }
            System.out.println();
        }

        System.out.println("============转入到文件中============"+sparseArrayToFile(ints));

        System.out.println("============到文件中转换成稀疏数组============");
        int[][] ints1 = fileToSparseArray();
        for(int [] arr:ints1){
            for(int arr2: arr){
                System.out.print(arr2+"\t\t");
            }
            System.out.println();
        }

        System.out.println("============稀疏数组转二维数组============");
        int[][] ints2 = sparseArrayConverCommonArray(ints1);
        for(int [] arr:ints2){
            for(int arr2: arr){
                System.out.print(arr2+"\t\t");
            }
            System.out.println();
        }

    }

    //普通数组转稀疏数组
    public static int [][] commonArrayConverSparseArray(int [][] commonArray){

        //获取数组中的有效个数、总行数、总列数
        int countLineNumber= commonArray.length;
        int countColumnNumber= commonArray[0].length;
        int countValidNumber= getArrayValidCountNumber(commonArray);

        //创建一个稀疏数组
        int [][] sparseArray=new int [countValidNumber+1][3];
        sparseArray[0][0]=countLineNumber;
        sparseArray[0][1]=countColumnNumber;
        sparseArray[0][2]=countValidNumber;

        int tempIndex=1;

        //遍历普通数组
        for(int index=0;index<countLineNumber;index++){
            for(int index2=0;index2<countColumnNumber;index2++){
                if(commonArray[index][index2]!=0){
                    sparseArray[tempIndex][0]=index;
                    sparseArray[tempIndex][1]=index2;
                    sparseArray[tempIndex][2]=commonArray[index][index2];
                    tempIndex++;
                }
            }
        }
        return sparseArray;
    }

    //稀疏数组转到文件上
    public static boolean sparseArrayToFile(int [][] sparseArray){
        try {
            //创建一个字符输出流对象
            BufferedWriter writer=new BufferedWriter(new FileWriter("D:\\test.txt"));

            //遍历当前稀疏数组
            for(int []arr:sparseArray){
                for(int element:arr){
                    writer.write(element+"\t");
                }
                writer.newLine();
                writer.flush();
            }
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }



    //文件内容转稀疏数组
    public static int[][] fileToSparseArray(){

        //创建一个稀疏数组
        int [][] sparseArray=null;

        try {
            //创建一个稀疏数组变量
            int sparseIndex=0;
            String readString="";

            //创建一个字符输入流
            BufferedReader reader=new BufferedReader(new FileReader("D:\\test.txt"));
            while((readString=reader.readLine())!=null){
                //将字符串数组转int数组
                int[] array = Arrays.stream(readString.trim().split("\t")).mapToInt(Integer::parseInt).toArray();
                if(sparseArray==null){
                    sparseArray=new int[array[2]+1][3];
                }
                sparseArray[sparseIndex][0]=array[0];
                sparseArray[sparseIndex][1]=array[1];
                sparseArray[sparseIndex][2]=array[2];
                sparseIndex++;
            }
            reader.close();//关流
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
        return sparseArray;
    }

    //稀疏数组转普通数组
    public static int[][] sparseArrayConverCommonArray(int[][] sparseArray){

        //创建一个普通数组对象
        int [][] commonArray=new int [sparseArray[0][0]][sparseArray[0][1]];

        for(int index=1;index<sparseArray.length;index++){
            commonArray[sparseArray[index][0]][sparseArray[index][1]]=sparseArray[index][2];
        }
        return commonArray;

    }
    //获取数组中的有效元素的个数
    public static int getArrayValidCountNumber(int [][] commonArray){
        //统计个数的变量
        int countNumber=0;

        for(int [] arr1:commonArray){
            for(int arr:arr1){
                if(arr!=0){
                    countNumber++;
                }
            }
        }
        return countNumber;
    }
}

结果