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


Ответы:


1735

Обратите внимание, что каждый из приведенных ниже примеров кода может выдать 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, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

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

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);

58
Стоит отметить, что PrintWriter урезает размер файла до нуля, если файл уже существует
Covar

34
PrintWriter может использоваться (и часто используется), но не является (концептуально) подходящим классом для работы. Из документов: "PrintWriter prints formatted representations of objects to a text-output stream. "ответ Божо более правильный, хотя и выглядит громоздким (вы всегда можете обернуть его каким-нибудь служебным методом).
leonbloy

14
Итак, где будет создан текстовый файл после того, как приложение будет собрано и использовано на другом ПК, поскольку мы не указали путь?
Марлон Абейкун

13
@MarlonAbeykoon Хороший вопрос. Ответ в том, что он создаст текстовый файл в рабочем каталоге . Рабочий каталог - это каталог, из которого вы запускаете программу. Например, если вы выполняете свою программу из командной строки, то рабочим каталогом будет тот каталог, в котором вы находитесь в данный момент (в Linux введите «pwd», чтобы увидеть текущий рабочий каталог). Или, если дважды щелкнуть файл JAR на рабочем столе, чтобы запустить его, рабочим каталогом будет рабочий стол.
Майкл

8
writer.close()должен быть в окончательном блоке
Тьерри

416

В 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).


5
@leonbloy Я знаю, что это старый комментарий, но если кто-нибудь увидит это, не могли бы вы объяснить, почему это не «всегда полезно»? По крайней мере, здесь написано « самый
Хуан,

14
Похоже, что писатель не имеет метода writeln (). Он только написал ()
YankeeWhiskey

10
Если вы измените тип писателя на BufferedWriter (который на самом деле), вы можете использовать writer.newLine ()
Niek

4
Кажется неуместным пытаться поймать в конце концов. Я знаю причину, но это похоже на запах кода.
ashes999

4
@ Тренго Это делает. Вызов close()любого потока, обернутого вокруг любого другого, также закроет все внутренние потоки.
Фонд Моника иск

132

Если у вас уже есть контент, который вы хотите записать в файл (а не сгенерированный на лету), 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();
}

Красиво сделано. Мне нравится пример file5 и file6. Чтобы протестировать файл6, убедитесь, что вы дважды запустили программу, и вы увидите, что она снова добавляет строки.
Tazboy

76
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
Простой код никогда не может быть здесь ответом. Вы должны объяснить.
маркиз Лорн

7
на самом деле это не скомпилируется, output.close()выдает IOException
Боб

43

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

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

39

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

7
File.exists()/createNewFile()Код здесь как бессмысленно и расточительно. Операционная система уже должна делать то же самое при new FileWriter()создании. Вы заставляете все это происходить дважды.
маркиз Лорн

1
File.exists () / createNewFile () не является бессмысленным и расточительным. Я искал способ выполнить другой код в зависимости от того, присутствует файл или нет. Это было очень полезно.
KirstieBallance

2
Я использовал этот метод, но вы должны знать, что он каждый раз перезаписывает файл. Если вы хотите, чтобы он добавлялся в случае, если файл существует, вы должны создать его экземпляр FileWriterследующим образом:new FileWriter(file.getAbsoluteFile(),true)
Adelin

2
Это как бессмысленно и расточительно, по той причине , я заявил. Вы вызываете два теста существования, два создания и удаление: и вы не выполняете здесь другой код в зависимости от того, присутствует ли файл или нет.
Маркиз Лорн

34

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

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.
Дан Темпл

3
Можно использовать «константу» StandardCharsets.UTF_8вместо строки «utf-8» (это предотвращает ошибки опечаток) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...- java.nio.charset.StandardCharsetsвведено в Java 7
Ralph

20

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

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

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


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

17

Поскольку автор не указал, требуется ли им решение для версий 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);

Другой пример (приложение):

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");
    [...]
}

Другой пример (приложение):

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

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


«Если файл не может быть записан / добавлен, вы можете даже не знать, почему» - это неправильно. Вы будете точно знать, почему, из текста, FileNotFoundExceptionкоторый выбрасывается при сбое операции.
маркиз Лорн

«Многие методы не генерировали исключения при сбое, поэтому было невозможно получить полезное сообщение об ошибке. Например, если удаление файла не удалось, программа получит« удалить ошибку », но не будет знать, произошло ли это потому, что файл не существует, у пользователя нет прав доступа или возникла другая проблема. "
afk5min

Прочитайте, что я написал. « Если файл не может быть записан / добавлен, вы, возможно, даже не сможете получить полезное сообщение об ошибке» неверно по указанной мной причине и остается таковым. Вы меняете тему. Ваш собственный предмет.
Маркиз Лорн

Я рассмотрю встроенные реализации для типичных файловых систем (которые были бы в OpenJDK, но у меня нет оснований полагать, что эта часть будет отличаться в проприетарном Oracle JDK или значительно отличаться в проприетарном IBM JDK, среди прочих) и обновлю мой ответ основан на этих выводах. Ваш комментарий имеет смысл - просто потому, что у «многих методов» могут быть проблемы, автор четко заявил, что им важна только операция записи / добавления в файл.
afk5min

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

16

Если вы хотите получить сравнительно безболезненный опыт, вы также можете взглянуть на пакет Apache Commons IO , а точнее на FileUtilsкласс .

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

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


1
Самый простой способ записи файла в FileUtilsэто static void write(File file, CharSequence data). Пример использования: import org.apache.commons.io.FileUtils; FileUtils.write(new File("example.txt"), "string with data");. FileUtilsтакже имеет writeLines, который занимает Collectionлинии.
Рори О'Кейн

12

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

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] также обновляет временную метку файла как побочный эффект (если он уже существует). Есть ли у этого побочный эффект?
Обезьяна

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

По какой-то причине, например, что? Эти exists()/createNewFile()последовательности буквально пустая трата времени и пространства.
маркиз Лорн

12

Вот некоторые из возможных способов создания и записи файла в 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 .


Просто интересно ... разве не должно быть FileWriterили OutputStreamWriterбыть закрыто в окончательном блоке?
Вольфганг Шреурс

@WolfgangSchreurs, да, это даже лучше, мне нужно переместить объявление переменных за пределы блока try, чтобы это можно было сделать.
Мехди

Я только что понял, что, используя автоматическое закрытие, даже если оно чище, нет необходимости объявлять переменные вне блока, и ресурсы будут закрываться автоматически, даже если возникает исключение (нужно явно добавить блок finally). См .: docs.oracle.com/javase/tutorial/essential/exceptions/…
Вольфганг

Я бы добавил try-with-resources в качестве отдельного примера (чтобы разделить разные возможности). Вы знаете, что SOF - это совместный веб-сайт. Если хотите, у вас есть право, измените ответ.
Мехди

10

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

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

это самый простой способ, который я нашел ... все проблемы здесь решены, и нужно вставить только текст
Rohit ZP

10

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

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

    outputStream.close();
}

Напишите с 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 для записи строки в новый файл:

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

9

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

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

8

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

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
}

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

Эти exists()/createNewFile()последовательности буквально пустая трата времени и пространства.
маркиз Лорн

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

Эти exists()/createNewFile()последовательности буквально пустая трата времени и пространства.
маркиз Лорн

5

Только одна строка! pathи lineстроки

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

Files.write(Paths.get(path), lines.getBytes());

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

5

Самый простой способ, который я могу найти:

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

Это, вероятно, будет работать только для 1,7+.


5

Стоит попробовать для 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();
    }
}

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

  1. Всегда полезно задавать кодировку кодировки, и для этого у нас есть константа в классе StandardCharsets.
  2. Код использует 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

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

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

4

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

java.nio.file

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

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

4

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

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

bwне используется.
Маркиз Лорн

И точка перезаписи файла новым контентом не указана.
Маркиз Лорн

3

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

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

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

2

Существует как минимум несколько способов создания файла и записи в него:

Небольшие файлы (1.7)

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

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);

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

Запись файла большего размера с использованием буферизованного потокового ввода-вывода (1.7)

В java.nio.fileпакет поддерживает канал ввода / вывода, который перемещает данные в буфер, минуя некоторые из слоев , которые могут узким местом Поток ввода / вывода.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

Этот подход предпочтителен из-за его эффективной производительности, особенно при выполнении большого количества операций записи. Буферизованные операции имеют этот эффект, поскольку они не обязаны вызывать метод записи операционной системы для каждого отдельного байта, что сокращает дорогостоящие операции ввода-вывода.

Использование NIO API для копирования (и создания нового) файла с Outputstream (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Существуют также дополнительные методы, которые позволяют копировать все байты из входного потока в файл.

FileWriter (текст) (<1,7)

Записывает непосредственно в файл (меньше производительности) и должен использоваться только тогда, когда количество записей меньше. Используется для записи символьно-ориентированных данных в файл.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (двоичный) (<1,7)

FileOutputStream предназначен для записи потоков необработанных байтов, таких как данные изображения.

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

При таком подходе следует всегда записывать массив байтов, а не писать по одному байту за раз. Ускорение может быть весьма значительным - до 10 и более раз. Поэтому рекомендуется использовать write(byte[])методы всякий раз, когда это возможно.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.