Как мне создать файл и записать его на Java?
Какой самый простой способ создать и записать (текстовый) файл в Java?
36 ответов
Обратите внимание, что каждый из приведенных ниже примеров кода может 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);
В Java 7 и выше:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("filename.txt"), "utf-8"))) {
writer.write("something");
}
Для этого есть полезные утилиты:
- FileUtils.writeStringtoFile (..) из commons-io
- Files.write (..) из гуавы
Обратите внимание, что вы можете использовать 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).
Если у вас уже есть контент, который вы хотите записать в файл (а не сгенерированный на лету), 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();
}
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();
}
}
}
}
Очень простой способ создания и записи в файл на 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
Вот небольшой пример программы для создания или перезаписи файла. Это длинная версия, поэтому ее легче понять.
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();
}
}
Использование:
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.
Этот ответ сосредоточен на Java 8 и пытается охватить все детали, необходимые для экзамена Java Professional. Он пытается объяснить, почему существуют разные подходы. У каждого из них есть свои преимущества, и каждый может быть самым простым в данном сценарии.
Участвующие классы включают:
.
├── OutputStream
│ └── FileOutputStream
├── Writer
│ ├── OutputStreamWriter
│ │ └── FileWriter
│ ├── BufferedWriter
│ └── PrintWriter (Java 5+)
└── Files (Java 7+)
FileOutputStream
Этот класс предназначен для записи потоков необработанных байтов. ВсеWriterподходы ниже полагаются на этот класс явно или скрытно.
try (FileOutputStream stream = new FileOutputStream("file.txt");) {
byte data[] = "foo".getBytes();
stream.write(data);
} catch (IOException e) {}
Обратите внимание, что оператор try-with-resources заботится оstream.close() и закрытие потока сбрасывает его, например stream.flush() (все приведенные ниже примеры используют этот подход).
OutputStreamWriter
Этот класс является мостом между символьными потоками и байтовыми потоками. Он может обернутьFileOutputStream, и напишите строки:
Charset utf8 = StandardCharsets.UTF_8;
try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File("file.txt")), utf8)) {
writer.write("foo");
} catch (IOException e) {}
BufferedWriter
Этот класс записывает текст в поток вывода символов, буферизуя символы, чтобы обеспечить эффективную запись отдельных символов, массивов и строк.
Он может обернуть OutputStreamWriter:
try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("file.txt"))))) {
writer.write("foo");
writer.newLine(); // method provided by BufferedWriter
} catch (IOException e) {}
До Java 5 это был лучший подход для больших файлов (с обычным блоком try/catch).
FileWriter
Это подкласс OutputStreamWriter, и это удобный класс для записи файлов символов:
boolean append = false;
try(FileWriter writer = new FileWriter("file.txt", append) ){
writer.write("foo");
writer.append("bar");
} catch (IOException e) {}
Ключевым преимуществом является то, что у него есть необязательный appendаргумент конструктора, который определяет, добавляется ли он к существующему файлу или перезаписывает его. Обратите внимание, что поведение добавления / перезаписи не контролируетсяwrite() а также append()методы, которые ведут себя почти одинаково.
Обратите внимание, что:
- Буферизации нет, но для обработки больших файлов ее можно обернуть в
BufferedWriter. FileWriterиспользует кодировку по умолчанию. Часто предпочтительнее явно указывать кодировку
PrintWriter
Этот класс печатает форматированные представления объектов в поток вывода текста. Под капотом он такой же, как иBufferedWriter подход выше (new BufferedWriter(new OutputStreamWriter(new FileOutputStream(...)))). PrintWriter был представлен в Java 5 как удобный способ вызова этой идиомы и добавляет дополнительные методы, такие как printf() а также println().
Методы этого класса не генерируют исключения ввода-вывода. Проверить ошибки можно позвонивcheckError(). Местом назначения экземпляра PrintWriter может быть File, OutputStream или Writer. Вот пример записи в файл:
try (PrintWriter writer = new PrintWriter("file.txt", "UTF-8")) {
writer.print("foo");
writer.printf("bar %d $", "a", 1);
writer.println("baz");
} catch (FileNotFoundException e) {
} catch (UnsupportedEncodingException e) {}
При письме в OutputStream или Writer есть необязательный autoFlushпараметр конструктора, который по умолчанию имеет значение false. в отличие отFileWriter, он перезапишет любой существующий файл.
Files.write()
Представлена Java 7 java.nio.file.Files. Files.write() позволяет создавать и записывать в файл за один вызов.
Ответ @icza показывает, как использовать этот метод. Пара примеров:
Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("foo", "bar");
try {
Files.write(Paths.get("file.txt"), "foo".getBytes(utf8));
Files.write(Paths.get("file2.txt"), lines, utf8);
} catch (IOException e) {}
Здесь нет буфера, поэтому он не подходит для больших файлов.
Files.newBufferedWriter ()
Java 7 также представила Files.newBufferedWriter() что позволяет легко получить BufferedWriter:
Charset utf8 = StandardCharsets.UTF_8;
try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("file.txt"), utf8)) {
writer.write("foo");
} catch (IOException e) {}
Это похоже на PrintWriter, с обратной стороной отсутствия методов PrintWriter и преимуществом в том, что он не принимает исключения.
Резюме
┌───────────────────────────┬──────────────────────────┬─────────────┬──────────────┐
│ │ Buffer for │ Can specify │ Throws │
│ │ large files? │ encoding? │ IOException? │
├───────────────────────────┼──────────────────────────┼─────────────┼──────────────┤
│ OutputStreamWriter │ Wrap with BufferedWriter │ Y │ Y │
│ FileWriter │ Wrap with BufferedWriter │ │ Y │
│ PrintWriter │ Y │ Y │ │
│ Files.write() │ │ Y │ Y │
│ Files.newBufferedWriter() │ Y │ Y │ Y │
└───────────────────────────┴──────────────────────────┴─────────────┴──────────────┘
Здесь мы вводим строку в текстовый файл:
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
Мы можем легко создать новый файл и добавить в него контент.
Поскольку автор не указал, требуется ли им решение для версий 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
Если у вас есть все строки, которые вы напишете (добавите) в текстовый файл заранее, рекомендуемый подход - 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
Упрощенный пример (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("----------");
[...]
}
Эти методы требуют минимальных усилий со стороны автора и должны быть предпочтительнее всех остальных при записи в [текстовые] файлы.
Если вы хотите получить сравнительно безболезненный опыт, вы также можете взглянуть на пакет Apache Commons IO, а именно: FileUtils класс
Никогда не забывайте проверять сторонние библиотеки. Joda-Time для манипулирования датами, Apache Commons LangStringUtils для обычных строковых операций и тому подобное может сделать ваш код более читабельным.
Ява - отличный язык, но стандартная библиотека иногда немного низкоуровневая. Мощный, но все же низкий уровень.
Вот некоторые из возможных способов создания и записи файла в 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.
Лучше всего использовать 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();
}
Использование:
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);
}
Если по какой-то причине вы хотите отделить процесс создания и записи, 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() делает проверку существования и файл создается атомарно. Это может быть полезно, например, если вы хотите убедиться, что вы были создателем файла, прежде чем писать в него.
Я думаю, что это самый короткий путь:
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();
Чтобы создать файл без перезаписи существующего файла:
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
}
Стоит попробовать для Java 7+:
Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());
Это выглядит многообещающе...
В 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
}
}
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");
}
}
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();
}
}
}
Самый простой способ, который я могу найти:
Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
writer.write("Hello, world!");
}
Это, вероятно, будет работать только для 1,7+.
Только одна строка!path а также line Строки
import java.nio.file.Files;
import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes());
Просто включите этот пакет:
java.nio.file
И тогда вы можете использовать этот код для записи файла:
Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
Чтение и запись файлов с использованием 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");
}
}
}
Если мы используем 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();
}
Вы даже можете создать временный файл, используя системное свойство, которое будет зависеть от того, какую ОС вы используете.
File file = new File(System.*getProperty*("java.io.tmpdir") +
System.*getProperty*("file.separator") +
"YourFileName.txt");
Для нескольких файлов вы можете использовать:
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();
}
}
}
Работает отлично.
Используя библиотеку 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 файл в корневом каталоге проекта.
Есть как минимум несколько способов создать файл и записать в него:
Маленькие файлы (1,7)
Вы можете использовать один из методов записи для записи байтов или строк в файл.
Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".getBytes();
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 для копирования (и создания нового) файла с выходным потоком (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[]) методы по возможности.