Guava Files.readLines() method in Java
In this post, we will show you how to use the Guava Files.readLines() method in Java, and explain its benefits and drawbacks. We will also compare it with other alternatives.
If you are working with files in Java, you might encounter situations where you need to read the lines from a file into a collection or perform some operations on them. For example, you might want to process a log file, or filter a text file. However, the standard Java File and Scanner classes have some limitations and drawbacks when it comes to reading lines from a file. One of them is that they do not provide a fluent and flexible API to open and close the file, catch all the exceptions, and loop through the lines.
Fortunately, there is a better way to read lines from a file in Java, using the Guava Files class. This class provides static utility methods for working with files and directories in Java. One of them is the Files.readLines() method, which reads all the lines from a file into a mutable List.
1. Overview of Files.readLines() method
The Guava Files.readLines() method is a static method that reads all the lines from a file into a mutable List. It accepts two parameters: the file to read from and the charset used to decode the input stream. It throws an IOException if an I/O error occurs. The syntax of the Files.readLines() method is as follows:
|
1 |
public static List<String> readLines(File file, `Charset` charset) throws IOException |
The file parameter is the file to read from. It must not be null or non-existent. The charset parameter is the charset used to decode the input stream. It must not be null. The return value is a List of Strings, each representing a line from the file. The line-termination characters are not included in the list elements.
2. Usage of Files.readLines() method
To use the Files.readLines() method, you need to import the com.google.common.io.Files package and create an instance of File by passing the path of the file to read from as a parameter. Then call the Files.readLines() method with the File instance and a Charset instance as parameters and store or use the List of Strings returned by the method.
For example, if you want to read all the lines from this a into a List of Strings, you can use the following code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import com.google.common.io.Files; import java.io.File; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.util.List; class Main { public static void main(String[] args) { File file = new File("foo.out"); try { List<String> lines = Files.readLines(file, StandardCharsets.UTF_8); System.out.println(lines); } catch (IOException e) { e.printStackTrace(); } } } |
3. Alternatives to Files.readLines() method
If you don’t want to use the Files.readLines() method from Guava, there are some other alternatives that you can use to read lines from a file in Java.
One alternative is to use the standard BufferedReader class, which provides a buffered reader for reading text from a character-input stream. You can use the BufferedReader.readLine() method, which reads a line of text and returns it as a String. For example, you can use the following code to read lines from a file using BufferedReader:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; import java.util.List; class Main { public static void main(String[] args) { List<String> lines = new ArrayList<>(); try (BufferedReader reader = new BufferedReader(new FileReader("foo.out"))) { String line; while ((line = reader.readLine()) != null) { lines.add(line); } } catch (IOException e) { e.printStackTrace(); } System.out.println(lines); } } |
The advantage of using this alternative is that it does not require any external dependency on Guava. It also allows you to read lines lazily and handle them as they are read. The disadvantage of using this alternative is that it requires more code and complexity than using the Files.readLines() method. You have to create and close the BufferedReader, loop through the lines, and handle the IOExceptions manually.
Another alternative is the Java 8 Stream API, which gives a way to process collections of data in a declarative way. You can use the Files.lines() method, which returns a stream of lines read from a file. For example, you can use the following code to read lines from a file using Stream:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; class Main { public static void main(String[] args) { List<String> lines = null; try (Stream<String> stream = Files.lines(Paths.get("foo.out"))) { lines = stream.collect(Collectors.toList()); } catch (IOException e) { e.printStackTrace(); } System.out.println(lines); } } |
The advantage of using this alternative is that it allows you to read lines streamingly and perform various operations on them using the Stream API. You can also specify the charset used to decode the input stream by passing a Charset instance to the Files.lines() method. The disadvantage of using this alternative is that it might not be compatible with older versions of Java. It also requires creating and closing the Stream, and handling the IOExceptions manually.
4. Benefits and drawbacks of using the Files.readLines() method
The Files.readLines() method has some benefits and drawbacks when compared with other methods of reading lines from a file in Java.
- One benefit is that it simplifies the logic of reading lines from a file and handling exceptions. You don’t have to write any boilerplate code to open and close the file and loop through the lines. You just need to call one method with two parameters and get the result.
- Another benefit is that it allows you to specify the charset used to decode the input stream. You don’t have to rely on the default charset or guess the encoding of the file. You can pass any valid
Charsetinstance to the method and ensure that the characters are decoded correctly. - One drawback is that you need to depend on the Guava library. This can be an issue if your project does not already use Guava, as you would have to include it as an external dependency. This can make your project bigger and more complicated.
- Another drawback is that it reads all the lines from the file into memory at once. This might be problematic if you are dealing with large files or limited memory resources. You might have to use another method that allows you to read lines lazily or streamingly.
5. Conclusion
In this post, we have covered how to use the Guava Files.readLines() method in Java, which is one of the methods that you can use to read lines from a file into a List of Strings. We have also explained its benefits and drawbacks, and compared it with other alternatives.
If you want to learn more about this method, you can check out the Guava official website or its GitHub repository.
Thanks for reading.
To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.
Like us? Refer us to your friends and support our growth. Happy coding :)