When working on an enterprise application, sometimes it is necessary to write the text or binary data into files in Java e.g. writing user-generated reports into the filesystem.
Though there are multiple ways of writing the files in Java, let’s quickly go through a few of them for quick reference when it is needed.
String content = "some text";
// Java 11
Files.writeString(Path.of("demo.txt"), content);
// Using Files class
Files.write(Path.of("demo.txt"), content.getBytes());
// Using BufferedWriter
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath.toFile()))) {
writer.write(content);
}
// Using FileWriter
try(FileWriter fileWriter = new FileWriter(Path.of("demo.txt").toFile())){
fileWriter.write(content);
}
// Write to binary file
try(FileOutputStream outputStream = new FileOutputStream(Path.of("demo.txt").toFile())){
byte[] strToBytes = content.getBytes();
outputStream.write(strToBytes);
}
1. Write to File with Files.writeString() – Since Java 11
With the method writeString() introduced in Java 11, we can write a String into a file using a single-line statement.
- As the name suggests, writeString() method is used to write the character data into files.
- All characters are written as they are, including the line separators. No extra characters are added.
- By default, UTF-8 character encoding is used.
- It throws IOException if an I/O error occurs writing to or creating the file, or the text cannot be encoded using the specified charset.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
Files.writeString(filePath, content);
2. Write to File with Files.write()
Files class is another method write() since Java 7 and it works similarly to writeString(). The write() method can be used to write the raw data in bytes or to write the strings in lines.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
//Write bytes
Files.write(filePath, content.getBytes());
//Write lines
List<String> lines = Arrays.asList("a", "b", "c");
Files.write(filePath, lines, StandardCharsets.UTF_8);
3. Fast Writing with FileChannel and ByteBuffer
FileChannel
can be used for reading, writing, mapping, and manipulating a file. If we are writing large files, FileChannel
can be faster than standard IO.
File channels are safe for use by multiple concurrent threads.
Path fileName = Path.of("demo.txt");
String content = "hello world !!";
try (
RandomAccessFile stream = new RandomAccessFile(filePath.toFile(),"rw");
FileChannel channel = stream.getChannel();) {
byte[] strBytes = content.getBytes();
ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
buffer.put(strBytes);
buffer.flip();
channel.write(buffer);
}
4. Write to Text File with BufferedWriter
BufferedWriter
the simplest way to write the content to a file. It writes text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.
Unless prompt output is required, it is advisable to wrap a BufferedWriter
around any Writer
whose write()
operations may be costly, such as FileWriter
and OutputStreamWriter
.
As it buffers before writing, so it results in fewer IO operations, so it improves the performance.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath.toFile()))) {
writer.write(content);
}
5. Write to File with FileWriter or PrintWriter
FileWriter
the most clean way to write files. The syntax is self-explanatory and easy to read and understand. FileWriter writes directly into the file (less performance) and should be used only when the number of writes is less.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
try(FileWriter fileWriter = new FileWriter(filePath.toFile())){
fileWriter.write(content);
}
Use PrintWriter
to write formatted text to a file. This class implements all of the print methods found in PrintStream
, so you can use all formats which you use with System.out.println()
statements.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
try(FileWriter fileWriter = new FileWriter(filePath.toFile());
PrintWriter printWriter = new PrintWriter(fileWriter);){
printWriter.print(content);
printWriter.printf("Blog name is %s", "howtodoinjava.com");
}
6. Write to Binary File with FileOutputStream
Use FileOutputStream
to write binary data to a file. FileOutputStream
is meant for writing streams of raw bytes such as image data. For writing streams of characters, consider using FileWriter
.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
try(FileOutputStream outputStream = new FileOutputStream(filePath.toFile())){
byte[] strToBytes = content.getBytes();
outputStream.write(strToBytes);
}
7. Write to File with DataOutputStream
DataOutputStream
lets an application write primitive Java data types to an output stream in a portable way. An application can then use a data input stream to read the data back in.
Path filePath = Path.of("demo.txt");
String content = "hello world !!";
try (
FileOutputStream outputStream
= new FileOutputStream(filePath.toFile());
DataOutputStream dataOutStream
= new DataOutputStream(new BufferedOutputStream(outputStream));) {
dataOutStream.writeUTF(content);
dataOutStream.writeInt(10);
dataOutStream.writeLong(100L);
}
7. Summary
- If we try to write to a file that doesn’t exist, the file will be created first and no exception will be thrown (except using
Path
method). - Always close the output stream after writing the file content to release all resources. It will also help in not corrupting the file.
- Use
PrintWriter
is used to write formatted text. - Use
FileOutputStream
to write binary data. - Use
DataOutputStream
to write primitive data types. - Use
FileChannel
to write larger files. It is the preferred way of writing files in Java 8 as well.
Happy Learning !!
Comments