Java IO流 字符流 字节流 缓冲流 文件复制 编码问题 xlsx类型文件生成 创建临时文件

已于 2023-08-15 16:39:36 修改
阅读量273 收藏
点赞数 1
分类专栏： Java 文章标签： java eclipse
于 2023-02-20 11:25:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44326073/article/details/129118422
版权
本文介绍了Java中的IO操作，包括计算文件大小的递归方法，删除文件的实现，使用FileInputStream和FileOutputStream进行读写，以及如何复制文件和文件夹。还讨论了字节流和字符流的区别，缓冲流提高效率的作用，以及处理编码问题。最后提到了如何创建和处理xlsx类型的文件。
摘要由CSDN通过智能技术生成

Java IO流

文件

1、获取文件大小，涉及知识点（File，递归）

递归：自己调自己

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Desktop\\test");
        System.out.println(fileSize(file));
    }
    //获取当前文件夹大小
    public static long fileSize(File file){
        long len = 0;
        //判断文件是否存在
        if (file.exists() && file.isDirectory()){
            //获取当前文件夹下的文件数组
            File[] files = file.listFiles();
            for (File file1 : files) {
                //判断当前读取的是否是文件
                if (file1.isFile()){
                    len += file1.length();
                }else {
                    //如果当前文件为文件夹则递归调用
                    long size = fileSize(file1);
                    len += size;
                }
            }
        }
        return len;
    }
}
2、删除文件，涉及知识点（File，递归）

复制文件夹时目标文件夹建在源文件目录下时，可用来删除套娃文件夹

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Desktop\\test");
        deleteFile(file);
    }

    public static void deleteFile(File file){
        //判断文件是否存在
        if (file.exists() && file.isDirectory()){
            //获取当前文件夹下的文件数组
            File[] files = file.listFiles();
            for (File file1 : files) {
                //判断当前读取的是否是文件
                if (file1.isFile()){
                    file1.delete();
                }else {
                    deleteFile(file1);
                }
            }
        }
        file.delete();
    }

}

字节流

1、读取 FileInputStream

读取当前文件下所有内容

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Desktop\\test");
        readFile(file);
    }

    public static void readFile(File file) throws IOException {
        //判断文件是否存在
        if (file.exists() && file.isDirectory()){
            //获取当前文件夹下的文件数组
            File[] files = file.listFiles();
            for (File file1 : files) {
                //判断当前读取的是否是文件
                if (file1.isFile()){
                    FileInputStream fileInputStream = new FileInputStream(file1);
                    int read = 0;
                    while((read = fileInputStream.read())>0){
                        System.out.println(read);
                    }
                    //释放资源
                    fileInputStream.close();
                }else {
                    System.out.println("xxxxxxxxxxxxx");
                    //如果当前文件为文件夹则递归调用
                    readFile(file1);
                }
            }
        }
    }

}
2、写入 FileOutputStream
public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Desktop\\test\\11.txt");
        writeFile(file);
    }

    public static void writeFile(File file) throws IOException {
        //判断文件是否存在
        if (file.exists()){
            //判断当前读取的是否是文件
            if (file.isFile()){
                FileOutputStream fileOutputStream = new FileOutputStream(file);
                byte[] by={'H','E','L','L','O'};
                fileOutputStream.write(by);
                //写入指定长度的字节
                fileOutputStream.write(by,2,3);
                fileOutputStream.close();
            }
        }
    }

}
3、复制文件
public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Desktop\\test\\11.txt");
        //a 文件夹要事先建好
        File file1 = new File("C:\\Users\\Desktop\\test\\a");
        copyFile(file,file1);
    }


    //目标文件夹下复制想要复制的文件
    public static void copyFile(File srcDir,File destDir) throws IOException {
        //在目标文件夹下创建同名文件
        File destFile = new File(destDir, srcDir.getName());
        //读取源文件内容并写入目标文件
        FileOutputStream fileOutputStream = new FileOutputStream(destFile);
        //读取源文件内容
        FileInputStream fileInputStream = new FileInputStream(srcDir);

        byte[] bytes = new byte[1024];
        int read ;
        while((read = fileInputStream.read())>0){
            fileOutputStream.write(read);
        }
		//释放资源
        fileInputStream.close();
        fileOutputStream.close();

    }
}
4、复制文件夹

注意目标文件夹不要建在源文件夹中否则将会无限套娃（有判断除外）

public class FileTest {
    public static void main(String[] args) throws IOException {
        //复制文件夹
        File file = new File("C:\\Users\\Desktop\\test");
        File file1 = new File("C:\\Users\\Desktop\\test\\test2");
        copyFolder(file,file1);
    }

    //复制文件夹
    //注意目标文件夹不要建在源文件夹中否则将会无限套娃（有判断除外）
    public static void copyFolder(File srcDir,File destDir) throws IOException{
        if(!(srcDir.exists() && srcDir.isDirectory())){
            throw new RuntimeException("当前文件夹不存在或者不是一个文件夹");
        }
        if(!srcDir.isDirectory()){
            throw new RuntimeException("destDir不是一个文件夹");
        }
        //创建目标文件夹
        File destFolder = new File(destDir, srcDir.getName());
        //创建出目标文件夹，不写的话报错
        destFolder.mkdirs();
        //读取源文件夹下所有文件
        //依次将源文件夹下的内容复制到目标文件下
        File[] files = srcDir.listFiles();
        for (File file : files) {
            //当要复制的是文件时
            if (file.isFile()){
                copyFile(file,destFolder);
            }else{
    				//判断复制的是不是目标文件，禁止套娃
    			if(file.getName().equals(destDir.getName())){
                    //throw new RuntimeException("禁止套娃，当前复制的是目标文件夹");
                    //中止本次循环,接着开始下一次循环，break;return;都会终止掉目前的循环，容易导致文件复制不全
                    continue;
                }
                //当复制的是文件夹时
                copyFolder(file,destFolder);
            }
        }
    }

    //目标文件夹下复制想要复制的文件
    public static void copyFile(File srcDir,File destDir) throws IOException {
        //在目标文件夹下创建同名文件
        File destFile = new File(destDir, srcDir.getName());
        //读取源文件内容并写入目标文件
        FileOutputStream fileOutputStream = new FileOutputStream(destFile);
        //读取源文件内容
        FileInputStream fileInputStream = new FileInputStream(srcDir);

        byte[] bytes = new byte[1024];
        int read ;
        while((read = fileInputStream.read())>0){
            fileOutputStream.write(read);
        }
		//释放资源
        fileInputStream.close();
        fileOutputStream.close();

    }

}
5、编码问题

乱码问题：
1、读取数据时未读完整个字符
以字节流读取为例，UTF-8中汉字占3个字节，字节流每次读取一个字节，则会造成乱码，可以使用字符流来解决。
2、编码格式不一致
例：编码格式为GBK，解码格式为UTF-8，此时会造成乱码，
使用时统一格式可解决

public class FileTest {
    public static void main(String[] args) throws IOException {
        //文件编码 编码相当于加密，把看的懂得文件编码成看不懂的，解码相当于解密，把看不懂的文件解码成看得懂的
        //编码和解码使用的编码格式要一致，不然会乱码
        //UTF-8
        //GBK
        //ANSI 如果安装的时windows的简体中文系统，此时ANSI = GBK ,可以通过查看文件编码验证（可使用工具notepad++）
        File file = new File("C:\\Users\\Desktop\\test\\aa.txt");
        File file1 = new File("C:\\Users\\Desktop\\test\\aa复制.txt");
        code(file);
        code(file1);
    }
    public static void code(File srcDir) throws IOException {
        FileInputStream fileInputStream = new FileInputStream(srcDir);
        byte[] bytes = new byte[1024];
        int read = fileInputStream.read(bytes);
        //charset 设置编码格式
        System.out.println(new String(bytes,"gbk"));
        fileInputStream.close();
    }
}

字符流

一次读取一个字符
FileWriter 写入
FileReader 读取

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Desktop\\test\\aa.txt");
        File file1 = new File("C:\\Users\\Desktop\\test\\zz.txt");
        copyTxt(file,file1);
    }
    //字符流复制纯文本文件
    public static void copyTxt(File srcDir,File destDir) throws IOException {
        //字符流 写入
        FileWriter fileWriter = new FileWriter(destDir);
        //字符流 读取
        FileReader fileReader = new FileReader(srcDir);
        char[] chars = new char[1];
        int len;
        while ((len= fileReader.read(chars))!=-1){
            fileWriter.write(chars,0,len);
            //刷新缓存，将内存中读取的字符写入文件中（硬盘）
            //fileWriter.flush();
        }
        //释放资源，同时刷新缓存，将内存中读取的字符写入文件中（硬盘）
        fileReader.close();
        //释放资源
        fileWriter.close();

    }
}

缓冲流

减少IO次数，提高读写效率

public class FileTest {
    public static void main(String[] args) throws IOException {
        //字符读取缓冲流
        BufferedReader bufferedReader = new BufferedReader(new FileReader("C:\\Users\\Desktop\\test\\11.txt"));
        //字符写入缓冲流 true开启续写
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("C:\\Users\\Desktop\\test\\aa.txt",true));
        buffereder(bufferedReader, bufferedWriter);


        //字节输入缓冲流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\\Users\\Desktop\\test\\11.txt"));
        //字节输出缓冲流 true开启续写
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Desktop\\test\\aa.txt", true));
        bufferedStream(bufferedInputStream, bufferedOutputStream);
    }

    private static void buffereder(BufferedReader bufferedReader, BufferedWriter bufferedWriter) throws IOException {
        String s;
        while ((s = bufferedReader.readLine()) != null){
            bufferedWriter.write(s);
            // 换行，支持不同系统
            bufferedWriter.newLine();
        }
        //释放资源
        bufferedWriter.close();
        bufferedReader.close();
    }

    private static void bufferedStream(BufferedInputStream bufferedInputStream, BufferedOutputStream bufferedOutputStream) throws IOException {
        byte[] bytes = new byte[10];
        int read;
        while ((read = bufferedInputStream.read(bytes)) != -1){
            //将指定长度的字节写入
            bufferedOutputStream.write(bytes,0,read);
        }
        //释放资源
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

}

删除原有文件，并重新创建文件

public static File convertByteToFile(byte[] bytes, String filePath) {
        if (bytes == null) {
            return null;
        }
        BufferedOutputStream bufferedOutputStream = null;
        try {
            // 每次上传文件之前，需要先将之前的文件删除掉
            File file = new File(filePath);
            // 如果文件夹存在就不创建
            if (!file.exists()) {
                file.mkdirs();
            }
            // 只删除该文件夹下的文件，不删除文件夹
            if (file.isDirectory()) {
                for (File f : file.listFiles()) {
                    f.delete();
                }
            }
            String fileName = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date(System.currentTimeMillis())) + "upload.png";
            File fileUpload = new File(filePath + fileName);
            //父级目录
            File fileParent = fileUpload.getParentFile();
            //判断父级目录是否存在
            if (!fileParent.exists()) {
                fileParent.mkdirs();
            }
            //创建文件
            fileUpload.createNewFile();
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(fileUpload));
            bufferedOutputStream.write(bytes);
            return file;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bufferedOutputStream != null) {
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

xlsx类型文件生成

创建临时文件
File file = File.createTempFile(fileNamePrefix, “.xlsx”);
//删除文件
file.delete();

/**
     * 写入数据逻辑
     *
     * @param oneFileJSONArray   单个文件的数据
     * @param fileNamePrefix     文件名前缀
     * @param processTemplateMap 配置的加工模板
     * @return
     */
    public File createFile(JSONArray oneFileJSONArray, String fileNamePrefix, HashMap<String, String> processTemplateMap) {
        try {
            File file = File.createTempFile(fileNamePrefix, ".xlsx");
            if (oneFileJSONArray.size() == 0) {
                return file;
            }
            OutputStream os = new FileOutputStream(file);
            SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook();
            sxssfWorkbook.createSheet("sheet1");
            Sheet sheet = sxssfWorkbook.getSheetAt(0);
            //
            for (int i = 0; i < oneFileJSONArray.size(); i++) {
                //一个个实例对象
                JSONObject jsonObject = oneFileJSONArray.getJSONObject(i);
                //配置的响应参数个数
                int responseParamSize = processTemplateMap.size();
                int responseParamChangeSize = processTemplateMap.size();
                //表头行
                Row rowTitle = null;
                if (i == 0) {
                    //只有第一次进来才创建表格title
                    rowTitle = sheet.createRow(0);
                }
                //内容行
                Row row = sheet.createRow(i + 1);
                //解析配置的响应参数
                for (Map.Entry<String, String> entry : processTemplateMap.entrySet()) {
                    if (i == 0) {
                        //创建表格的title内容
                        Cell numTile = rowTitle.createCell((responseParamSize - responseParamChangeSize));
                        numTile.setCellValue(entry.getValue());
                    }
                    //填充表格的数据
                    Object values = jsonObject.get(entry.getKey());
                    Cell cell = row.createCell((responseParamSize - responseParamChangeSize--));
                    cell.setCellValue(excludeNull(values));
                }
            }
            sxssfWorkbook.write(os);
            sxssfWorkbook.close();
            os.close();
            os.flush();
            return file;
        } catch (IOException e) {
            log.error("创建xssfWorkbook出错，文件找不到:", e);
            throw new TradeDatacenterException(TradeDatacenterErrorCode.TARGET_FILE_NOT_EXIST, e.getMessage());
        } catch (Exception e) {
            log.error("创建xssfWorkbook失败:", e);
            throw new TradeDatacenterException(TradeDatacenterErrorCode.TARGET_FILE_NOT_EXIST, e.getMessage());
        }
    }
梦魇星虹
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
XLS与XLSX互相转换
10-17
XLS与XLSX互相转换，在2003的EXCEL创造的表格在2007版本中打不开的情况下，这是一个利器。
Java 开发之：POI XLS和XLSX兼容解析及单元格数据转换工具代码
醉陌浮生，乱谜浊
08-18 1007
XLS和XLSX解析//申明类型为空Workbook wb = null;//将获取到的文件转成文件流InputStream is = new FileInputStream(file);//分析获取到的文件后戳信息 if (prefix.equals(“xls”)) { wb= new HSSFWorkbook(is); } else if (pre
如何在Java中创建临时文件？
网络技术联盟站
04-19 5621
在Java程序中，有时需要创建临时文件来暂存数据或者执行某些操作。Java提供了许多方式来创建临时文件。在本教程中，我们将介绍如何使用Java标准库来创建临时文件。
Java XLS 转 XLSX
m0_49790240的博客
08-18 1589
Java XLS 转 XLSX。
Java 中使用EasyExcel实现文件导出功能，直接复制就能用
m0_54793512的博客
06-04 2054
设计到了合并单元格，直接用的注解解决的合并单元格。3·控制层：自己创建一个controller。4· service层逻辑需要自己写。5·准备的工具类：直接粘贴复制。例：这是我项目中用到的数据。1 ·添加上面两个依赖。
字节数组流byte文件
最新发布
04-25
字节数组流byte[]资源，里面包括png图片、pdf文件、xlsx、docx、txt文件
vue-以文件流-blob-的形式-下载-导出文件操作
10-14
总的来说，Vue中以文件流-Blob形式下载导出文件的关键步骤包括：设置请求响应类型为`blob`、获取文件流、构造Blob对象、生成URL并触发下载。为了确保良好的跨浏览器兼容性，可能需要针对不同的浏览器实现不同的下载...
Angular利用HTTP POST下载流文件的步骤记录
10-15
2. 处理接收到的文件流，创建Blob对象并指定正确的MIME类型。 3. 创建一个临时下载URL，并使用`<a>`标签模拟点击触发下载。 4. 记得清理`createObjectURL`生成的URL，避免内存泄漏。 这种方法不仅适用于Angular，还...
Java Poi流 根据Word模板插入相应的文本、表格和图片，生成新的Word报告
09-27
Java POI库是Apache软件基金会开发的一个开源项目，专门用于读写Microsoft Office格式的文件，如Word（.doc和.docx）、Excel（.xls和.xlsx）等。在本主题中，我们将深入探讨如何使用Java POI流处理Word模板，插入...
java读取excel文件流，测试.xlsx
11-13
本博需要的测试文件，
java实现excel表格文件的复制
09-30
java实现excel表格文件的复制，测试可用，将excel表格的表头和内容拷贝到新表中
java实现生成Excel（默认.xls，可自己修改文件类型）文件程序
12-01
java实现生成Excel（.xls）文件程序，并封装了从浏览器下载的方法，压缩包内含有使用说明，希望大神们指教，互相学习
java读写xlsx文件
04-09
java利用poi读写excel2010(xlsx)文件 环境：eclipse3.7.2，jre6，excel2010
使用poi将xls转为xlsx，所有样式完美转换
09-11
使用poi将xls格式的Excel转为xlsx，文件中的所有样式都可以完美转换，例如合并栏、背景和单元格样式等。Java源码
JAVA临时文件的使用
qq_53679247的博客
07-02 2875
临时文件是在计算机系统中用于临时存储数据的文件。它们通常用于存储临时性的数据、中间计算结果或需要在程序执行期间暂时保存的数据。临时文件具有以下特点：1. 临时性：临时文件通常只在特定的时间段内存在，并在使用后被删除或清理。2. 存储临时数据：它们用于存储程序执行期间需要临时保存的数据，如缓存数据、临时计算结果等。3. 临时文件夹：操作系统提供了一个专门用于存储临时文件的文件夹，通常称为临时文件夹或临时目录。
java 后台 Excel 文件生成后转化为字节流
热门推荐
程介元
05-06 3万+
Java 后台 Excel 文件生成后转化为字节流java excel 使用 poi组件， HSSFWorkbook workBook = new HSSFWorkbook(); 对于workBook生成字节流，很容易发现有个workBook .getBytes()，但是，是不可用的，下载以后打不开， 如果下载，正确的写法为 workBook.write(response.getOutputStr
maven项目下上传xlsx文件成inputstream流后用WorkbookFactory转换报错
何小杰的博客
02-14 6559
因为java项目需要因此需要 html提交xlsx文件 controller层能接受MultipartFile文件，并转换成inputstream流扔给business（service）层处理 business（service）层将xlsx的信息全部获取并返回到前台 但是在前台上传xlsx文件时，一直返回信息时500，即提示服务器内部错误。 于是在断点的情况下，博主确认controller能接...
java实现xls转换为xlsx
h18300103614的博客
05-10 4618
工作所需，要把xls转换为xlsx，参考了Java 复制 Excel 工作表 而改造的，亲测有效。 jdk1.5及以上 所需jar包：Spire.Office.jar 或 Spire.Xls.jar jar包下载：https://www.e-iceblue.cn/ 冰蓝科技，很不错的网站，值得研究研究。 下载步骤在 java为word添加水印，图片水印和文字水印 或者要送我分也行，嘿嘿：Spire.Office.jar 代码 import com.spire.xls.FileFormat; import c
java Excel导出 xlsx格式（超简单）
qq_40997700的博客
06-26 1万+
XSSF:xlsx HSSF:xls HSSF是POI工程对Excel 97(-2007)文件操作的纯Java实现 XSSF是POI工程对Excel 2007 OOXML (.xlsx)文件操作的纯Java实现 我之前是导出xls版本的，后来改成xlsx版本的，想切换版本就把全文的HSSF和XSSF替换了就可以了，可能会有极个别的方法不适用，自行百度一下就可以了 package com.wttec...
java 生成excel 文件流
05-10
Java可以使用Apache POI库来生成Excel文件流。下面是一个简单的示例代码： ``` import java.io.FileOutputStream; import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.xssf.usermodel....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值