Java 数组与稀疏数组直接的转化

Java 数组与稀疏数组直接的转化

写了一个demo，实现效果：

• 数组=> 稀疏数组=>文件
• 文件=>稀疏数组=>数组
  

控制台输出

生成的data文件

/**
 * 稀疏数组 ： 减少空间，提高效率
 */
public class testArray {
    public static void main(String[] args) throws IOException {
        int[][] oldArr = getOldArr(); // 声明原始数组，弄一个示例数据
        int count = getCount(oldArr); // 获取原始数组的有效数字总数
        int[][] buildArray = buildArray(count, oldArr); // 构建稀疏数组
        System.out.println("--------原始数组--------");
        print(oldArr); // 打印原数组
        System.out.println("--------稀疏数组--------");
        print(buildArray); // 打印稀疏数组
        int[][] oldArray = getOldArray(buildArray); // 再把稀疏数组转换为原始数组
        System.out.println("--------稀疏数组-转-原始数组------------");
        print(oldArray);
        saveFile(buildArray,"C:\\Users\\l\\Desktop\\test"); // 把稀疏数组保存到data文件     
        int[][] ints = readFile("C:\\Users\\l\\Desktop\\test\\map.data"); // 读取data文件
        System.out.println("打印从文件读取转化后的稀疏数组");
        print(ints);
    }

    // 稀疏数组转换为原始数组
    public static int[][] getOldArray(int newArr[][]){
        int oldArr[][] = new int[newArr[0][0]][newArr[0][1]];
        for (int i = 1; i < newArr.length; i++) {
             int row = newArr[i][0];
             int col = newArr[i][1];
             int value = newArr[i][2];
             oldArr[row][col] = value;
        }
        return oldArr;
    }

    // 打印
    public static void print(int[][] arr){
        for (int[] ints : arr) {
            for (int i : ints) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
    }
    /**
     * 构建稀疏数组
     * @param count
     * @param oldArr
     * @return
     */
    static int[][] buildArray(int count,int[][] oldArr){
        int [][] newArr = new int[count+1][3]; //稀疏数组行数 旧数组有效数字+1 ，列固定3行
        // 构建稀疏数组第一行
        newArr[0][0] = 11; //稀疏数组第一行第一列就是原数组的总行数
        newArr[0][1] = 11; //稀疏数组第一行第二列就是原数组的总列数
        newArr[0][2] = count; // //稀疏数组第一行第三列就是原始数组的有效数字总数量
        int num = 0; //
        for (int i = 0; i < oldArr.length; i++) { // 遍历行
            for (int j = 0; j < oldArr[i].length; j++) { // 遍历列
                if (oldArr[i][j]!=0){ // 如果当前遍历的数是有效数字
                    num++; // 每走到这儿，稀疏数组就会增加一行
                    newArr[num][0] = i; // 稀疏数组的第一列：当前有效数字所在的行
                    newArr[num][1] = j; // 稀疏数组的第二列：当前有效数字所在的列
                    newArr[num][2] = oldArr[i][j]; // 稀疏数组的第二列：当前有效数字的值
                }
            }
        }

        return newArr;
    }
    // 构建一个测试的二维数组数据
    static int[][] getOldArr(){
        int [][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
        arr[4][6] = 10;
        return arr;
    }
    // 获取原始数组的有效数字总数
    static int getCount(int[][] oldArr){
        int count = 0;
        for (int[] ints : oldArr) {
            for (int i : ints) {
                if (i!=0){
                    count++;
                }
            }
        }
        return count;
    }

    public static boolean saveFile(int[][] newArr,String filePath) throws IOException {
        String fileName =  "map.data";
        filePath = filePath+"/" +fileName;
        File file = new File(filePath);
        if (file.exists()&&file.isFile()){
            file.delete();
        }
        FileOutputStream stream = new FileOutputStream(filePath);
        for (int[] ints : newArr) {
            for (int i : ints) {
                String line = String.valueOf(i) + "\t";
                byte[] bytes = line.getBytes();
                stream.write(bytes);
            }
            stream.write("\n".getBytes());
        }
		stream.close(); 
        return false;
    }

    /**
     * 读取data文件，转化为稀疏数组
     * @param filePath
     * @return
     * @throws IOException
     */
    public static int[][] readFile(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()){
            throw new FileNotFoundException("文件不存在！");
        }
        FileInputStream stream = new FileInputStream(file);
        int read = 0;
        String var = "";
        int row = 0; // 表名数组的行
        int col = 0;// 表名数组的列
        ArrayList<String> list = new ArrayList<>();
        while ((read=stream.read())!=-1){ // 读到-1，就没有了
            String value = String.valueOf((char) read);
            if (!value.equals("\n")){ // 只要不读到换行符就拼接字符串
                var += value;
            }

            if (value.equals("\n")) { // 如果读到换行，表明读完一行
                row++;
                list.add(var); // 把数据存到集合
                var = "";
            }
            if (value.equals("\t")){ // 如果读到制表符，表明读完一列
                col++;
            }
        }
        stream.close();
        int [][] newArr = new int[row][col];
        for (int i = 0; i < list.size(); i++) {
            String line = list.get(i);
            String[] split = line.split("\t");
            // 字符串数组转化为int类型数组

            // 方式1
            // 使用stream流方式
            int[] splitArr = Arrays.stream(split).mapToInt(Integer::parseInt).toArray();
/*

            // 方式2
            // 循环转化
            int [] splitArr = new int[split.length];
            for (int j = 0; j < split.length; j++) {
                arr[j] = Integer.parseInt(split[j]);
            }*/
            newArr[i] = splitArr;
        }

        return newArr;
    }

}