1. Overview
In this quick tutorial, we’ll write a List of Strings into a text file in Java in different ways. First, we’ll discuss FileWriter, then BufferedWriter, and finally, Files.writeString.
2. Using FileWriter
The java.io package contains a FileWriter class that we can use to write character data to a file. If we look at the hierarchy, we’ll see that the FileWriter class extends the OutputStreamWriter class, which in turn extends the Writer class.
Let’s have a look at the constructors available to initialize a FileWriter:
FileWriter f = new FileWriter(File file);
FileWriter f = new FileWriter(File file, boolean append);
FileWriter f = new FileWriter(FileDescriptor fd);
FileWriter f = new FileWriter(File file, Charset charset);
FileWriter f = new FileWriter(File file, Charset charset, boolean append);
FileWriter f = new FileWriter(String fileName);
FileWriter f = new FileWriter(String fileName, Boolean append);
FileWriter f = new FileWriter(String fileName, Charset charset);
FileWriter f = new FileWriter(String fileName, Charset charset, boolean append);
Note that all the constructors of the FileWriter class assume that the default byte-buffer size and the default character encoding are acceptable.
Now, let’s learn how to write a List of Strings into a text file using FileWriter:
FileWriter fileWriter = new FileWriter(TEXT_FILENAME);
for (String str : stringList) {
fileWriter.write(str + System.lineSeparator());
}
fileWriter.close();
return TEXT_FILENAME;
One important thing to note in the example is that the FileWriter creates the sampleTextFile.txt if it isn’t present already. If the file exists, then we can overwrite it or append it depending on the choice of the constructor.
3. Using BufferedWriter
The java.io package contains a BufferedWriter class that can be used with other Writers to write character data with better performance. But how is it more efficient?
When we use BufferedWriter, the characters are written to the buffer instead of the disk. When the buffer gets filled, all the data is written to the disk in one go, resulting in reduced traffic from/to the disk, and hence, contributing to better performance.
If we talk about the hierarchy, the BufferedWriter class extends the Writer class.
Let’s have a look at the constructors available to initialize a BufferedWriter:
BufferedWriter b = new BufferedWriter(Writer w);
BufferedWriter b = new BufferedWriter(Writer w, int size);
Note that it takes the default value if we don’t specify the buffer size.
Now, let’s explore how to write a List of Strings into a text file using BufferedWriter:
BufferedWriter br = new BufferedWriter(new FileWriter(TEXT_FILENAME));
for (String str : stringList) {
br.write(str + System.lineSeparator());
}
br.close();
return TEXT_FILENAME;
In the above code, we’ve wrapped FileWriter with BufferedWriter, which results in reducing read calls and, in turn, improving performance.
3. Using Files.writeString
The java.nio package contains a method writeString() from the Files class to write characters into a file. This method was introduced in Java 11.
Let’s have a look at the two overloaded methods available in java.nio.file.Files:
public static Path writeString(Path path, CharSequence csq, OpenOption… options) throws IOException
public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOption… options) throws IOException
Note that in the first method, we don’t have to specify the Charset. By default, it takes UTF-8 Charset, whereas in the second method, we can specify the Charset. Finally, let’s learn how to write a List of Strings into a text file using Files.writeString:
Path filePath = Paths.get(TEXT_FILENAME);
Files.deleteIfExists(filePath);
Files.createFile(filePath);
for (String str : stringList) {
Files.writeString(filePath, str + System.lineSeparator(),
StandardOpenOption.APPEND);
}
return filePath.toString();
In the example above, we deleted the file if it already existed and then created a file using Files.createFile method. Note that we have set OpenOption field to StandardOperation.APPEND, which means the file will open in append mode. If we don’t specify OpenOption, then we can expect two things to happen:
- The file will be overwritten if it’s already present
- File.writeString will create a new file and write on it if the file doesn’t exist
4. Testing
For JUnit tests, let’s define a List of Strings:
private static final List<String> stringList = Arrays.asList("Hello", "World");
Here, we’ll find out the count of lines of the output file using the NIO Files.lines and count(). The count should be equal to the number of Strings in the List.
Now, let’s head to testing of our FileWriter implementation:
@Test
public void givenUsingFileWriter_whenStringList_thenGetTextFile() throws IOException {
String fileName = FileWriterExample.generateFileFromStringList(stringList);
long count = Files.lines(Paths.get(fileName)).count();
assertTrue("No. of lines in file should be equal to no. of Strings in List", ((int) count) == stringList.size());
}
Next, we’ll test the BufferedWriter implementation:
@Test
public void givenUsingBufferedWriter_whenStringList_thenGetTextFile() throws IOException {
String fileName = BufferedWriterExample.generateFileFromStringList(stringList);
long count = Files.lines(Paths.get(fileName)).count();
assertTrue("No. of lines in file should be equal to no. of Strings in List", ((int) count) == stringList.size());
}
Finally, let’s test our Files.writeString implementation:
@Test
public void givenUsingFileWriteString_whenStringList_thenGetTextFile() throws IOException {
String fileName = FileWriteStringExample.generateFileFromStringList(stringList);
long count = Files.lines(Paths.get(fileName)).count();
assertTrue("No. of lines in file should be equal to no. of Strings in List", ((int) count) == stringList.size());
}
5. Conclusion
In this article, we explored three common ways of writing a List of Strings into a text file. Also, we tested our implementation by writing JUnit tests.
As always, the complete code for the tutorial is available over on GitHub.
