Как мне создать файл и записать его на Java?

1145

Каков самый простой способ создания и записи в (текстовый) файл на Java?

Теги:
file-io

31 ответ

1599
Лучший ответ

Обратите внимание, что каждый из приведенных ниже примеров кода может вызвать IOException. Блоки try/catch/finally были опущены для краткости. Смотрите этот учебник для получения информации об обработке исключений.

Обратите внимание, что каждый из приведенных ниже примеров кода перезапишет файл, если он уже существует.

Создание текстового файла:

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

Создание бинарного файла:

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

Пользователи Java 7+ могут использовать класс Files для записи в файлы:

Создание текстового файла:

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);

Создание бинарного файла:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);
  • 47
    Стоит отметить, что PrintWriter урезает размер файла до нуля, если файл уже существует
  • 34
    PrintWriter может использоваться (и часто используется), но не является (концептуально) подходящим классом для работы. Из документов: "PrintWriter prints formatted representations of objects to a text-output stream. " . Ответ Божо более правильный, хотя выглядит громоздким (вы всегда можете обернуть его в какой-нибудь служебный метод).
Показать ещё 10 комментариев
392

В Java 7 и выше:

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

Для этого есть полезные утилиты:

Также обратите внимание, что вы можете использовать FileWriter, но он использует кодировку по умолчанию, которая часто является плохой идеей - лучше всего указать кодировку явно.

Ниже приведен исходный ответ до ответа на Java 7


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*/}
}

См. Также: Чтение, запись и создание файлов (включая NIO2).

  • 0
    Это правильный путь к текстовому файлу, хотя фильтр BufferedWriter не всегда полезен, и кодировка должна передаваться в качестве аргумента. +1 для уточнения кодировки.
  • 5
    @leonbloy Я знаю, что это старый комментарий, но если кто-нибудь увидит это, не могли бы вы объяснить, почему это не «всегда полезно»? По крайней мере, здесь написано « самый эффективный» docs.oracle.com/javase/1.5.0/docs/api/java/io/…
Показать ещё 11 комментариев
114

Если у вас уже есть контент, который вы хотите записать в файл (а не сгенерированный на лету), добавление java.nio.file.Files в Java 7 как часть собственный ввод-вывод обеспечивает самый простой и эффективный способ достижения ваших целей.

В основном создание и запись в файл - это только одна строка, более того один простой вызов метода!

В следующем примере создаются и записываются в 6 разных файлов, чтобы продемонстрировать, как их можно использовать:

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();
}
  • 0
    Красиво сделано. Мне нравится пример file5 и file6. Чтобы протестировать файл6, убедитесь, что вы дважды запустили программу, и вы увидите, что она снова добавляет строки.
71
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();
          }
        }
    }
}
  • 18
    Не лучше ли поместить output.close () в блок finally?
  • 7
    Простой код никогда не может быть здесь ответом. Вы должны объяснить.
Показать ещё 1 комментарий
42

Вот небольшая примерная программа для создания или перезаписывания файла. Это длинная версия, поэтому ее легче понять.

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();
    }
}
33

Использование:

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

Использование try() автоматически закроет поток. Эта версия короткая, быстрая (буферизованная) и позволяет выбирать кодировку.

Эта функция была введена в Java 7.

  • 5
    Следует отметить, что это функция Java 7, поэтому она не будет работать в предыдущих версиях Java.
  • 2
    Можно использовать «константу» StandardCharsets.UTF_8 вместо строки «utf-8» (это предотвращает ошибки ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)... ) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)... - - java.nio.charset.StandardCharsets введен в Java 7
30

Очень простой способ создания и записи в файл на 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);
        }
    }
}

Ссылка: Файл создать пример в java

  • 4
    Код File.exists()/createNewFile() здесь и бессмысленный, и расточительный. Операционная система уже должна делать то же самое при создании new FileWriter() . Вы заставляете все это происходить дважды.
  • 0
    File.exists () / createNewFile () не является бессмысленным и расточительным. Я искал способ выполнить другой код в зависимости от того, присутствует файл или нет. Это было очень полезно.
Показать ещё 2 комментария
18

Здесь мы вводим строку в текстовый файл:

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

Мы можем легко создать новый файл и добавить в него контент.

  • 0
    Обратите внимание, что закрытия BufferedWriter достаточно, поскольку оно также заботится о закрытии FileWriter.
15

Если вы хотите иметь относительно безболезненный опыт, вы также можете посмотреть Apo Commons IO package, а именно FileUtils class.

Никогда не забывайте проверять сторонние библиотеки. Joda-Time для обработки даты, Apache Commons Lang StringUtils для обычных операций с строками, и это может сделать ваш код более читаемым.

Java - отличный язык, но стандартная библиотека иногда немного низкоуровневая. Мощный, но низкий уровень, тем не менее.

12

Поскольку автор не указал, требуется ли им решение для версий Java, которые были EoL'd (как Sun, так и IBM, и это технически наиболее распространенные JVM), и из-за того, что большинство людей, похоже, ответили на автор вопрос, прежде чем было указано, что это текстовый (не двоичный) файл, я решил дать свой ответ.


Прежде всего, Java 6, как правило, достигла конца жизни, и поскольку автор не уточнил, что ему нужна прежняя совместимость, я предполагаю, что это автоматически означает, что Java 7 или выше (Java 7 еще не EoL'd от IBM). Итак, мы можем посмотреть прямо на учебник ввода-вывода файлов: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

До выпуска Java SE 7 класс java.io.File был механизмом, используемым для ввода-вывода файлов, но имел несколько недостатков.

  • Многие методы не выдавали исключений, когда они терпели неудачу, поэтому было невозможно получить полезное сообщение об ошибке. Например, если сбой файла не удался, программа получит "удалить сбой", но не знает, было ли это потому, что файл не существовал, у пользователя не было разрешений или возникла какая-то другая проблема.
  • Метод переименования не работал последовательно на разных платформах.
  • Не было никакой реальной поддержки символических ссылок.
  • Желательна дополнительная поддержка метаданных, такая как права доступа к файлам, владелец файла и другие атрибуты безопасности. Доступ к метаданным файлов был неэффективным.
  • Многие из методов File не масштабировались. Запрос большого каталога на сервере может привести к зависанию. Большие каталоги также могут вызывать проблемы с ресурсами памяти, что приводит к отказу в обслуживании.
  • Невозможно было написать надежный код, который мог бы рекурсивно проходить дерево файлов и отвечать соответствующим образом, если бы существовали круговые символические ссылки.

Ну что ж, это исключает java.io.File. Если файл не может быть написан/добавлен, вы, возможно, не сможете даже знать, почему.


Мы можем продолжить изучение учебника: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Если у вас есть все строки, вы заранее напишите (добавьте) в текстовый файл, рекомендуется использовать https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# написать-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption...-

Вот пример (упрощенный):

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

Другой пример (append):

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

Если вы хотите записать содержимое файла по ходу: 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...-

Упрощенный пример (Java 8 или выше):

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

Другой пример (append):

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

Эти методы требуют минимальных усилий для части автора и должны быть предпочтительнее всех остальных при записи в [текстовые] файлы.

  • 0
    «Если файл не может быть записан / добавлен, вы можете даже не знать, почему» - это неправильно. Вы будете точно знать, почему, из текста FileNotFoundException который выбрасывается при сбое операции.
  • 0
    «Многие методы не генерировали исключения при сбое, поэтому было невозможно получить полезное сообщение об ошибке. Например, если удаление файла завершилось неудачно, программа получит« delete fail », но не узнает, так ли это файл не существует, у пользователя нет прав доступа или возникла другая проблема. "
Показать ещё 3 комментария
9

Использование:

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);
}
  • 0
    это самый простой способ, который я нашел ... все проблемы решены здесь, и только текст должен быть вставлен
9

Если вы по какой-то причине хотите отделить действие создания и записи, эквивалент Java touch -

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() выполняется проверка существования и файл, создаваемый атомарно. Это может быть полезно, если вы хотите, чтобы вы были создателем файла, прежде чем писать его, например.

  • 1
    [touch] также обновляет временную метку файла как побочный эффект (если он уже существует). Есть ли у этого побочный эффект?
  • 0
    @ Ape-inago: В моей системе это не так (просто возвращает false и не влияет на файл). Я имел в виду не touch в общем смысле, а скорее в его обычном вторичном использовании для создания файла без записи в него данных. Документированная цель касания - обновить временную метку в файле. Создание файла, если он не существует, на самом деле является побочным эффектом, и его можно отключить переключателем.
Показать ещё 1 комментарий
8

Я думаю, что это самый короткий путь:

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();
7

Чтобы создать файл без перезаписи существующего файла:

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
}
6

Вот некоторые из возможных способов создания и записи файла в Java:

Использование 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();
}

Использование 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();
}

Использование 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();
}

Использование 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();
}

Для дальнейшей проверки этого учебника о том, как читать и писать файлы на Java.

  • 0
    Просто интересно ... не должны ли FileWriter или OutputStreamWriter быть закрыты в блоке finally?
  • 0
    @WolfgangSchreurs, да, это даже лучше, мне нужно переместить объявление переменной за пределы блока try, чтобы это можно было сделать.
Показать ещё 2 комментария
6
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");
    }
}
  • 0
    Эти последовательности exists()/createNewFile() буквально пустая трата времени и пространства.
6
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();
        }
    }
}
  • 0
    Эти последовательности exists()/createNewFile() буквально пустая трата времени и пространства.
5

Только одна строка! path и line являются строками

import java.nio.file.Files;
import java.nio.file.Paths;

Files.write(Paths.get(path), lines.getBytes());
  • 0
    Гм, автор явно указал «текстовые» файлы. И текстовые файлы состоят из символов. Двоичные файлы состоят из байтов. Кроме того, неясно, что такое lines . Если это java.lang.String , то вызов getBytes() байты с использованием кодировки платформы по умолчанию , что не очень хорошо в общем случае.
5

Самый простой способ найти:

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

Вероятно, он работает только на 1.7 +.

4

Для нескольких файлов вы можете использовать:

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();
        }
    }
}

Он отлично работает.

4

Это стоит попробовать для Java 7 +:

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

Это выглядит многообещающим...

4

Если мы используем Java 7 и выше, а также знаем, какой контент будет добавлен (добавлен) в файл, мы можем использовать метод newBufferedWriter в NIO пакет.

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();
    }
}

Есть несколько замечаний:

  • Всегда хорошая привычка указывать кодировку кодировки и для этого мы имеем константу в классе StandardCharsets.
  • В коде используется оператор try-with-resource, в котором ресурсы автоматически закрываются после попытки.

Хотя OP не спрашивал, но на всякий случай мы хотим искать строки с определенным ключевым словом, например. confidential мы можем использовать потоковые API в 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();
}
4

Просто включите этот пакет:

java.nio.file

И затем вы можете использовать этот код для записи файла:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
4

Чтение и запись файлов с использованием ввода и вывода:

//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");
        }
    }
}
3

лучший способ - использовать Java7: Java 7 представляет новый способ работы с файловой системой, а также новый класс утилиты - Files. Используя класс Files, мы можем создавать, перемещать, копировать, удалять файлы и каталоги; его также можно использовать для чтения и записи в файл.

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

    Files.write(path, strToBytes);
}

Запись с помощью FileChannel Если вы имеете дело с большими файлами, FileChannel может быть быстрее стандартного ввода-вывода. Следующий код записывает String в файл с помощью 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();
}

Запись с помощью 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();
}

Запись с помощью FileOutputStream

Теперь посмотрим, как мы можем использовать FileOutputStream для записи двоичных данных в файл. Следующий код преобразует строковые байты и записывает байты в файл с помощью 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 мы можем использовать PrintWriter для записи форматированного текста в файл:

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();
}

Напишите с помощью BufferedWriter: используйте BufferedWriter для записи String в новый файл:

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

    writer.close();
}

добавьте строку в существующий файл:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}
3

Вы даже можете создать временный файл, используя системное свойство, которое не зависит от используемой ОС.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");
3

Есть несколько простых способов, например:

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();
  • 0
    bw не используется.
  • 0
    И точка перезаписи файла новым контентом не указана.
2

Используя Google Guava, мы можем создавать и писать в файл очень легко.

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);
    }
}

В примере создается новый файл fruits.txt в корневом каталоге проекта.

2

Чтение коллекции с клиентами и сохранение в файл с помощью 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();
        }
    }
}
1

В Java 8 используйте файлы и пути и используйте конструкцию try-with-resources.

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
    }
}
0

Создание образца файла:

try {
    File file = new File ("c:/new-file.txt");
    if(file.createNewFile()) {
        System.out.println("Successful created!");
    }
    else {
        System.out.println("Failed to create!");
    }
}
catch (IOException e) {
    e.printStackTrace();
}
Сообщество Overcoder
Наверх
Меню