java 文件流的一些常用操作

最新推荐文章于 2024-08-13 07:30:00 发布
最新推荐文章于 2024-08-13 07:30:00 发布
阅读量236 收藏 1
点赞数
分类专栏： JAVA 文章标签： Java文件流 Java文件操作 I/O
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36161345/article/details/92985291
版权

package com.cn.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;

/**
 * 文件及文件夹操作工具类
 * 文件中\r\n为换行
 * @author Administrator
 *
 */
public class FileUtils {
    
    /**
     * FileOutputStream 文件写入内容
     * @param filePath    文件路径
     * @param content    文件内容
     */
    public void fileOutput_FileOutputStream(String filePath,String content){
        try {
            File file=new File(filePath);    //创建file
            if(!file.exists()){                //判断文件是否存在
                file.createNewFile();        //创建文件
            }
            //创建文件输出流,参数true为追加内容，若无则是覆盖内容
            FileOutputStream out = new FileOutputStream(file,true);    
            byte[] contentInBytes = content.getBytes("utf-8");        //内容转化
            out.write(contentInBytes);    //写入内容
            //关闭流
            out.flush();  
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
    
    /**
     * FileWriter    文件写入内容
     * @param filePath    文件路径
     * @param content    文件内容
     */
    public void fileOutput_FileWriter(String filePath,String content){
        try {
            File file=new File(filePath);    //创建file
            if(!file.exists()){                //判断文件是否存在
                file.createNewFile();        //创建文件
            }
            //参数true为追加内容，若无则是覆盖内容
            FileWriter fw = new FileWriter(file,true);
            fw.write(content);
            //关闭流
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * BufferedWriter    文件写入内容
     * @param filePath    文件路径
     * @param content    文件内容
     */
    public void fileOutput_BufferedWriter(String filePath,String content){
        try {
            File file=new File(filePath);    //创建file
            if(!file.exists()){                //判断文件是否存在
                file.createNewFile();        //创建文件
            }
            //参数true为追加内容，若无则是覆盖内容
            BufferedWriter bw = new BufferedWriter(new FileWriter(file,true));
            bw.write(content); 
            //关闭流
            bw.flush();  
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
    
    /**
     * PrintWriter    文件写入内容
     * @param filePath    文件路径
     * @param content    文件内容
     */
    public void fileOutput_PrintWriter(String filePath,String content){
        try {
            File file=new File(filePath);    //创建file
            if(!file.exists()){                //判断文件是否存在
                file.createNewFile();        //创建文件
            }
            //参数true为追加内容，若无则是覆盖内容
            PrintWriter pw = new PrintWriter(new FileWriter(file,true));
            pw.println(content);      // 换行
            //pw.print(content);      // 不换行
            //关闭流
            pw.flush();
            pw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * PrintStream    文件写入内容
     * @param filePath    文件路径
     * @param content    文件内容
     */
    public void fileOutput_PrintStream(String filePath,String content){
        try {
            File file=new File(filePath);    //创建file
            if(!file.exists()){                //判断文件是否存在
                file.createNewFile();        //创建文件
            }
            //参数true为追加内容，若无则是覆盖内容
            PrintStream pw=new PrintStream(new FileOutputStream(file,true));
            pw.println(content);
            //关闭流
            pw.flush();
            pw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // System.out.write()方法是字符流,System.out.println()方法是字节流
    
    /**
     * FileInputStream 读取文件内容并写入指定路径文件中
     * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件
     * @param filePath 文件路径
     * @param newFilePath 要写入的路径
     */
    public void fileInput_FileInputStream(String filePath,String newFilePath){
        try {
            File file=new File(filePath);                //创建file
            if(!file.exists() || file.isDirectory()){    //判断文件是否存在或者是目录
                throw new FileNotFoundException();        //抛出异常
            }
            InputStream in = new FileInputStream(file);                         // 读取的文件
            FileOutputStream out = new FileOutputStream(newFilePath,true);    // 指定要写入的文件

            /*// 一次读一个字节
            int tempbyte;  
            while ((tempbyte = in.read()) != -1) {  
                out.write(tempbyte);
                //System.out.write(tempbyte);  
            }  */
            
            // 一次读多个字节
            int byteread = 0;
            byte[] tempbytes = new byte[1024];
            while ((byteread = in.read(tempbytes)) != -1) { 
                 out.write(tempbytes, 0, byteread);
                //System.out.write(tempbytes, 0, byteread);  
            }
            
            //关闭流
            out.flush();
            out.close();
            in.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }  

    }
    
    /**
     * InputStreamReader 读取文件内容并写入指定路径文件中
     * 以字符为单位读取文件，常用于读文本，数字等类型的文件 
     * @param filePath    文件路径
     * @param newFilePath 要写入的路径
     */
    public void fileInput_InputStreamReader(String filePath,String newFilePath){
        try {
            File file=new File(filePath);                //创建file
            if(!file.exists() || file.isDirectory()){    //判断文件是否存在或者是目录
                throw new FileNotFoundException();        //抛出异常
            }
            Reader reader = new InputStreamReader(new FileInputStream(file)); 
            // 指定要写入的文件
            Writer writer = new OutputStreamWriter(new FileOutputStream(newFilePath,true));
            // 一次读一个字节
            int tempchar;  
            while ((tempchar = reader.read()) != -1) {  
                //System.out.print(tempchar);  
                writer.write(tempchar);
            }  
            

            /*// 一次读多个字节
            char[] tempchars = new char[1024];  
            int charread = 0;  
            // 读入多个字符到字符数组中，charread为一次读取字符数  
            while ((charread = reader.read(tempchars)) != -1) {  
                //System.out.print(tempchar);  
                writer.write(tempchars);
            }*/
            
            //关闭流
            writer.flush();
            writer.close();
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * BufferedReader 读取文件内容并写入指定路径文件中
     * 以行为单位读取文件，常用于读面向行的格式化文件
     * @param filePath 文件路径
     * @param newFilePath 要写入的路径
     */
    public void fileInput_BufferedReader(String filePath,String newFilePath){
        try {
            File file=new File(filePath);                //创建file
            if(!file.exists() || file.isDirectory()){    //判断文件是否存在或者是目录
                throw new FileNotFoundException();        //抛出异常
            }
            BufferedReader reader = new BufferedReader(new FileReader(file));
            BufferedWriter writer = new BufferedWriter(new FileWriter(newFilePath,true));
            String tempString = null;  
            int line = 1;  
            // 一次读入一行，直到读入null为文件结束  
            while ((tempString = reader.readLine()) != null) { 
                //System.out.println(tempString);
                writer.write(tempString);
                writer.newLine();
            }  
            //关闭流
            writer.flush();
            writer.close();
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }  
    }
    
    /**
     * 文件复制
     * @param targetFile    目标文件
     * @param newFile        新文件
     * @throws IOException    文件流异常
     */
    public void copyFile(String targetFile,String newFile) throws IOException{
        FileInputStream in=new FileInputStream(targetFile);    //创建输入流（目标文件）
        File file=new File(newFile);                        //新文件
        if(!file.exists()){            //判断新文件是否存在
            file.createNewFile();    //创建新文件
        }
        FileOutputStream out=new FileOutputStream(file);    //创建输出流
        int c;                            //标识符
        byte buffer[]=new byte[1024];    //创建byte数组
        while((c=in.read(buffer))!=-1){    //循环读取输入流
            for(int i=0;i<c;i++)        //读取到的内容写入输出流
                out.write(buffer[i]);        
        }
        out.close();    //关闭输入流
        in.close();        //关闭输出流
    }
    
    /**
     * 文件重命名
     * @param path        路径
     * @param oldname    原文件名
     * @param newname    新文件名
     */
    public void renameFile(String path,String oldName,String newName){
        if(!oldName.equals(newName)){                //新的文件名和以前文件名不同时,才有必要进行重命名
            File oldfile=new File(path+"/"+oldName);//原文件
            File newfile=new File(path+"/"+newName);//新文件
            if(newfile.exists())                    //若在该目录下已经有一个文件和新文件名相同，则不允许重命名
                System.out.println(newName+"已经存在！");
            else{
                oldfile.renameTo(newfile);            //文件重命名
            }
        }         
    }

    /**
     * 文件移动
     * @param filename    文件名
     * @param oldpath    原路径
     * @param newpath    新路径
     * @param cover        是否覆盖重名文件
     */
    public void changeDirectory(String filename,String oldpath,String newpath,boolean cover){
        if(!oldpath.equals(newpath)){                    //新的路径和以前路径不同时,才有必要进行移动
            File oldfile=new File(oldpath+"/"+filename);//原文件
            File newfile=new File(newpath+"/"+filename);//新文件
            if(newfile.exists()){                        //若在待转移目录下，已经存在待转移文件
                if(cover){                                //覆盖
                    oldfile.renameTo(newfile);            //移动
                }else{
                    System.out.println("在新目录下已经存在："+filename);
                }
            }
            else{                                        //不存在同名文件
                oldfile.renameTo(newfile);                //移动
            }
        }       
    }
    
    /**
     * 创建文件
     * @param path            路径
     * @param fileName        文件名
     * @throws IOException    文件流异常
     */
    public void createFile(String path,String fileName) throws IOException{
        File file=new File(path+"/"+fileName);
        if(!file.exists())
            file.createNewFile();
    }
    
    /**
     * 创建文件夹
     * @param path 路径
     */
    public void createDir(String path){
        File dir=new File(path);
        if(!dir.exists())
            dir.mkdir();
    }
    
    /**
     * 删除文件
     * @param path            路径
     * @param fileName        文件名
     */
    public void delFile(String path,String fileName){
         File file=new File(path+"/"+fileName);
         if(file.exists()&&file.isFile())
             file.delete();
    }
    
    /**
     * 删除文件夹
     * @param path    路径
     */
    public void delDir(String path){
        File dir=new File(path);
        if(dir.exists()){
            File[] tmp=dir.listFiles();
            for(int i=0;i<tmp.length;i++){
                if(tmp[i].isDirectory()){
                    delDir(path+"/"+tmp[i].getName());
                }
                else{
                    tmp[i].delete();
                }
            }
            dir.delete();
        }
    }
    
}
 

菜鸟-编程
关注
专栏目录
JAVA 文件常用流操作.zip
05-02
这个名为"JAVA 文件常用流操作.zip"的压缩包可能包含了各种关于Java中文件流使用的示例和教程。让我们深入探讨一下Java中的文件流操作。 首先，Java中的文件操作主要通过IO（Input/Output）流来实现。IO流分为两大...
java文件流
仙道Bob的专栏
04-26 1707
【代码】java文件流。
Java的流(Stream)、文件(File)和IO
weixin_39158966的博客
04-25 1847
因为几乎所有的字符流都只能连接在其它流上，而基本上节点流（低级流）都是字节流，由于 InputStreamReader & OutputStreamWriter 可以连接字节流，而其本身又是字节流，所以可以起到将字节流与字符流“对接”的作用。可以称之为“转换流”。：标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法，该方法会连续读取若干字符，当读取到换行符时，将之前读取的字符以字符串形式返回（若读取不到换行符，可能会阻塞），若返回值为 null 时，表示流的末尾。
java——IO流
最新发布
Good_Starry的博客
08-13 1013
java——IO流：文件；常用文件操作；io流的分类；节点流和处理流；对象流；转换流；打印流；Properties
Java中文件流的基本用法
Kristabo的博客
03-25 8162
1.文件流是什么？ Java中的文件流，即以文件为主要对象，进行数据的输入或输出。 2.文件流包括什么 Java中，文件流包括四类：FileInputStream、FileOutPutStream、FileReader、FileWriter。而其中前两者又属于字节流，即以字节为读写单位的流；后两者属于字符流，即以字符为读写单位的流。关于区分字符流和字节流的主要特征：以Stream结尾的属于字节流，以Reader/Writer结尾的属于字符流。 3.基本使用方法 （1）流的创建 四个类都是以创建实
java文件操作-IO流
qq_53464269的博客
03-03 3223
文件操作
Java笔记（二十四）：IO流、文件、Input/OutputStream、Reader、Writer、节点流处理流、序列化反序列化、标准输入输出流、转换流、打印流、Properties类
欢迎~
07-29 610
①//根据路径构建一个File对象；②//根据父目录文件+子路径构建一个File对象；③//根据父目录+子路径构建一个File对象；④ 使用文件对象名.createNewFile()创建新文件。节点流可以从一个特定的数据源【数据源就是存放数据的地方】读写数据，常见节点流如FileReader、FileWriter；节点流是比较底层的流（直接对数据进行操作）BufferedInputStream是字节流，在创建BufferedInputStream时，会创建内部缓冲区数组。/**
java处理文件常用操作
03-13
在Java后端中处理文件通常涉及到文件的读取、写入、删除以及可能的文件流处理等操作。
Java使用FileInputStream流读取文件示例详解
08-18
JAVA中针对文件的读写操作设置了一系列的流，其中主要有FileInputStream、FileOutputStream、FileReader、FileWriter四种最为常用的流。 二、FileInputStream 1. FileInputStream概念 FileInputStream流被称为文件...
Java流(文件读写操作)
06-14
### Java流(文件读写操作) #### 一、流的分类 Java中处理文件和数据时，使用流的概念来进行操作。根据不同的标准，流可以分为几种类型。 ##### 1. 按数据流动方向 - **输入流**：主要用于从数据源读取数据。输入...
Java IO流常用字节字符流原理解析
08-19
"Java IO流常用字节字符流原理解析" Java IO流中有两种基本的流类型：字节流和字符流。在Java IO流中，字节流是指以byte为单位进行操作的流，而字符流是指以char为单位进行操作的流。今天，我们将主要介绍Java IO流...
Java文件操作与流处理
qq_61635026的博客
07-29 1495
在计算机中，文件是用于存储数据的基本单位。它可以包含文本、图像、音频、视频或其他类型的数据。文件可以用于保存程序代码、用户数据、操作系统配置等内容。每个文件都有一个唯一的名称，通过这个名称可以在计算机系统中找到和访问文件。
【Java】文件流
2301_76903988的博客
03-09 739
文件流、创建文件对象、获取文件的相关信息、目录操作和文件删除
javaIO流之文件流
恒二哥的博客
05-18 1898
在 IO 操作中，文件的操作相对来说是比较复杂的，但也是使用频率最高的部分，我们几乎所有的项目中几乎都躺着一个叫做 FileUtil 或者 FileUtils 的工具类。java.io.File 类是专门对文件进行操作的类，注意只能对文件本身进行操作，不能对文件内容进行操作，想要操作内容，必须借助输入输出流。File 类是文件和目录的抽象表示，主要用于文件和目录的创建、查找和删除等操作。怎么理解上面两句话？其实很简单！
Java文件输入输出流
m0_74198476的博客
05-28 3546
Java文件输入输出流
Java之文件流(26个Demo)
nuist_NJUPT的博客
08-06 1922
Java文件流主要包括字节流和字符流，字符流本质上就是字节流+编码表，下面通过26个案例介绍了字符流和字节流对文件的操作，包括创建文件路径，文件的读取和写入，文件判断，文件删除，遍历文件，文件复制，文件的编码与解码，文件异常处理以及对象序列化和反序列化等。目录1-File类的三个构造方法2-File类的创建功能3-File类判断和获取功能4-File类删除功能5-简单递归6-遍历目录打印绝对路径7-字节流写数据的三种方式8-字节流读数据的方式9-字节流复制文本文件10-字节流读数据(一次读一组)11-字节流
Java文件流
qq_51497975的博客
06-30 5823
这篇文章主要用来介绍Java文件流的一些操作，相信很多小伙伴在文件操作上还是处于懵懵懂懂的状态，没关系相信看了我这篇文章，肯定会有所收获 说明 其实Java的流操作有很多，文件流只是其中一部分，但是他们的操作方法大同小异，而且我们平时用到的最多的也就是文件流，所以我这里就只介绍文件流 字节输入输出流 InputStream 和 OutputStream 是所有字节输入输出流的父类，InputStream 是输入流，OutputStream是输出流。FileInputStream 和 FileOutputSt
java——io文件流（详细、全面、快速掌握）
m0_57957187的博客
12-28 1290
本篇主要对java中的io流进行总结，以复制文件操作为例对文件输入流(FileInputStream)、输出流(FileOutputStream)以及缓冲区的使用：BufferedInputStream、BufferedOutputStream以及字符输入流(BufferedReader)输出流(PrintWriter)进行讲解，最后讲解了序列化：将对象输出为文件和反序列化：将文件读取为对象进行了演示和讲解；以下代码可以直接复制到idea中运行，便于理解掌握；
【Java从入门到精通】Java 流(Stream)、文件(File)和IO
RL2698853114的博客
05-03 1438
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。
Java输入输出流与文件操作详解
"程序设计第15章主要探讨了输入输出流和文件操作，涵盖了Java中的I/O流体系、字符流、字节流、目录和文件管理等多个关键知识点。" 在Java程序设计中，输入输出流（I/O流）是进行数据传输的基础，它们允许程序与外部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值