csdnceshi78
程序go
2010-05-21 19:58
浏览 759
已采纳

如何创建一个文件并用 Java 写入?

What's the simplest way to create and write to a (text) file in Java?

转载于:https://stackoverflow.com/questions/2885173/how-do-i-create-a-file-and-write-to-it-in-java

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

30条回答 默认 最新

  • weixin_41568183
    零零乙 2010-05-21 20:06
    已采纳

    Note that each of the code samples below may throw IOException. Try/catch/finally blocks have been omitted for brevity. See this tutorial for information about exception handling.

    Creating a text file (note that this will overwrite the file if it already exists):

    PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
    writer.println("The first line");
    writer.println("The second line");
    writer.close();
    

    Creating a binary file (this will also overwrite the file):

    byte data[] = ...
    FileOutputStream out = new FileOutputStream("the-file-name");
    out.write(data);
    out.close();
    

    Java 7+ users can use the Files class to write to files:

    Creating a text file:

    List<String> lines = Arrays.asList("The first line", "The second line");
    Path file = Paths.get("the-file-name.txt");
    Files.write(file, lines, Charset.forName("UTF-8"));
    //Files.write(file, lines, Charset.forName("UTF-8"), StandardOpenOption.APPEND);
    

    Creating a binary file:

    byte data[] = ...
    Path file = Paths.get("the-file-name");
    Files.write(file, data);
    //Files.write(file, data, StandardOpenOption.APPEND);
    
    点赞 评论
  • csdnceshi65
    larry*wei 2010-05-21 20:09

    In Java 7 and up:

    try (Writer writer = new BufferedWriter(new OutputStreamWriter(
                  new FileOutputStream("filename.txt"), "utf-8"))) {
       writer.write("something");
    }
    

    There are useful utilities for that though:

    Note also that you can use a FileWriter, but it uses the default encoding, which is often a bad idea - it's best to specify the encoding explicitly.

    Below is the original, prior-to-Java 7 answer


    Writer writer = null;
    
    try {
        writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"));
        writer.write("Something");
    } catch (IOException ex) {
        // Report
    } finally {
       try {writer.close();} catch (Exception ex) {/*ignore*/}
    }
    

    See also: Reading, Writing, and Creating Files (includes NIO2).

    点赞 评论
  • weixin_41568127
    ?yb? 2010-05-21 20:09
    public class Program {
        public static void main(String[] args) {
            String text = "Hello world";
            BufferedWriter output = null;
            try {
                File file = new File("example.txt");
                output = new BufferedWriter(new FileWriter(file));
                output.write(text);
            } catch ( IOException e ) {
                e.printStackTrace();
            } finally {
              if ( output != null ) {
                output.close();
              }
            }
        }
    }
    
    点赞 评论
  • csdnceshi65
    larry*wei 2010-05-21 20:10

    If you wish to have a relatively pain-free experience you can also have a look at the Apache Commons IO package, more specifically the FileUtils class.

    Never forget to check third-party libraries. Joda-Time for date manipulation, Apache Commons Lang StringUtils for common string operations and such can make your code more readable.

    Java is a great language, but the standard library is sometimes a bit low-level. Powerful, but low-level nonetheless.

    点赞 评论
  • csdnceshi80
    胖鸭 2010-05-21 20:12

    If you for some reason want to separate the act of creating and writing, the Java equivalent of touch is

    try {
       //create a file named "testfile.txt" in the current working directory
       File myFile = new File("testfile.txt");
       if ( myFile.createNewFile() ) {
          System.out.println("Success!");
       } else {
          System.out.println("Failure!");
       }
    } catch ( IOException ioe ) { ioe.printStackTrace(); }
    

    createNewFile() does an existence check and file create atomically. This can be useful if you want to ensure you were the creator of the file before writing to it, for example.

    点赞 评论
  • csdnceshi67
    bug^君 2013-04-09 18:05

    Here's a little example program to create or overwrite a file. It's the long version so it can be understood more easily.

    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    import java.io.Writer;
    
    public class writer {
        public void writing() {
            try {
                //Whatever the file path is.
                File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
                FileOutputStream is = new FileOutputStream(statText);
                OutputStreamWriter osw = new OutputStreamWriter(is);    
                Writer w = new BufferedWriter(osw);
                w.write("POTATO!!!");
                w.close();
            } catch (IOException e) {
                System.err.println("Problem writing to the file statsTest.txt");
            }
        }
    
        public static void main(String[]args) {
            writer write = new writer();
            write.writing();
        }
    }
    
    点赞 评论
  • csdnceshi80
    胖鸭 2013-04-19 14:35

    Use:

    try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
        writer.write("text to write");
    } 
    catch (IOException ex) {
        // Handle me
    }  
    

    Using try() will close stream automatically. This version is short, fast (buffered) and enables choosing encoding.

    This feature was introduced in Java 7.

    点赞 评论
  • weixin_41568126
    乱世@小熊 2014-04-22 14:01

    If you already have the content you want to write to the file (and not generated on the fly), the java.nio.file.Files addition in Java 7 as part of native I/O provides the simplest and most efficient way to achieve your goals.

    Basically creating and writing to a file is one line only, moreover one simple method call!

    The following example creates and writes to 6 different files to showcase how it can be used:

    Charset utf8 = StandardCharsets.UTF_8;
    List<String> lines = Arrays.asList("1st line", "2nd line");
    byte[] data = {1, 2, 3, 4, 5};
    
    try {
        Files.write(Paths.get("file1.bin"), data);
        Files.write(Paths.get("file2.bin"), data,
                StandardOpenOption.CREATE, StandardOpenOption.APPEND);
        Files.write(Paths.get("file3.txt"), "content".getBytes());
        Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
        Files.write(Paths.get("file5.txt"), lines, utf8);
        Files.write(Paths.get("file6.txt"), lines, utf8,
                StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    } catch (IOException e) {
        e.printStackTrace();
    }
    
    点赞 评论
  • csdnceshi64
    游.程 2014-06-10 11:55

    Here we are entering a string into a text file:

    String content = "This is the content to write into a file";
    File file = new File("filename.txt");
    FileWriter fw = new FileWriter(file.getAbsoluteFile());
    BufferedWriter bw = new BufferedWriter(fw);
    bw.write(content);
    bw.close(); // Be sure to close BufferedWriter
    

    We can easily create a new file and add content into it.

    点赞 评论
  • csdnceshi77
    狐狸.fox 2014-06-29 12:48

    To create file without overwriting existing file:

    System.out.println("Choose folder to create file");
    JFileChooser c = new JFileChooser();
    c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    c.showOpenDialog(c);
    c.getSelectedFile();
    f = c.getSelectedFile(); // File f - global variable
    String newfile = f + "\\hi.doc";//.txt or .doc or .html
    File file = new File(newfile);
    
    try {
        //System.out.println(f);
        boolean flag = file.createNewFile();
    
        if(flag == true) {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        /* Or use exists() function as follows:
            if(file.exists() == true) {
                JOptionPane.showMessageDialog(rootPane, "File already exists");
            }
            else {
                JOptionPane.showMessageDialog(rootPane, "File created successfully");
            }
        */
    }
    catch(Exception e) {
        // Any exception handling method of your choice
    }
    
    点赞 评论
  • csdnceshi53
    Lotus@ 2014-07-15 14:43

    Use:

    JFileChooser c = new JFileChooser();
    c.showOpenDialog(c);
    File writeFile = c.getSelectedFile();
    String content = "Input the data here to be written to your file";
    
    try {
        FileWriter fw = new FileWriter(writeFile);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.append(content);
        bw.append("hiiiii");
        bw.close();
        fw.close();
    }
    catch (Exception exc) {
       System.out.println(exc);
    }
    
    点赞 评论
  • weixin_41568134
    MAO-EYE 2014-11-07 16:34
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterExample {
        public static void main(String [] args) {
            FileWriter fw= null;
            File file =null;
            try {
                file=new File("WriteFile.txt");
                if(!file.exists()) {
                    file.createNewFile();
                }
                fw = new FileWriter(file);
                fw.write("This is an string written to a file");
                fw.flush();
                fw.close();
                System.out.println("File written Succesfully");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    点赞 评论
  • csdnceshi71
    Memor.の 2014-11-07 20:28

    The simplest way I can find:

    Path sampleOutputPath = Paths.get("/tmp/testfile")
    try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
        writer.write("Hello, world!");
    }
    

    It will probably only work for 1.7+.

    点赞 评论
  • csdnceshi61
    derek5. 2014-11-15 02:17

    File reading and writing using input and outputstream:

    //Coded By Anurag Goel
    //Reading And Writing Files
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    
    public class WriteAFile {
        public static void main(String args[]) {
            try {
                byte array [] = {'1','a','2','b','5'};
                OutputStream os = new FileOutputStream("test.txt");
                for(int x=0; x < array.length ; x++) {
                    os.write( array[x] ); // Writes the bytes
                }
                os.close();
    
                InputStream is = new FileInputStream("test.txt");
                int size = is.available();
    
                for(int i=0; i< size; i++) {
                    System.out.print((char)is.read() + " ");
                }
                is.close();
            } catch(IOException e) {
                System.out.print("Exception");
            }
        }
    }
    
    点赞 评论
  • csdnceshi56
    lrony* 2014-12-11 06:55

    One line only ! path and line are Strings

    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    Files.write(Paths.get(path), lines.getBytes());
    
    点赞 评论
  • csdnceshi59
    ℙℕℤℝ 2014-12-17 07:24

    I think this is the shortest way:

    FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
    // your file extention (".txt" in this case)
    fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
    fr.close();
    
    点赞 评论
  • csdnceshi53
    Lotus@ 2015-05-10 15:42

    Just include this package:

    java.nio.file
    

    And then you can use this code to write the file:

    Path file = ...;
    byte[] buf = ...;
    Files.write(file, buf);
    
    点赞 评论
  • csdnceshi62
    csdnceshi62 2015-05-13 04:39

    Since the author did not specify whether they require a solution for Java versions that have been EoL'd (by both Sun and IBM, and these are technically the most widespread JVMs), and due to the fact that most people seem to have answered the author's question before it was specified that it is a text (non-binary) file, I have decided to provide my answer.


    First of all, Java 6 has generally reached end of life, and since the author did not specify he needs legacy compatibility, I guess it automatically means Java 7 or above (Java 7 is not yet EoL'd by IBM). So, we can look right at the file I/O tutorial: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

    Prior to the Java SE 7 release, the java.io.File class was the mechanism used for file I/O, but it had several drawbacks.

    • Many methods didn't throw exceptions when they failed, so it was impossible to obtain a useful error message. For example, if a file deletion failed, the program would receive a "delete fail" but wouldn't know if it was because the file didn't exist, the user didn't have permissions, or there was some other problem.
    • The rename method didn't work consistently across platforms.
    • There was no real support for symbolic links.
    • More support for metadata was desired, such as file permissions, file owner, and other security attributes. Accessing file metadata was inefficient.
    • Many of the File methods didn't scale. Requesting a large directory listing over a server could result in a hang. Large directories could also cause memory resource problems, resulting in a denial of service.
    • It was not possible to write reliable code that could recursively walk a file tree and respond appropriately if there were circular symbolic links.

    Oh well, that rules out java.io.File. If a file cannot be written/appended, you may not be able to even know why.


    We can continue looking at the tutorial: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

    If you have all lines you will write (append) to the text file in advance, the recommended approach is https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption...-

    Here's an example (simplified):

    Path file = ...;
    List<String> linesInMemory = ...;
    Files.write(file, linesInMemory, StandardCharsets.UTF_8);
    

    Another example (append):

    Path file = ...;
    List<String> linesInMemory = ...;
    Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);
    

    If you want to write file content as you go: https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java.nio.charset.Charset-java.nio.file.OpenOption...-

    Simplified example (Java 8 or up):

    Path file = ...;
    try (BufferedWriter writer = Files.newBufferedWriter(file)) {
        writer.append("Zero header: ").append('0').write("\r\n");
        [...]
    }
    

    Another example (append):

    Path file = ...;
    try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
        writer.write("----------");
        [...]
    }
    

    These methods require minimal effort on the author's part and should be preferred to all others when writing to [text] files.

    点赞 评论
  • csdnceshi57
    perhaps? 2015-06-08 14:58
    package fileoperations;
    import java.io.File;
    import java.io.IOException;
    
    public class SimpleFile {
        public static void main(String[] args) throws IOException {
            File file =new File("text.txt");
            file.createNewFile();
            System.out.println("File is created");
            FileWriter writer = new FileWriter(file);
    
            // Writes the content to the file
            writer.write("Enter the text that you want to write"); 
            writer.flush();
            writer.close();
            System.out.println("Data is entered into file");
        }
    }
    
    点赞 评论
  • csdnceshi78
    程序go 2015-06-21 07:00

    If we are using Java 7 and above and also know the content to be added (appended) to the file we can make use of newBufferedWriter method in NIO package.

    public static void main(String[] args) {
        Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
        String text = "\n Welcome to Java 8";
    
        //Writing to the file temp.txt
        try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
            writer.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

    There are few points to note:

    1. It is always a good habit to specify charset encoding and for that we have constant in class StandardCharsets.
    2. The code uses try-with-resource statement in which resources are automatically closed after the try.

    Though OP has not asked but just in case we want to search for lines having some specific keyword e.g. confidential we can make use of stream APIs in Java:

    //Reading from the file the first line which contains word "confidential"
    try {
        Stream<String> lines = Files.lines(FILE_PATH);
        Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
        if(containsJava.isPresent()){
            System.out.println(containsJava.get());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    
    点赞 评论
  • csdnceshi71
    Memor.の 2015-10-14 04:46

    There are some simple ways, like:

    File file = new File("filename.txt");
    PrintWriter pw = new PrintWriter(file);
    
    pw.write("The world I'm coming");
    pw.close();
    
    String write = "Hello World!";
    
    FileWriter fw = new FileWriter(file);
    BufferedWriter bw = new BufferedWriter(fw);
    
    fw.write(write);
    
    fw.close();
    
    点赞 评论
  • csdnceshi67
    bug^君 2015-11-19 16:07

    A very simple way to create and write to a file in Java:

    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    
    public class CreateFiles {
    
        public static void main(String[] args) {
            try{
                // Create new file
                String content = "This is the content to write into create file";
                String path="D:\\a\\hi.txt";
                File file = new File(path);
    
                // If file doesn't exists, then create it
                if (!file.exists()) {
                    file.createNewFile();
                }
    
                FileWriter fw = new FileWriter(file.getAbsoluteFile());
                BufferedWriter bw = new BufferedWriter(fw);
    
                // Write in file
                bw.write(content);
    
                // Close connection
                bw.close();
            }
            catch(Exception e){
                System.out.println(e);
            }
        }
    }
    

    Reference: File create Example in java

    点赞 评论
  • csdnceshi56
    lrony* 2016-03-05 17:45

    Reading collection with customers and saving to file, with JFilechooser.

    private void writeFile(){
    
        JFileChooser fileChooser = new JFileChooser(this.PATH);
        int retValue = fileChooser.showDialog(this, "Save File");
    
        if (retValue == JFileChooser.APPROVE_OPTION){
    
            try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){
    
                this.customers.forEach((c) ->{
                    try{
                        fileWrite.append(c.toString()).append("\n");
                    }
                    catch (IOException ex){
                        ex.printStackTrace();
                    }
                });
            }
            catch (IOException e){
                e.printStackTrace();
            }
        }
    }
    
    点赞 评论
  • csdnceshi71
    Memor.の 2016-05-30 10:00

    It's worth a try for Java 7+:

     Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());
    

    It looks promising...

    点赞 评论
  • csdnceshi68
    local-host 2016-06-01 04:41

    You can even create a temporary file using a system property, which will be independent of which OS you are using.

    File file = new File(System.*getProperty*("java.io.tmpdir") +
                         System.*getProperty*("file.separator") +
                         "YourFileName.txt");
    
    点赞 评论
  • csdnceshi59
    ℙℕℤℝ 2016-08-15 13:40

    Using Google's Guava library, we can create and write to a file very easily.

    package com.zetcode.writetofileex;
    
    import com.google.common.io.Files;
    import java.io.File;
    import java.io.IOException;
    
    public class WriteToFileEx {
    
        public static void main(String[] args) throws IOException {
    
            String fileName = "fruits.txt";
            File file = new File(fileName);
    
            String content = "banana, orange, lemon, apple, plum";
    
            Files.write(content.getBytes(), file);
        }
    }
    

    The example creates a new fruits.txt file in the project root directory.

    点赞 评论
  • weixin_41568183
    零零乙 2016-08-18 09:53

    For multiple files you can use:

    static void out(String[] name, String[] content) {
    
        File path = new File(System.getProperty("user.dir") + File.separator + "OUT");
    
        for (File file : path.listFiles())
            if (!file.isDirectory())
                file.delete();
        path.mkdirs();
    
        File c;
    
        for (int i = 0; i != name.length; i++) {
            c = new File(path + File.separator + name[i] + ".txt");
            try {
                c.createNewFile();
                FileWriter fiWi = new FileWriter(c.getAbsoluteFile());
                BufferedWriter buWi = new BufferedWriter(fiWi);
                buWi.write(content[i]);
                buWi.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    It's working great.

    点赞 评论
  • weixin_41568208
    北城已荒凉 2018-04-04 15:51

    Here are some of the possible ways to create and write a file in Java :

    Using FileOutputStream

    try {
      File fout = new File("myOutFile.txt");
      FileOutputStream fos = new FileOutputStream(fout);
      BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
      bw.write("Write somthing to the file ...");
      bw.newLine();
      bw.close();
    } catch (FileNotFoundException e){
      // File was not found
      e.printStackTrace();
    } catch (IOException e) {
      // Problem when writing to the file
      e.printStackTrace();
    }
    

    Using FileWriter

    try {
      FileWriter fw = new FileWriter("myOutFile.txt");
      fw.write("Example of content");
      fw.close();
    } catch (FileNotFoundException e) {
      // File not found
      e.printStackTrace();
    } catch (IOException e) {
      // Error when writing to the file
      e.printStackTrace();
    }
    

    Using PrintWriter

    try {
      PrintWriter pw = new PrintWriter("myOutFile.txt");
      pw.write("Example of content");
      pw.close();
    } catch (FileNotFoundException e) {
      // File not found
      e.printStackTrace();
    } catch (IOException e) {
      // Error when writing to the file
      e.printStackTrace();
    }
    

    Using OutputStreamWriter

    try {
      File fout = new File("myOutFile.txt");
      FileOutputStream fos = new FileOutputStream(fout);
      OutputStreamWriter osw = new OutputStreamWriter(fos);
      osw.write("Soe content ...");
      osw.close();
    } catch (FileNotFoundException e) {
      // File not found
      e.printStackTrace();
    } catch (IOException e) {
      // Error when writing to the file
      e.printStackTrace();
    }
    

    For further check this tutorial about How to read and write files in Java .

    点赞 评论
  • csdnceshi52
    妄徒之命 2018-06-14 04:53

    In Java 8 use Files and Paths and using try-with-resources construct.

    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class WriteFile{
        public static void main(String[] args) throws IOException {
            String file = "text.txt";
            System.out.println("Writing to file: " + file);
            // Files.newBufferedWriter() uses UTF-8 encoding by default
            try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
                writer.write("Java\n");
                writer.write("Python\n");
                writer.write("Clojure\n");
                writer.write("Scala\n");
                writer.write("JavaScript\n");
            } // the file will be automatically closed
        }
    }
    
    点赞 评论
  • csdnceshi66

    best way is to use Java7: Java 7 introduces a new way of working with the filesystem, along with a new utility class – Files. Using the Files class, we can create, move, copy, delete files and directories as well; it also can be used to read and write to a file.

    public void saveDataInFile(String data) throws IOException {
        Path path = Paths.get(fileName);
        byte[] strToBytes = data.getBytes();
    
        Files.write(path, strToBytes);
    }
    

    Write with FileChannel If you are dealing with large files, FileChannel can be faster than standard IO. The following code write String to a file using FileChannel:

    public void saveDataInFile(String data) 
      throws IOException {
        RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
        FileChannel channel = stream.getChannel();
        byte[] strBytes = data.getBytes();
        ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
        buffer.put(strBytes);
        buffer.flip();
        channel.write(buffer);
        stream.close();
        channel.close();
    }
    

    Write with DataOutputStream

    public void saveDataInFile(String data) throws IOException {
        FileOutputStream fos = new FileOutputStream(fileName);
        DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
        outStream.writeUTF(data);
        outStream.close();
    }
    

    Write with FileOutputStream

    Let’s now see how we can use FileOutputStream to write binary data to a file. The following code converts a String int bytes and writes the bytes to file using a FileOutputStream:

    public void saveDataInFile(String data) throws IOException {
        FileOutputStream outputStream = new FileOutputStream(fileName);
        byte[] strToBytes = data.getBytes();
        outputStream.write(strToBytes);
    
        outputStream.close();
    }
    

    Write with PrintWriter we can use a PrintWriter to write formatted text to a file:

    public void saveDataInFile() throws IOException {
        FileWriter fileWriter = new FileWriter(fileName);
        PrintWriter printWriter = new PrintWriter(fileWriter);
        printWriter.print("Some String");
        printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
        printWriter.close();
    }
    

    Write with BufferedWriter: use BufferedWriter to write a String to a new file:

    public void saveDataInFile(String data) throws IOException {
        BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
        writer.write(data);
    
        writer.close();
    }
    

    append a String to the existing file:

    public void saveDataInFile(String data) throws IOException {
        BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
        writer.append(' ');
        writer.append(data);
    
        writer.close();
    }
    
    点赞 评论

相关推荐