java将二维数组转为稀疏数组保存到本地并读取本地文件转为二维数组

简介: java将二维数组转为稀疏数组保存到本地并读取本地文件转为二维数组

package sparsearray;

import java.io.*;

public class SparseArray {

public static void main(String[] args) {
    //创建一个原始的二维数组11*11
    //0表示没有棋子,1表示黑棋,2表示白棋
    int[][] chessArr1 = new int[11][11];
    chessArr1[1][2] = 1;
    chessArr1[2][3] = 2;
    System.out.println("原始二维数组:");
    //遍历二维数组
    for (int[] row : chessArr1) {
        for (int data : row) {
            System.out.printf("%d\t",data);
        }
        System.out.println();
    }
    //统计原始二维数组不为0的的个数
    int count = 0;
    for (int[] row : chessArr1) {
        for (int data : row) {
            if(data != 0) {
                count++;
            }
        }
    }
    System.out.println("原始二维数组不为0的的个数为:"+count);

    //定义稀疏数组
    int[][] sparseArr = new int[count+1][3];

    //稀疏数组第一行的值
    sparseArr[0][0] = chessArr1.length;
    sparseArr[0][1] = chessArr1[0].length;
    sparseArr[0][2] = count;


    //为稀疏数组其他行赋值
    int count2 = 0;//记录是第几个非零的数据
    for (int i = 1;i<chessArr1.length;i++) {
        for (int j = 0;j<chessArr1[0].length;j++) {
            if (chessArr1[i][j]!=0) {
                count2++;
                sparseArr[count2][0] = i;
                sparseArr[count2][1] = j;
                sparseArr[count2][2] = chessArr1[i][j];
            }
        }
    }

    System.out.println("");
    System.out.println("稀疏数组为:");
    //遍历稀疏数组
    for (int i =0;i<sparseArr.length;i++) {
        System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
    }

    System.out.println("开始写入文件<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
    //将稀疏数组保存到磁盘E:\java\repos\idea_repos\DataStructures\src\sparsearray\data.txt,文件名为data.txt
    BufferedWriter out =null;
    try {
        out = new BufferedWriter(new FileWriter("E:\\java\\repos\\idea_repos\\DataStructures\\src\\sparsearray\\map.data",true));  //文件写入流
        //将数组中的元素写入文件,每个用tab隔开
        for(int i = 0;i<sparseArr.length;i++) {
            for (int j=0;j<sparseArr[0].length;j++) {
                out.write(sparseArr[i][j]+"\t");
            }
            out.newLine();

// out.write("\r\n");

        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (out!=null) {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    System.out.println("写入文件成功<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
    /**
     * 读取map.data文件
     */
    BufferedReader br = null;
    int readRow = 0;//记录行数

// String[] temp =null;//读取的数组

    //建新的稀疏数组
    int[][] sparseArr2 = new int[count+1][3];
    try {
        br = new BufferedReader(new FileReader("E:\\java\\repos\\idea_repos\\DataStructures\\src\\sparsearray\\map.data"));
        String line = null;
        //统计行数
        while ((line = br.readLine()) !=null) {
            String[] temp = line.split("\t");
            for (int j = 0;j<temp.length;j++) {
                sparseArr2[readRow][j] = Integer.parseInt(temp[j]);
            }
            readRow++;
        }



    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br!=null) {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 遍历读取的稀疏数组
     */
    System.out.println("从磁盘读取的稀疏数组为:");
    for (int i = 0;i<sparseArr2.length;i++) {
        System.out.printf("%d\t%d\t%d\t\n",sparseArr2[i][0],sparseArr2[i][1],sparseArr2[i][2]);
    }

    /**
     * 将稀疏数组转为二维数组
     */
    //根据稀疏数组创建二维数组
    int[][] chessArr2 = new int[sparseArr2[0][0]][sparseArr2[0][1]];

    //为二维数组赋值
    for(int i = 1; i < sparseArr2.length; i++) {
        chessArr2[sparseArr2[i][0]][sparseArr2[i][1]] = sparseArr2[i][2];
    }
    System.out.println();
    System.out.println("转换后的新的二维数组为:");
    //输出新的二维数组
    for (int[] row : chessArr2) {
        for (int data : row) {
            System.out.printf("%d\t",data);
        }
        System.out.println();
    }
}

}

目录
相关文章
|
3月前
|
存储 缓存 Java
Java数组全解析:一维、多维与内存模型
本文深入解析Java数组的内存布局与操作技巧,涵盖一维及多维数组的声明、初始化、内存模型,以及数组常见陷阱和性能优化。通过图文结合的方式帮助开发者彻底理解数组本质,并提供Arrays工具类的实用方法与面试高频问题解析,助你掌握数组核心知识,避免常见错误。
|
2月前
|
Java
Java 数组学习笔记
本文整理Java数组常用操作:遍历、求和、查找、最值及二维数组行求和等典型练习,涵盖静态初始化、元素翻倍、去极值求平均等实例,帮助掌握数组基础与应用。
|
4月前
|
存储 Java 索引
java 数组
在 Java 中,数组是一种数据结构,用于存储多个相同类型的数据元素。数组的大小一旦创建后就不能改变,因此它是固定长度的。Java 数组是一种 对象,即使它存储的值是基本类型(如 int、double 等),它也是一个对象引用。
93 0
|
6月前
|
存储 人工智能 Java
打乱数组内容引发的问题( Java)
本文介绍了两种实现数组随机打乱的方法,并深入探讨了Java中原始数据类型与对象类型的差异。方法一通过自定义随机数交换数组元素位置,方法二借助`Collections.shuffle()`函数完成数组打乱。同时,文章详细解析了`int`和`Integer`的区别,包括声明方式、内存占用、初始化以及对象特性等,并讲解了自动装箱与拆箱的功能,帮助读者更好地理解Java的基础知识。
|
8月前
|
人工智能 Java
Java 中数组Array和列表List的转换
本文介绍了数组与列表之间的相互转换方法,主要包括三部分:1)使用`Collections.addAll()`方法将数组转为列表,适用于引用类型,效率较高;2)通过`new ArrayList&lt;&gt;()`构造器结合`Arrays.asList()`实现类似功能;3)利用JDK8的`Stream`流式计算,支持基本数据类型数组的转换。此外,还详细讲解了列表转数组的方法,如借助`Stream`实现不同类型数组间的转换,并附带代码示例与执行结果,帮助读者深入理解两种数据结构的互转技巧。
463 1
Java 中数组Array和列表List的转换
|
7月前
|
存储 Java 数据挖掘
Java 中数组的多种定义方式
本文深入解析了Java中数组的多种定义方式,涵盖基础的`new`关键字创建、直接初始化、动态初始化,到多维数组、`Arrays.fill()`方法以及集合类转换为数组等高级用法。通过理论与实践结合的方式,探讨了每种定义方法的适用场景、优缺点及其背后的原理,帮助开发者掌握高效、灵活的数组操作技巧,从而编写更优质的Java代码。
275 0
|
前端开发 Java
java前端:删除数组中指定元素的方法
java前端:删除数组中指定元素的方法
234 1
|
10月前
|
存储 Java 索引
Java快速入门之数组、方法
### Java快速入门之数组与方法简介 #### 一、数组 数组是一种容器,用于存储同种数据类型的多个值。定义数组时需指定数据类型,如`int[]`只能存储整数。数组的初始化分为静态和动态两种: - **静态初始化**:直接指定元素,系统自动计算长度,如`int[] arr = {1, 2, 3};` - **动态初始化**:手动指定长度,系统给定默认值,如`int[] arr = new int[3];` 数组访问通过索引完成,索引从0开始,最大索引为`数组.length - 1`。遍历数组常用`for`循环。常见操作包括求和、找最值、统计特定条件元素等。
|
存储 缓存 算法
提高 Java 数组性能的方法
【10月更文挑战第19天】深入探讨了提高 Java 数组性能的多种方法。通过合理运用这些策略,我们可以在处理数组时获得更好的性能表现,提升程序的运行效率。
243 2
下一篇
开通oss服务