对文件读写稀疏矩阵

稀疏数组方便保存只有少量有效数据的数组

第一种

创建一个样本数组

int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[1][3] = 2;
        chessArr[1][4] = 2;
        chessArr[2][6] = 1;
        chessArr[2][1] = 1;
        for (int[] i : chessArr) {
            for (int j = 0; j < i.length; j++) {
                System.out.printf("%d\t",i[j]);
            }
            System.out.println("");
        }

输出为:
在这里插入图片描述

转化为稀疏数组

//获取有效数据的数量
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println(sum);
        //创建稀疏数组3*3
        int sparseArr[][] = new int[sum + 1][3];
        //设置第一行数据
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        int row = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    sparseArr[row+1][0] = i;
                    sparseArr[row+1][1] = j;
                    sparseArr[row+1][2] = chessArr[i][j];
                    row++;
                }
            }
        }
        //输出稀疏数组
        for (int[] i : sparseArr) {
            for (int j = 0; j < i.length; j++) {
                System.out.printf("%d\t",i[j]);
            }
            System.out.println("");
        }

输出结果:
在这里插入图片描述

将稀疏数组保存到文件中

            for (int i = 0; i < sparseArr.length; i++) {
                for (int j = 0; j < sparseArr[i].length; j++) {
                    //将每个元素转换为字符串
                    String content =sparseArr[i][j] + "";
                    out.write(content + "\t");
                }
                out.write("\r\n");
            }
            out.close();

输出结果
在这里插入图片描述

读取文件中的数据,变成稀疏数组

		//预定义字符数组用来存从文件中读取的字符
        char[] chars = new char[100];
        FileReader fileReader = new FileReader(file);
        fileReader.read(chars);
        //判断文件有多少行数据,以此动态创建合适的稀疏数组
        int m = 0;
        for (char c : chars){
            if (10==c) {
                m++;
            }
        }
        //创建稀疏数组
        int[][] sparseArrRead = new int[m][3];
        //定义总字符数组索引,用于遍历一个一个字符
        int o = 0;
        //给每一个稀疏数组赋值
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < 3; j++) {
                //预定义用来存有效数据的字符串,当匹配成功以后,方便将其转化为数字,存到稀疏数组中
                String termstring = "";
                //不断循环总字符数组
                while (true) {
                	//如果等于"/r",o=o=2跳过换行符号"/r/n"
                    if (chars[o] == 13) {
                        o =o + 2;
                    }
                    //如果不是其他无效符号,既遍历到有效数据的时候,将字符暂时保存到termstring中
                    if (chars[o] != 9 && chars[o] != 10) {
                        termstring += chars[o];
                        o++;
                        //跳出次循环,再次寻找下一个字符
                        continue;
                    }
                    //如果拼配到"/t",则将临时字符串termstring转数字存起来,break出去,为下一个二维数组元素赋值
                    sparseArrRead[i][j] = Integer.parseInt(termstring);
                    o++;
                    break;
                }
            }
        }
        //输出
        for (int[] i : sparseArrRead) {
            for (int j = 0; j < i.length; j++) {
                System.out.printf("%d\t",i[j]);
            }
            System.out.println("");
        }
        //关闭
        fileReader.close();

另一种

		char[] chars = new char[100];//能不固定长度吗?
        FileReader fileReader = new FileReader(file);
        fileReader.read(chars);
        //判断文件有多少行数据,以此动态创建合适的稀疏数组
        int l = 0;
        for (char c : chars){
            if (10==c) {
                l++;
            }
        }
        //稀疏数组赋值
        int[][] sparseArrRead = new int[l][3];
        String firstStr = String.valueOf(chars);
        String s = firstStr.trim(); //删除字符串前后空格
        String[] splitRow = s.split("\r\n");
        int n = 0;
        int m = 0;
        for (String s1 : splitRow) {
            String[] splitOne = s1.split("\t");
            for (String s2 : splitOne) {
                sparseArrRead[n][m] = Integer.parseInt(s2);
                m++;
                if (m == 3) {
                    n++;
                    m = 0;
                }
            }
        }
        //输出数组
        for (int[] i : sparseArrRead) {
            for (int j = 0; j < i.length; j++) {
                System.out.printf("%d\t",i[j]);
            }
            System.out.println("");
        }
        fileReader.close();

其实可以将总字符数组转化成一个字符串,然后根据"/r/n"来分割一行一行
然后再根据"/t"继续分割成一个数据

如果把稀疏数组大小写死,那么直接一个一个读取更简单。

但是好像无论如何都要预定义一个固定长度的数组来接收文件中的字符,还是没有办法动态读取。只能用集合吗?

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页