精华内容
下载资源
问答
  • java写入文件不覆盖写入_Java写入文件–用Java写入文件的4种方法
    千次阅读
    2020-07-19 08:54:52

    java写入文件不覆盖写入

    Java provides several ways to write to file. We can use FileWriter, BufferedWriter, java 7 Files and FileOutputStream to write a file in Java.

    Java提供了几种写入文件的方法。 我们可以使用FileWriterBufferedWriter ,java 7 FilesFileOutputStream用Java编写文件。

    Java写入文件 (Java Write to File)

    Let’s have a brief look at four options we have for java write to file operation.

    让我们简要地看一下java写入文件操作的四个选项。

    1. FileWriter: FileWriter is the simplest way to write a file in Java. It provides overloaded write method to write int, byte array, and String to the File. You can also write part of the String or byte array using FileWriter. FileWriter writes directly into Files and should be used only when the number of writes is less.

      FileWriter :FileWriter是用Java编写文件的最简单方法。 它提供了重载的write方法,可以将int,字节数组和String写入File。 您也可以使用FileWriter编写String或byte数组的一部分。 FileWriter直接写入文件,仅在写入次数较少时才应使用。
    2. BufferedWriter: BufferedWriter is almost similar to FileWriter but it uses internal buffer to write data into File. So if the number of write operations is more, the actual IO operations are less and performance is better. You should use BufferedWriter when the number of write operations is more.

      BufferedWriter :BufferedWriter与FileWriter几乎相似,但是它使用内部缓冲区将数据写入File。 因此,如果写入操作的数量更多,则实际的IO操作会更少,而性能会更好。 当写入操作的数量更多时,应使用BufferedWriter。
    3. FileOutputStream: FileWriter and BufferedWriter are meant to write text to the file but when you need raw stream data to be written into file, you should use FileOutputStream to write file in java.

      FileOutputStream :FileWriter和BufferedWriter旨在将文本写入文件,但是当您需要将原始流数据写入文件时,应使用FileOutputStream在Java中写入文件。
    4. Files: Java 7 introduced Files utility class and we can write a file using its write function. Internally it’s using OutputStream to write byte array into file.

      Files :Java 7引入了Files实用程序类,我们可以使用其write函数编写文件。 在内部,它使用OutputStream将字节数组写入文件。

    Java写入文件示例 (Java Write to File Example)

    Here is the example showing how we can write a file in java using FileWriter, BufferedWriter, FileOutputStream, and Files in java.

    这是显示如何在Java中使用FileWriter,BufferedWriter,FileOutputStream和Files编写文件的示例。

    WriteFile.java

    WriteFile.java

    package com.journaldev.files;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class WriteFile {
    
        /**
         * This class shows how to write file in java
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) {
            String data = "I will write this String to File in Java";
            int noOfLines = 10000;
            writeUsingFileWriter(data);
            
            writeUsingBufferedWriter(data, noOfLines);
            
            writeUsingFiles(data);
            
            writeUsingOutputStream(data);
            System.out.println("DONE");
        }
    
        /**
         * Use Streams when you are dealing with raw data
         * @param data
         */
        private static void writeUsingOutputStream(String data) {
            OutputStream os = null;
            try {
                os = new FileOutputStream(new File("/Users/pankaj/os.txt"));
                os.write(data.getBytes(), 0, data.length());
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        /**
         * Use Files class from Java 1.7 to write files, internally uses OutputStream
         * @param data
         */
        private static void writeUsingFiles(String data) {
            try {
                Files.write(Paths.get("/Users/pankaj/files.txt"), data.getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * Use BufferedWriter when number of write operations are more
         * It uses internal buffer to reduce real IO operations and saves time
         * @param data
         * @param noOfLines
         */
        private static void writeUsingBufferedWriter(String data, int noOfLines) {
            File file = new File("/Users/pankaj/BufferedWriter.txt");
            FileWriter fr = null;
            BufferedWriter br = null;
            String dataWithNewLine=data+System.getProperty("line.separator");
            try{
                fr = new FileWriter(file);
                br = new BufferedWriter(fr);
                for(int i = noOfLines; i>0; i--){
                    br.write(dataWithNewLine);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    br.close();
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * Use FileWriter when number of write operations are less
         * @param data
         */
        private static void writeUsingFileWriter(String data) {
            File file = new File("/Users/pankaj/FileWriter.txt");
            FileWriter fr = null;
            try {
                fr = new FileWriter(file);
                fr.write(data);
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                //close resources
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

    These are the standard methods to write a file in java and you should choose any one of these based on your project requirements. That’s all for Java write to file example.

    这些是用Java编写文件的标准方法,您应根据项目要求选择其中一种。 这就是Java写入文件示例的全部内容。

    GitHub Repository. GitHub存储库中签出更多Java IO示例。

    翻译自: https://www.journaldev.com/878/java-write-to-file

    java写入文件不覆盖写入

    更多相关内容
  • Java使用字节流写入写出图片或文件经典代码
  • 下面小编就为大家带来一篇Java中IO流文件读取、写入和复制的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java实现文件写入——IO

    千次阅读 2021-02-12 14:52:34
    输入输出的重要性:输入和输出功能...Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类...

    输入输出的重要性:

    输入和输出功能是Java对程序处理数据能力的提高,Java以流的形式处理数据。流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。

    程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“读入”与“写入”操作的流类。

    Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。

    (一)解析文件处理的奥秘

    1、学习使用文件类 : File类

    File类用于封装系统的文件和目录的相关信息。在该类中定义了一些与平台无关的方法来操作文件。例如文件的大小、修改时间、文件路径等。

    创建 File 对象可以通过下面3种方式:

    方法1:方法2:方法3:

    new File(String pathName)

    File file = new File(“E://1.txt”)

    new File(String parent , String child)

    parent :父抽象路径名;child:子路径名字符串

    2、如何获取文件信息

    File 类是对文件和文件夹的抽象,包含了对文件和文件夹的多种属性和操作方法。File类的常用方法如下表:

    返回方法说明

    String

    getName

    获取文件名称

    String

    getParent

    获取文件的父路径字符串

    String

    getPath

    获取文件的相对路径字符串

    String

    getAbsolutePath

    获取文件的绝对路径字符串

    boolean

    exists

    判断文件或者文件夹是否存在

    boolean

    isFile

    判断是不是文件类型

    boolean

    isDirectory

    判断是不是文件夹类型

    boolean

    delete

    删除文件或文件夹,如果删除成功返回结果为true

    boolean

    mkdir

    创建文件夹,创建成功返回true

    boolean

    setReadOnly

    设置文件或文件夹的只读属性

    long

    length

    获取文件的长度

    long

    lastModified

    获取文件的最后修改时间

    String[ ]

    list

    获取文件夹中的文件和子文件夹的名称,并存放到字符串数组中

    下面通过实例介绍File类获取文件信息

    1 packagecom.zch.io;2

    3 importjava.io.File;4 importjava.util.Date;5

    6 /**

    7 * 在src根目录下创建FileInfo类,在该类的主方法中创建文件对象,通过File类的相关方法,获取文件的相关信息8 *9 *@authorzch10 *11 */

    12 public classFileInfo {13 public static voidmain(String[] args) {14

    15 String filePath = "src/com/zch/io/FileInfo.java";16 //根据指定路径创建文件对象

    17 File file = newFile(filePath);18 System.out.println("文件名称:" +file.getName());19 System.out.println("文件是否存在:" +file.exists());20 System.out.println("文件的相对路径:" +file.getPath());21 System.out.println("文件的绝对路径:" +file.getAbsolutePath());22 System.out.println("是否为可执行文件:" +file.canExecute());23 System.out.println("文件可以读取:" +file.canRead());24 System.out.println("文件可以写入:" +file.canWrite());25 System.out.println("文件上级路径:" +file.getParent());26 System.out.println("文件大小:" + file.length() + "B");27 System.out.println("文件最后修改时间:" + newDate(file.lastModified()));28 System.out.println("是否文件类型:" +file.isFile());29 System.out.println("是否为文件夹:" +file.isDirectory());30

    31 }32

    33 }

    运行结果如下:

    文件名称:FileInfo.java

    文件是否存在:true

    文件的相对路径:src\com\zch\io\FileInfo.java

    文件的绝对路径:D:\Java\IO\src\com\zch\io\FileInfo.java

    是否为可执行文件:true

    文件可以读取:true

    文件可以写入:true

    文件上级路径:src\com\zch\io

    文件大小:1195B

    文件最后修改时间:Sat Sep 09 21:30:10 CST 2017

    是否文件类型:true

    是否为文件夹:false

    在使用delete()方法删除File对象时,如果删除的对象是目录,该目录中的内容必须为空。

    (二)使用字节输入输出流

    字节流用于处理二进制数据的读取和写入,它以字节为单位,InputStream类和OutputStream类是字节流的抽象类,它们定义了数据流读取和写入的基本方法。各个子类会依其特点实现或覆盖这些方法。

    1、字节数入流抽象类InputStream

    InputStream 类是字节输入流的抽象类,定义了操作输入流的各种方法,这些方法如表:

    返回方法说明

    int

    available()

    返回当前输入流的数据读取方法可以读取的有效字节数量

    Abstract int

    read()

    从当前数据流中读取一个字节。若已达到流结尾,则返回-1

    int

    read(byte[ ] bytes)

    从当前输入流读取一定的byte数据,并存取在数组中,然后返回读取的byte数据的数量,若已到达流结尾,则返回-1。

    void

    reset()

    将当前的输入流重新定位到最后一次调用mark()方法时的位置

    void

    mark(int readlimit)

    在当前输入流中做标记位置,当调用reset()方法时将返回到该位置,从标记位置开始,到再读入readlimit个字符为止,这个标记都维持有效。

    Boolean

    markSupported()

    测试当前输入流是否支持mark()和reset()方法,只要其中一个不支持,则返回false

    long

    skip(long n)

    跳过和丢弃当前输入的n个字节数据

    void

    close()

    关闭当前输入流,并释放任何与之相关联的系统资源

    InputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。下面通过实例如何使用InputStream从控制台获取用户输入的数据信息。

    1 packagecom.zch.io;2

    3 importjava.io.IOException;4 importjava.io.InputStream;5

    6 /**

    7 * 创建InputStream实例inp,并将其赋值为System类的in属性,定义为控制台输入流,从inp输入流中获取字节信息,8 * 用这些字节信息创建字符串,并将其在控制台上输出。9 *@authorzch10 *11 */

    12 public classInputMessage {13 public static voidmain(String[] args) {14 InputStream inp =System.in;15

    16 byte[] bytes = new byte[1024];17

    18 try{19 while(inp.read() != -1){20 //根据用户输入的信息创建字符串

    21

    22 String str = newString(bytes).trim();23

    24 }25 inp.close(); //关闭流

    26

    27 } catch(IOException e) {28 //TODO Auto-generated catch block

    29 e.printStackTrace();30 }31

    32 }33 }34

    2、字节输出流抽象类OutputStream类

    OutputStream定义了输出流的各种方法,如下表:

    返回方法说明

    void

    write(byte[ ] b)

    将byte[ ] 数组中的数据写入当前输出流

    void

    write(byte[] b ,int off, int len)

    将byte[ ]数组下标off开始的len长度的数据写入当前输出流

    Abstract void

    write(int b)

    写入一个byte数据到当前输出流

    void

    flush()

    刷新当前输出流,并强制写入所有缓冲的字节数据

    void

    close()

    关闭当前输出流

    和InputStream类一样,OutputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。

    packagecom.zch.io;importjava.io.IOException;importjava.io.OutputStream;/*** 创建OutputStream实例out,并将其赋值为System.out标准输出流。通过write()方法向流写入数据。

    *@authorzch

    **/

    public classOutputData {public static voidmain(String[] args) {

    OutputStream output= System.out; //实例化OutputStream对象

    byte[] bytes = "使用OutputStream输出流在控制台输出字符串\n".getBytes(); //创建bytes数组

    try{

    output.write(bytes);

    bytes= "输出内容:\n".getBytes();

    output.write(bytes);//向流中写入数据

    bytes= "Java数据交互管道——IO流 \n".getBytes();

    output.write(bytes);

    output.close();

    }catch(IOException e) {//TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    输出结果如下:

    使用OutputStream输出流在控制台输出字符串

    输出内容:

    Java数据交互管道——IO流

    3、文件字节输入流类 : FileInputStream类

    文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类,并实现了读取输入流的各种方法。

    创建文件字节输入流创建的构造方法语法如下:

    语法1:以File对象为参数创建FileInputStream实例

    new FileInputStream(File file)

    语法2:以文件对象的绝对路径为参数创建FIleInputStream实例

    new FileInputStream(String filepath)

    4、文件字节输出流类:FileOutputStream

    文件字节输出流关联指定文件路径的文件,数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类,并实现OutputStream类的各种方法。

    文件字节输出流的构造方法语法如下:

    语法1:以File对象为参数创建FileOutputStream实例

    new FileOutputStream(File file)

    语法2:以文件对象的绝对路径为参数创建FIleOutputStream实例

    new FileOutputStream(String filepath)

    下面通过实例介绍文件的写入和读取:

    package com.zch.io;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.FileOutputStream;

    import java.io.IOException;

    /**

    * 创建OutputStream实例out,并将其赋值为System.out标准输出流,通过write方法向流中写入数据

    *

    * @author zch

    *

    */

    public class FileCreate {

    public static void main(String[] args) {

    File file = new File("D:/", "word.txt"); //创建文件对象

    try {

    if (!file.exists()) {//如果文件不存在则新建文件

    file.createNewFile();

    }

    FileOutputStream output = new FileOutputStream(file);

    byte[] bytes = "Java数据交流管道——IO流".getBytes();

    output.write(bytes);//将数组的信息写入文件中

    output.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    try {

    FileInputStream input = new FileInputStream(file);

    byte[] bytes2 = new byte[1024];

    int len = input.read(bytes2);

    System.out.println("文件中的信息是:" + new String(bytes2, 0, len));

    input.close();

    } catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    (三) 使用字符输入输出流

    字符输入输出流 与 字节输入输出流有相同的功能,但传送数据的方式不一样,字节流以字节为单位传送数据,可以使任何类型的数据,例如文本、音频、视频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。使用字符输入输出流的好处是,当读取中文时不会出现乱码问题,而使用字节输入输出流时,却不能保证这一点。

    1、字符输入流抽象类:Reader类

    该类定义了操作字符输入流的方法,如下表:

    返回方法说明

    boolean

    ready()

    判断此数据流是否准备好

    int

    read()

    读入一个字符,若已读到流结尾,则返回值为-1

    int

    read(char[ ])

    读取一些字符到char[ ]数组内,并返回所读入的字符的数量,若已到达流结尾,则返回-1

    Abscract int

    read(char[ ] chars,int off,int len)

    读取一些字符到char[ ]数组下标从off开始到off+len的位置,并返回所读入的字符的数量,若已到达流结尾,则返回-1;

    void

    reset()

    将当前输入流重新定位到最后一次mark()方法时的位置

    void

    mark(int readLimit)

    将当前输入流中做标记,当调用reset方法时将返回到该位置,从标记位置开始,到再读入readLimit个字符为止,这个标记都维持有效

    boolean

    markSupported

    测试当前输入流是否支持mark()方法和reset()方法。只要有一个方法不支持,则返回-1

    long

    skip(long n)

    跳过参数n指定的字符数量,并返回所跳过字符的数量

    Abstract void

    close()

    关闭字符输入流,并释放与之关联的所有资源

    2、字符输出流类Writer类

    Writer 类主要是用于解决字符输入流的类,其地位与Reader类在输入流的地位和作用是相同的,也是所有字符输出流的流类。

    Writer类的主要方法如下:

    返回

    方法

    说明

    void

    write(char[ ] cbuf)

    将字符数组的数据写入字符输出流

    Abstract void

    write(char[ ] cbuf int off ,int len)

    将字符数组从下标off 开始向输入流写入长度为len的数据

    void

    write(int c )

    向字符输入流中写入一个字符数据

    void

    write(String str )

    向输入流中写入一个字符串数据

    void

    write(String str , int off ,int len)

    向输入流中写入一个字符串从off 开始长度为len的数据

    Abstract void

    flush()

    刷新当前输出流,并强制写入所有缓冲区的字节数据

    void

    close()

    向输出流中写入缓冲区的数据,然后关闭当前输出流,释放所有与当前输出流相关联的系统资源

    3、文件字符输入流FileReader

    文件字符输入流与文件字节输入流的功能相似,但是传送数据的方式不一样,字节流以字节为单位传送数据,可以使文本、视频、音频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。

    创建字符输入流常用的构造方法:

    语法1:

    new FileReader(File file);

    语法2:

    new FileReader(String path);

    下面通过实例介绍FileReader类读取指定磁盘文件的内容。

    package com.zch.io;

    import java.io.File;

    import java.io.FileReader;

    public class FileInAndOut {

    public static void main(String[] args) {

    //定义指定磁盘的文件的File对象

    File file = new File("D://word.txt");

    if(! file.exists()){

    System.out.println("对不起,不包含指定路径的文件");

    }else{

    //根据指定路径的File对象创建FileReader对象

    try {

    FileReader fr = new FileReader(file);

    char[] data = new char[23];//定义char数组

    int length = 0;

    while((length = fr.read(data))>0){//循环读取文件中的数据

    String str = new String(data,0,length);//根据读取文件的内容创建String 对象

    System.out.println(str);//输出读取内容

    }

    fr.close();//关闭流

    } catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    运行结果如下图:

    901ed501932e19b9eb571e5d8285d1cf.png

    9816a55aacc4ae52d52b69b7511e5421.png

    4、文件字符输出流FileWriter

    文件字符输出流继承自Writer类,提供了向文件输出的各种方法,数据通过文件字符输出流以字符为单位输出并保存到文件中。

    package com.zch.io;

    /**

    * 通过给定的String类型参数的指定文件名称与路径,创建FileWriter类。

    *

    * @author zch

    */

    import java.io.File;

    import java.io.FileReader;

    import java.io.FileWriter;

    import java.io.IOException;

    public class FileWriterDemo {

    public static void main(String[] args) {

    File file = new File("D://word2.txt");//创建指定文件

    try {

    if(! file.exists()){

    file.createNewFile();//如果指定文件不存在,新建文件

    }

    FileReader fr = new FileReader("D://word.txt");

    FileWriter fw = new FileWriter(file);//创建FileWriter对象

    int length = 0;

    while((length = fr.read()) != -1){//如果没有读到文件末尾

    fw.write(length);//向文件写入数据

    }

    fr.close();//关闭流

    fw.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    运行后创建了Word2.txt 文件,并向其中写入数据

    2b43bf976219b78e70ca1b1e0a479abd.png

    (四)IO流实战:

    1、Java IO流实现复制文件夹

    通过IO不仅可以复制文件,还可以复制文件夹,但是文件夹内,可能包含其他文件夹,因此需要对他们进行分别复制。

    1 packagecom.zch.io;2

    3 importjava.io.File;4 importjava.io.FileInputStream;5 importjava.io.FileOutputStream;6

    7 public classCopyFile {8 public static voidmain(String[] args) {9 File sourceFile = null;10 File desFile = null;11

    12 String sourceFolder = "D://简历2";13 String copyFolder = "D://copy";14

    15 sourceFile = newFile(sourceFolder);16

    17 if (!sourceFile.isDirectory() || !sourceFile.exists()) {18 System.out.println("源文件夹不存在!");19 } else{20 desFile = newFile(copyFolder);21 desFile.mkdir();22

    23 copy(sourceFile.listFiles(), desFile);24 System.out.println("文件夹复制成功!");25 }26 }27 /**

    28 * 创建copy方法,该方法接收文件数组和目标文件夹两个参数,如果目标文件夹不存在,则调用mkdir()方法创建文件夹,然后再循环中将文件数组29 * 中的每个文件对象写到目标文件夹内。30 *@paramfl31 *@paramfile32 */

    33 public static voidcopy(File[] fl, File file) {34 if (!file.exists()) { //如果文件夹不存在

    35 file.mkdir(); //建立新的文件夹

    36 }37

    38 for (int i = 0; i < fl.length; i++) {39 if (fl[i].isFile()) { //如果是文件类型,则复制文件

    40 try{41 FileInputStream fis = newFileInputStream(fl[i]);42 FileOutputStream out = new FileOutputStream(newFile(43 file.getPath() + File.separator +fl[i].getName()));44

    45 int count =fis.available();46 byte[] data = new byte[count];47

    48 if ((fis.read(data)) != -1) {49 out.write(data);50 }51 } catch(Exception e) {52 //TODO Auto-generated catch block

    53 e.printStackTrace();54 }55 }56

    57 if (fl[i].isDirectory()) { //如果是文件夹类型

    58 File des = new File(file.getPath() +File.separator59 +fl[i].getName());60 des.mkdir(); //在目标文件夹中创建相同的文件夹

    61 copy(fl[i].listFiles(), des); //递归调用方法本身

    62 }63

    64 }65

    66 }67 }

    运行本实例,会将D盘中的简历文件中的内容复制到D盘的copy文件夹中,而且包含文件夹的子文件夹

    2、Java IO流实现分行向文件中写入数据

    FileWriter类可以向文件写入字符数据,如果将FileWriter类封装到BufferWriter类的缓冲字符流中,能够实现缓冲字符输出流,并且可以通过读输出流的newLine()方法,来实现数据的分行写入。

    1 packagecom.zch.io;2

    3 importjava.io.BufferedWriter;4 importjava.io.File;5 importjava.io.FileWriter;6 importjava.io.IOException;7

    8 /**

    9 * 创建BranchWriter类,在主方法中定义文件对象,将该对象作为参数创建BufferedWriter类实例,10 * 调用该实例的writer方法将数据写入文件中,然后 调用newLine()方法写入换行符,实现分行向文件写入数据。11 *12 *@authorzch13 *14 */

    15 public classBranchWriter {16 public static voidmain(String[] args) {17 String filePath = "D://BranchWriter.txt";18

    19 File file = newFile(filePath);20

    21 try{22 if (!file.exists()) {23 file.createNewFile();24 }25 FileWriter fw = new FileWriter(file); //创建文件输出流

    26

    27 BufferedWriter bw = new BufferedWriter(fw); //使用缓冲区数据流封装输出流

    28 for (int i = 0; i < 100; i++) { //循环写入100行数据

    29

    30 bw.write("Java交互管道——IO流".toCharArray());//写入数据到输出流

    31

    32 bw.newLine(); //写入换行符

    33

    34 bw.flush(); //刷新缓冲区

    35 }36

    37 System.out.println("成功写入数据!");38

    39 } catch(IOException e) {40 //TODO Auto-generated catch block

    41 e.printStackTrace();42 }43 }44 }

    3、删除指定文件

    File类的delete()方法可以实现删除指定的文件,首先使用目标文件路径创建File类的实例对象,然后再调用File类的delete()方法。

    package com.zch.io;

    import java.io.File;

    public class FileDelete {

    public static void main(String[] args) {

    String filePath = "D://word.txt";

    File file = new File(filePath);

    delFile(file);

    }

    public static void delFile(File file) {

    if (!file.exists()) {

    System.out.println("文件不存在!");

    return;

    }

    boolean rs = file.delete();

    if (rs) {

    System.out.println("文件删除成功!");

    } else {

    System.out.println("文件删除失败!");

    }

    }

    }

    ————————————————

    版权声明:本文为CSDN博主「Christopher Cheung」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

    原文链接:https://blog.csdn.net/zch19960629/java/article/details/77917739

    展开全文
  • Java实现文件写入——IO(输入输出详解)

    万次阅读 多人点赞 2017-09-09 20:43:12
    输入输出的重要性: &nbsp;&nbsp;&nbsp;&nbsp;...输入和输出功能是Java对...程序从输入读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“...

    输入输出的重要性:

         输入和输出功能是Java对程序处理数据能力的提高,Java以流的形式处理数据。流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。

         程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“读入”与“写入”操作的流类。

    Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。


    (一)解析文件处理的奥秘



    1、学习使用文件类 : File类


         File类用于封装系统的文件和目录的相关信息。在该类中定义了一些与平台无关的方法来操作文件。例如文件的大小、修改时间、文件路径等。

    创建 File 对象可以通过下面3种方式:

    方法1:方法2:方法3:
    new File(String pathName)File file = new File(“E://1.txt”)new File(String parent , String child)
    parent :父抽象路径名;child:子路径名字符串

    2、如何获取文件信息

    File 类是对文件和文件夹的抽象,包含了对文件和文件夹的多种属性和操作方法。File类的常用方法如下表:

    返回方法说明
    StringgetName获取文件名称
    StringgetParent获取文件的父路径字符串
    StringgetPath获取文件的相对路径字符串
    StringgetAbsolutePath获取文件的绝对路径字符串
    booleanexists判断文件或者文件夹是否存在
    booleanisFile判断是不是文件类型
    booleanisDirectory判断是不是文件夹类型
    booleandelete删除文件或文件夹,如果删除成功返回结果为true
    booleanmkdir创建文件夹,创建成功返回true
    booleansetReadOnly设置文件或文件夹的只读属性
    longlength获取文件的长度
    longlastModified获取文件的最后修改时间
    String[ ]list获取文件夹中的文件和子文件夹的名称,并存放到字符串数组中

    下面通过实例介绍File类获取文件信息

    package com.zch.io;
    
    import java.io.File;
    import java.util.Date;
    
    /**
     * 在src根目录下创建FileInfo类,在该类的主方法中创建文件对象,通过File类的相关方法,获取文件的相关信息
     * 
     * @author zch
     * 
     */
    public class FileInfo {
    	public static void main(String[] args) {
    
    		String filePath = "src/com/zch/io/FileInfo.java";
    		// 根据指定路径创建文件对象
    		File file = new File(filePath);
    		System.out.println("文件名称:" + file.getName());
    		System.out.println("文件是否存在:" + file.exists());
    		System.out.println("文件的相对路径:" + file.getPath());
    		System.out.println("文件的绝对路径:" + file.getAbsolutePath());
    		System.out.println("是否为可执行文件:" + file.canExecute());
    		System.out.println("文件可以读取:" + file.canRead());
    		System.out.println("文件可以写入:" + file.canWrite());
    		System.out.println("文件上级路径:" + file.getParent());
    		System.out.println("文件大小:" + file.length() + "B");
    		System.out.println("文件最后修改时间:" + new Date(file.lastModified()));
    		System.out.println("是否文件类型:" + file.isFile());
    		System.out.println("是否为文件夹:" + file.isDirectory());
    
    	}
    
    }
    
    

    运行结果如下:

    文件名称:FileInfo.java
    文件是否存在:true
    文件的相对路径:src\com\zch\io\FileInfo.java
    文件的绝对路径:D:\Java\IO\src\com\zch\io\FileInfo.java
    是否为可执行文件:true
    文件可以读取:true
    文件可以写入:true
    文件上级路径:src\com\zch\io
    文件大小:1195B
    文件最后修改时间:Sat Sep 09 21:30:10 CST 2017
    是否文件类型:true
    是否为文件夹:false
    

    在使用delete()方法删除File对象时,如果删除的对象是目录,该目录中的内容必须为空。


    (二)使用字节输入输出流

         字节流用于处理二进制数据的读取和写入,它以字节为单位,InputStream类和OutputStream类是字节流的抽象类,它们定义了数据流读取和写入的基本方法。各个子类会依其特点实现或覆盖这些方法。


    1、字节数入流抽象类InputStream

          InputStream 类是字节输入流的抽象类,定义了操作输入流的各种方法,这些方法如表:

    返回方法说明
    intavailable()返回当前输入流的数据读取方法可以读取的有效字节数量
    Abstract intread()从当前数据流中读取一个字节。若已达到流结尾,则返回-1
    intread(byte[ ] bytes)从当前输入流读取一定的byte数据,并存取在数组中,然后返回读取的byte数据的数量,若已到达流结尾,则返回-1。
    voidreset()将当前的输入流重新定位到最后一次调用mark()方法时的位置
    voidmark(int readlimit)在当前输入流中做标记位置,当调用reset()方法时将返回到该位置,从标记位置开始,到再读入readlimit个字符为止,这个标记都维持有效。
    BooleanmarkSupported()测试当前输入流是否支持mark()和reset()方法,只要其中一个不支持,则返回false
    longskip(long n)跳过和丢弃当前输入的n个字节数据
    voidclose()关闭当前输入流,并释放任何与之相关联的系统资源

         InputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。下面通过实例如何使用InputStream从控制台获取用户输入的数据信息。

    package com.zch.io;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * 创建InputStream实例inp,并将其赋值为System类的in属性,定义为控制台输入流,从inp输入流中获取字节信息,
     * 用这些字节信息创建字符串,并将其在控制台上输出。
     * @author zch
     *
     */
    public class InputMessage {
    	public static void main(String[] args) {
    		InputStream inp = System.in;
    		
    		byte[] bytes = new byte[1024];
    		
    		try {
    			while(inp.read() != -1){
    				//根据用户输入的信息创建字符串
    				
    				String str = new String(bytes).trim();
    				
    			}
    			inp.close();		//关闭流
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    }
    
    


    2、字节输出流抽象类OutputStream类


    OutputStream定义了输出流的各种方法,如下表:
    返回方法说明
    voidwrite(byte[ ] b)将byte[ ] 数组中的数据写入当前输出流
    voidwrite(byte[] b ,int off, int len)将byte[ ]数组下标off开始的len长度的数据写入当前输出流
    Abstract voidwrite(int b)写入一个byte数据到当前输出流
    voidflush()刷新当前输出流,并强制写入所有缓冲的字节数据
    voidclose()关闭当前输出流

         和InputStream类一样,OutputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。

    package com.zch.io;
    
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * 创建OutputStream实例out,并将其赋值为System.out标准输出流。通过write()方法向流写入数据。
     * @author zch
     *
     */
    public class OutputData {
    	public static void main(String[] args) {
    	OutputStream output = System.out;			//实例化OutputStream对象
    	
    	byte[] bytes = "使用OutputStream输出流在控制台输出字符串\n".getBytes();		//创建bytes数组
    	
    	try {
    		output.write(bytes);
    		
    		bytes = "输出内容:\n".getBytes();
    		output.write(bytes);        //向流中写入数据
    		
    		bytes = "Java数据交互管道——IO流 \n".getBytes();
    		output.write(bytes);
    		
    		output.close();
    		
    	} catch (IOException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    	}
    }
    
    

    输出结果如下:

    使用OutputStream输出流在控制台输出字符串
    输出内容:
       Java数据交互管道——IO流 
    
    



    3、文件字节输入流类 : FileInputStream类


         文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类,并实现了读取输入流的各种方法。

           创建文件字节输入流创建的构造方法语法如下:

    • 语法1:以File对象为参数创建FileInputStream实例
    new FileInputStream(File file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleInputStream实例
    new FileInputStream(String filepath)
    

    4、文件字节输出流类:FileOutputStream

          文件字节输出流关联指定文件路径的文件,数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类,并实现OutputStream类的各种方法。

           文件字节输出流的构造方法语法如下:

    • 语法1:以File对象为参数创建FileOutputStream实例
    new FileOutputStream(File file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleOutputStream实例
    new FileOutputStream(String filepath)
    
    

    下面通过实例介绍文件的写入和读取:

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * 创建OutputStream实例out,并将其赋值为System.out标准输出流,通过write方法向流中写入数据
     * 
     * @author zch
     * 
     */
    public class FileCreate {
    	public static void main(String[] args) {
    		File file = new File("D:/", "word.txt");  //创建文件对象
    
    		try {
    			if (!file.exists()) {				//如果文件不存在则新建文件
    				file.createNewFile();			
    
    			}
    			FileOutputStream output = new FileOutputStream(file);
    
    			byte[] bytes = "Java数据交流管道——IO流".getBytes();
    
    			output.write(bytes);				//将数组的信息写入文件中
    
    			output.close();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    		try {
    			FileInputStream input = new FileInputStream(file);
    
    			byte[] bytes2 = new byte[1024];
    
    			int len = input.read(bytes2);
    
    			System.out.println("文件中的信息是:" + new String(bytes2, 0, len));
    
    			input.close();
    
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    }
    
    
    

    (三) 使用字符输入输出流

          字符输入输出流 与 字节输入输出流有相同的功能,但传送数据的方式不一样,字节流以字节为单位传送数据,可以使任何类型的数据,例如文本、音频、视频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。使用字符输入输出流的好处是,当读取中文时不会出现乱码问题,而使用字节输入输出流时,却不能保证这一点。

    1、字符输入流抽象类:Reader类

    该类定义了操作字符输入流的方法,如下表:

    返回方法说明
    booleanready()判断此数据流是否准备好
    intread()读入一个字符,若已读到流结尾,则返回值为-1
    intread(char[ ])读取一些字符到char[ ]数组内,并返回所读入的字符的数量,若已到达流结尾,则返回-1
    Abscract intread(char[ ] chars,int off,int len)读取一些字符到char[ ]数组下标从off开始到off+len的位置,并返回所读入的字符的数量,若已到达流结尾,则返回-1;
    voidreset()将当前输入流重新定位到最后一次mark()方法时的位置
    voidmark(int readLimit)将当前输入流中做标记,当调用reset方法时将返回到该位置,从标记位置开始,到再读入readLimit个字符为止,这个标记都维持有效
    booleanmarkSupported测试当前输入流是否支持mark()方法和reset()方法。只要有一个方法不支持,则返回-1
    longskip(long n)跳过参数n指定的字符数量,并返回所跳过字符的数量
    Abstract voidclose()关闭字符输入流,并释放与之关联的所有资源



    2、字符输出流类Writer类

           Writer 类主要是用于解决字符输入流的类,其地位与Reader类在输入流的地位和作用是相同的,也是所有字符输出流的流类。


    Writer类的主要方法如下:

    返回方法说明
    voidwrite(char[ ] cbuf) 将字符数组的数据写入字符输出流
    Abstract voidwrite(char[ ] cbuf int off ,int len) 将字符数组从下标off 开始向输入流写入长度为len的数据
    voidwrite(int c ) 向字符输入流中写入一个字符数据
    voidwrite(String str ) 向输入流中写入一个字符串数据
    voidwrite(String str , int off ,int len) 向输入流中写入一个字符串从off 开始长度为len的数据
    Abstract voidflush()刷新当前输出流,并强制写入所有缓冲区的字节数据
    voidclose()向输出流中写入缓冲区的数据,然后关闭当前输出流,释放所有与当前输出流相关联的系统资源


    3、文件字符输入流FileReader

           文件字符输入流与文件字节输入流的功能相似,但是传送数据的方式不一样,字节流以字节为单位传送数据,可以使文本、视频、音频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。

    创建字符输入流常用的构造方法:

    • 语法1:
    new FileReader(File file);
    
    
    • 语法2:
    new FileReader(String path);
    
    

    下面通过实例介绍FileReader类读取指定磁盘文件的内容。

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileReader;
    
    public class FileInAndOut {
    	public static void main(String[] args) {
    		//定义指定磁盘的文件的File对象
    		File file = new File("D://word.txt");
    		
    		if(! file.exists()){
    			System.out.println("对不起,不包含指定路径的文件");
    		}else{
    			//根据指定路径的File对象创建FileReader对象
    			try {
    				FileReader fr = new FileReader(file);
    				
    				char[] data = new char[23];			//定义char数组
    				
    				int length = 0;
    				
    				while((length = fr.read(data))>0){			//循环读取文件中的数据
    					String str = new String(data,0,length);			//根据读取文件的内容创建String 对象
    					System.out.println(str);				//输出读取内容
    				}
    				fr.close();								//关闭流
    				
    				
    				
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    		}
    	}
    }
    
    
    

    运行结果如下图:

    这里写图片描述
    这里写图片描述


    4、文件字符输出流FileWriter

           文件字符输出流继承自Writer类,提供了向文件输出的各种方法,数据通过文件字符输出流以字符为单位输出并保存到文件中。

    package com.zch.io;
    /**
     * 通过给定的String类型参数的指定文件名称与路径,创建FileWriter类。
     * 
     * @author zch
     */
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterDemo {
    	public static void main(String[] args) {
    		File file = new File("D://word2.txt");		//创建指定文件
    		
    		try {
    		if(! file.exists()){
    				file.createNewFile();				//如果指定文件不存在,新建文件
    			
    		}
    		
    		FileReader fr = new FileReader("D://word.txt");
    		
    		FileWriter fw = new FileWriter(file);				//创建FileWriter对象
    		
    		int length = 0;
    		while((length = fr.read()) != -1){			//如果没有读到文件末尾
    			fw.write(length);			//向文件写入数据
    			
    		}
    		fr.close();							//关闭流
    		fw.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    
    

    运行后创建了Word2.txt 文件,并向其中写入数据
    这里写图片描述


    (四)IO流实战:

    1、Java IO流实现复制文件夹

           通过IO不仅可以复制文件,还可以复制文件夹,但是文件夹内,可能包含其他文件夹,因此需要对他们进行分别复制。

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class CopyFile {
    	public static void main(String[] args) {
    		File sourceFile = null;
    		File desFile = null;
    
    		String sourceFolder = "D://简历2";
    		String copyFolder = "D://copy";
    
    		sourceFile = new File(sourceFolder);
    
    		if (!sourceFile.isDirectory() || !sourceFile.exists()) {
    			System.out.println("源文件夹不存在!");
    		} else {
    			desFile = new File(copyFolder);
    			desFile.mkdir();
    
    			copy(sourceFile.listFiles(), desFile);
    			System.out.println("文件夹复制成功!");
    		}
    	}
    /**
     * 创建copy方法,该方法接收文件数组和目标文件夹两个参数,如果目标文件夹不存在,则调用mkdir()方法创建文件夹,然后再循环中将文件数组
     * 中的每个文件对象写到目标文件夹内。
     * @param fl
     * @param file
     */
    	public static void copy(File[] fl, File file) {
    		if (!file.exists()) { // 如果文件夹不存在
    			file.mkdir(); // 建立新的文件夹
    		}
    
    		for (int i = 0; i < fl.length; i++) {
    			if (fl[i].isFile()) { // 如果是文件类型,则复制文件
    				try {
    					FileInputStream fis = new FileInputStream(fl[i]);
    					FileOutputStream out = new FileOutputStream(new File(
    							file.getPath() + File.separator + fl[i].getName()));
    
    					int count = fis.available();
    					byte[] data = new byte[count];
    
    					if ((fis.read(data)) != -1) {
    						out.write(data);
    					}
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    
    			if (fl[i].isDirectory()) { // 如果是文件夹类型
    				File des = new File(file.getPath() + File.separator
    						+ fl[i].getName());
    				des.mkdir(); // 在目标文件夹中创建相同的文件夹
    				copy(fl[i].listFiles(), des); // 递归调用方法本身
    			}
    
    		}
    
    	}
    }
    
    
    

    运行本实例,会将D盘中的简历文件中的内容复制到D盘的copy文件夹中,而且包含文件夹的子文件夹


    2、Java IO流实现分行向文件中写入数据

          FileWriter类可以向文件写入字符数据,如果将FileWriter类封装到BufferWriter类的缓冲字符流中,能够实现缓冲字符输出流,并且可以通过读输出流的newLine()方法,来实现数据的分行写入。

    package com.zch.io;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     * 创建BranchWriter类,在主方法中定义文件对象,将该对象作为参数创建BufferedWriter类实例,
     * 调用该实例的writer方法将数据写入文件中,然后 调用newLine()方法写入换行符,实现分行向文件写入数据。
     * 
     * @author zch
     * 
     */
    public class BranchWriter {
    	public static void main(String[] args) {
    		String filePath = "D://BranchWriter.txt";
    
    		File file = new File(filePath);
    
    		try {
    			if (!file.exists()) {
    				file.createNewFile();
    			}
    			FileWriter fw = new FileWriter(file); // 创建文件输出流
    
    			BufferedWriter bw = new BufferedWriter(fw); // 使用缓冲区数据流封装输出流
    			for (int i = 0; i < 100; i++) {				//循环写入100行数据
    				
    				bw.write("Java交互管道——IO流".toCharArray());// 写入数据到输出流
    				
    				bw.newLine(); // 写入换行符
    				
    				bw.flush(); // 刷新缓冲区
    			}
    
    			System.out.println("成功写入数据!");
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    
    

    3、删除指定文件

           File类的delete()方法可以实现删除指定的文件,首先使用目标文件路径创建File类的实例对象,然后再调用File类的delete()方法。

    package com.zch.io;
    
    import java.io.File;
    
    public class FileDelete {
    
    	public static void main(String[] args) {
    		String filePath = "D://word.txt";
    
    		File file = new File(filePath);
    		delFile(file);
    	}
    
    	public static void delFile(File file) {
    		if (!file.exists()) {
    			System.out.println("文件不存在!");
    			return;
    		}
    		boolean rs = file.delete();
    		if (rs) {
    			System.out.println("文件删除成功!");
    		} else {
    			System.out.println("文件删除失败!");
    		}
    	}
    }
    
    
    
    展开全文
  • Java输入输出文件读写详解;Java输入输出文件读写详解。
  • Java文件写入的6种方法

    千次阅读 2021-10-29 00:21:20
    写程序时经常会碰到读写文件的场景,在Java中操作文件的方法本质上只有两种:字符和字节,而他们的实现类又有很多,因此,有时候用起来,就会比较乱。这篇文章系统介绍了Java操作文件的几种...

    写程序时经常会碰到读写文件的场景,在Java中操作文件的方法本质上只有两种:字符流和字节流,而他们的实现类又有很多,因此,有时候用起来,就会比较乱。

    这篇文章系统介绍了Java操作文件的几种方式,学习一下,

    https://www.cnblogs.com/rinack/p/14173936.html

    1baa57d2c74472a3f60337ad10a34721.png

    b807b7acd1c1f7f5c9b2b70558e48b59.png

    e74c47e3b968c063c98cd3ca619b6e89.png        

    1cfed231c156d981a8466e812423ddb0.png

    ef665f569817a71e515025db4cae7685.png

    37dc15cd877a390015159aa2455eb3bc.png

    918245815ea25e29576bb6467841862c.png

    679bb82138dc7a3a41f934bdca276a34.png

    a77557c1beb6755b458c7a7499df5f5f.png

    e6f0ef87fa7dce5c195649c7ec18e2a2.png

    FileWriter类的实现如下,

    /** 
      * 方法 1:使用 FileWriter 写文件 
      * @param filepath 文件目录 
      * @param content  待写入内容 
      * @throws IOException 
      */ 
    public static void fileWriterMethod(String filepath, String content) throws IOException { 
        try (FileWriter fileWriter = new FileWriter(filepath)) { 
            fileWriter.append(content); 
        } 
    }

    只需要传入具体的文件路径和待写入的内容即可,调用代码如下,

    public static void main(String[] args) { 
        fileWriterMethod("/Users/mac/Downloads/io_test/write1.txt", "Hello, Java."); 
    }

    130d3da7d6c50656ee7ab99ff15010ba.png

    了解了缓存区的优点之后,咱们回到本文的主题,接下来我们用BufferedWriter来文件的写入,实现代码如下,

    /** 
     * 方法 2:使用 BufferedWriter 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void bufferedWriterMethod(String filepath, String content) throws IOException { 
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filepath))) { 
            bufferedWriter.write(content); 
        } 
    }

    797a9fffb0a381c64617ac7449ab9236.png

    /** 
     * 方法 3:使用 PrintWriter 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void printWriterMethod(String filepath, String content) throws IOException { 
        try (PrintWriter printWriter = new PrintWriter(new FileWriter(filepath))) { 
            printWriter.print(content); 
        } 
    }

    1f53581858068143eff1dd71eeb414da.png

    /** 
     * 方法 4:使用 FileOutputStream 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void fileOutputStreamMethod(String filepath, String content) throws IOException { 
        try (FileOutputStream fileOutputStream = new FileOutputStream(filepath)) { 
            byte[] bytes = content.getBytes(); 
            fileOutputStream.write(bytes); 
        } 
    }

    94d3061ecab1f94e1d7c2a5768580113.png

    /** 
     * 方法 5:使用 BufferedOutputStream 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void bufferedOutputStreamMethod(String filepath, String content) throws IOException { 
        try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream( 
                new FileOutputStream(filepath))) { 
            bufferedOutputStream.write(content.getBytes()); 
        } 
    }

    4673ca0210ea87fe6490e8639b493e9d.png

    /** 
     * 方法 6:使用 Files 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void filesTest(String filepath, String content) throws IOException { 
        Files.write(Paths.get(filepath), content.getBytes()); 
    }

    5aed868fc1a0fe02a8a098c139a50ff0.png

    import java.io.*; 
    import java.nio.file.Files; 
    import java.nio.file.Paths; 
     
    public class WriteExample { 
        public static void main(String[] args) throws IOException { 
            // 构建写入内容 
            StringBuilder stringBuilder = new StringBuilder(); 
            for (int i = 0; i < 1000000; i++) { 
                stringBuilder.append("ABCDEFGHIGKLMNOPQRSEUVWXYZ"); 
            } 
            // 写入内容 
            final String content = stringBuilder.toString(); 
            // 存放文件的目录 
            final String filepath1 = "/Users/mac/Downloads/io_test/write1.txt"; 
            final String filepath2 = "/Users/mac/Downloads/io_test/write2.txt"; 
            final String filepath3 = "/Users/mac/Downloads/io_test/write3.txt"; 
            final String filepath4 = "/Users/mac/Downloads/io_test/write4.txt"; 
            final String filepath5 = "/Users/mac/Downloads/io_test/write5.txt"; 
            final String filepath6 = "/Users/mac/Downloads/io_test/write6.txt"; 
     
            // 方法一:使用 FileWriter 写文件 
            long stime1 = System.currentTimeMillis(); 
            fileWriterTest(filepath1, content); 
            long etime1 = System.currentTimeMillis(); 
            System.out.println("FileWriter 写入用时:" + (etime1 - stime1)); 
     
            // 方法二:使用 BufferedWriter 写文件 
            long stime2 = System.currentTimeMillis(); 
            bufferedWriterTest(filepath2, content); 
            long etime2 = System.currentTimeMillis(); 
            System.out.println("BufferedWriter 写入用时:" + (etime2 - stime2)); 
     
            // 方法三:使用 PrintWriter 写文件 
            long stime3 = System.currentTimeMillis(); 
            printWriterTest(filepath3, content); 
            long etime3 = System.currentTimeMillis(); 
            System.out.println("PrintWriterTest 写入用时:" + (etime3 - stime3)); 
     
            // 方法四:使用 FileOutputStream  写文件 
            long stime4 = System.currentTimeMillis(); 
            fileOutputStreamTest(filepath4, content); 
            long etime4 = System.currentTimeMillis(); 
            System.out.println("FileOutputStream 写入用时:" + (etime4 - stime4)); 
     
            // 方法五:使用 BufferedOutputStream 写文件 
            long stime5 = System.currentTimeMillis(); 
            bufferedOutputStreamTest(filepath5, content); 
            long etime5 = System.currentTimeMillis(); 
            System.out.println("BufferedOutputStream 写入用时:" + (etime5 - stime5)); 
     
            // 方法六:使用 Files 写文件 
            long stime6 = System.currentTimeMillis(); 
            filesTest(filepath6, content); 
            long etime6 = System.currentTimeMillis(); 
            System.out.println("Files 写入用时:" + (etime6 - stime6)); 
    
    
        } 
     
        /** 
         * 方法六:使用 Files 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void filesTest(String filepath, String content) throws IOException { 
            Files.write(Paths.get(filepath), content.getBytes()); 
        } 
     
        /** 
         * 方法五:使用 BufferedOutputStream 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void bufferedOutputStreamTest(String filepath, String content) throws IOException { 
            try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream( 
                    new FileOutputStream(filepath))) { 
                bufferedOutputStream.write(content.getBytes()); 
            } 
        } 
     
        /** 
         * 方法四:使用 FileOutputStream  写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void fileOutputStreamTest(String filepath, String content) throws IOException { 
            try (FileOutputStream fileOutputStream = new FileOutputStream(filepath)) { 
                byte[] bytes = content.getBytes(); 
                fileOutputStream.write(bytes); 
            } 
        } 
     
        /** 
         * 方法三:使用 PrintWriter 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void printWriterTest(String filepath, String content) throws IOException { 
            try (PrintWriter printWriter = new PrintWriter(new FileWriter(filepath))) { 
                printWriter.print(content); 
            } 
        } 
     
        /** 
         * 方法二:使用 BufferedWriter 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void bufferedWriterTest(String filepath, String content) throws IOException { 
            try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filepath))) { 
                bufferedWriter.write(content); 
            } 
        } 
     
        /** 
         * 方法一:使用 FileWriter 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void fileWriterTest(String filepath, String content) throws IOException { 
            try (FileWriter fileWriter = new FileWriter(filepath)) { 
                fileWriter.append(content); 
            } 
        } 
    }

    在查看结果之前,我们先去对应的文件夹看看写入的文件是否正常,如下图所示,

    0515e9e661b62be65c7c59be08266a26.png

    从上述结果可以看出,每种方法都正常写入了26 MB的数据,他们最终执行的结果如下图所示,

    e5e52fee47a813c41934dd1b426ef784.png

    4c29b9e9cb7bfca2a258fc47772830d5.png

    7f90c2fd7d9c404880691587df008302.png

    80648265fbe253ffa79c4ec5feb39c17.png

    c70e7074f142a2ba2fa7b79134533630.png


    cc8d9b4ed0e99a3118db8982d0fa53fe.png

    近期更新的文章:

    第七届DAMS中国数据智能管理峰会(上海站) - 文末俩惊喜

    MyBatis动态传递参数的两种方式#{}和${}

    OpenJDK的一个bug

    DTCC参会归来有感

    小白学习MySQL - 聊聊数据备份的重要性

    文章分类和索引:

    《公众号800篇文章分类和索引

    展开全文
  • (1)一般的java代码 @Test public void whenConvertingToFile_thenCorrect() throws IOException { InputStream initialStream = new FileInputStream( new File("src/main/resources/sample.txt")); byte[]...
  • java写入文件是乱码

    2021-03-22 14:39:11
    java写入文件是乱码我们读取、写入文件流时,经常会遇到乱码的现象,造成乱码的原因当然不可能是一个,这里主要介绍因为文件编码格式而导致的乱码的问题。首先,明确一点,文本文件与二进制文件的概念与差异。文本...
  • Java实现文件复制,File文件读取,写入,IO的读取写入
  • java写入dat文件

    千次阅读 2021-03-05 11:20:38
    Java的输入输出包括字节流、文件流、对象流等,要注意区分不同流使用的不同类。字...Java的输入输出包括字节流、文件流、对象流等,要注意区分不同流使用的不同类。字...Java的输入输出包括字节流、文件流和对象流等,...
  • Java写入文件的性能详细分析

    千次阅读 2021-03-01 10:36:04
    前言众所周知,Java中有多种针对文件的操作类,以面向字节和字符可分为两大类,这里以写入为例:面向字节的:FileOutputStream 和BufferedOutputStream面向字符的:FileWriter 和BufferedWriter近年来发展出...
  • Java文件写入的六种方式

    千次阅读 2021-05-23 16:55:05
    Java 中操作文件的方法本质上只有两种:字符和字节,而字节和字符的实现类又有很多,因此在文件写入时我们就可以选择各种各样的类来实现。 Java 中的“”是一种抽象的概念,也是一种比喻,就好比...
  • java写入文件的几种方法(一)

    万次阅读 多人点赞 2019-01-16 11:42:58
    1. FileWritter写入文件 FileWritter, 字符写入字符到文件。默认情况下,它会使用新的内容取代所有现有的内容,如下: new FileWriter(file); 然而,当指定一个true (Boolean)值作为FileWritter构造函数的第...
  • Java读取和写入二进制大文件的方法,应该说是一个基于二进制的大文件块,演示了如何自定义缓存区,并使用不具有缓冲功能的DataInputStream 和DataOutputStream 类来读写二进制的大文件块数据,运行效果请参见如下...
  • java中io,利用三种方式将数据写入文件中,新手必备
  • 主要介绍了java的io操作示例,将字符串写入到txt文件中,需要的朋友可以参考下
  • 输入输出含义和意义:输入和输出...Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类...
  • java写入文件的几种方法分享

    千次阅读 2021-02-12 08:59:37
    转自:http://www.jb51.net/article/47062.htm一,FileWritter写入文件FileWritter, 字符写入字符到文件。默认情况下,它会使用新的内容取代所有现有的内容,然而,当指定一个true (布尔)值作为FileWritter构造...
  • 主要介绍了java实现追加内容到文件末尾的常用方法,结合具体实例分析了java文件流写入指针等相关操作技巧,需要的朋友可以参考下
  • Java io流文件读取和写入

    千次阅读 2020-07-10 17:16:29
    Java io 操作demo类 1.读取操作 /** *@author lxw *@date 2020/6/24 *@desc 获取文件输入,这里读入内存中 *@param [fileName] *@return byte[] **/ public byte[] readPdfFile(String fileName) ...
  • 如何用Java写入文件– FileOutputStream

    千次阅读 2020-06-02 19:38:08
    要将数据写入文件,您必须将数据转换为字节并将其保存到文件。 请参阅下面的完整示例。 package com.mkyong.io; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; pub...
  • Java对象写入文件

    千次阅读 2021-03-06 03:50:20
    对象的序列化指将一个Java对象写入IO中,与此对应的反是,对象的反序列化则指从IO中恢复该Java对象。如果需要需要让某个对象支持序列化机制,则必须让它的类是可序列化的(serializable)。为了让某个...
  • 主要介绍了Java 批量文件压缩导出并下载到本地示例代码,实现思路首先要把zip流写入到http响应输出中,再把excel的流写入zip中,具体示例代码,大家通过本文学习吧
  • java 流写入本地文件

    千次阅读 2018-03-27 10:17:51
    java"] private static void writeToLocal(String destination, InputStream input) throws Exception{ int index; byte[] bytes = new byte[1024]; FileOutputStream downloadFile = new F.....
  • java中创建、写入文件的5种方式

    千次阅读 2021-03-22 16:12:39
    java中有很多的方法可以创建文件...Files.newBufferedWriter(Java 8)Files.write(Java 7 推荐)PrintWriterFile.createNewFileFileOutputStream.write(byte[] b) 管道实际上不只这5种,通过管道的排列组合,其...
  • JAVA读取与写入文件

    千次阅读 2020-11-10 09:12:34
    简单的展示Java 文件输入输出File读取写入文件的快速实现,方便大家记忆与快速使用。
  • NULL 博文链接:https://blacklab.iteye.com/blog/562541
  • =null){ System.out.print("写入成功"); e=d.readLine(); } c.close(); d.close(); } catch (RuntimeException e) { // TODO Auto-generated catch block e.printStackTrace(); System.out.println("文件不存在"); }...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 250,036
精华内容 100,014
关键字:

java 写入文件流

java 订阅