Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

Java Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

> CHECK OUT THE COURSE

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.

Java bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE
Generic footer banner
Comments are closed on this article!