1. Overview
In this tutorial, we’ll explore the differences between different methods of reading files in Java. We’ll compare the getResourceAsStream() method and the FileInputStream class and discuss their use cases. We’ll also talk about the Files.newInputStream() method that is recommended over FileInputStream due to its memory and performance benefits.
Then we’ll look at code examples to learn how to read files using these methods.
2. Basics
Before we dive into the code examples, let’s understand the differences between getResourceAsStream() and FileInputStream and their popular use cases.
2.1. Reading Files Using getResourceAsStream()
The getResourceAsStream() method reads a file from the classpath. The file path passed to the getResourceAsStream() method should be relative to the classpath. The method returns an InputStream that can be used to read the file.
This method is commonly used to read configuration files, properties files, and other resources packaged with the application.
2.2. Reading Files Using FileInputStream
On the other hand, the FileInputStream class is used to read a file from the filesystem. This is useful when we need to read files not packaged with the application.
The file path passed to the FileInputStream constructor should be an absolute path or a path relative to the current working directory.
The FileInputStream objects can have memory and performance issues due to their use of finalizers. A better alternative to FileInputStream is the Files.newInputStream() method that works in the same way. We’ll use the Files.newInputStream() method in our code examples to read files from the filesystem.
These methods are commonly used to read files present externally on the filesystem such as log files, user data files, and secret files.
3. Code Example
Let’s look at an example to demonstrate the usage of getResourceAsStream() and Files.newInputStream(). We’ll create a simple utility class that reads a file using both methods. Then we’ll test the methods by reading sample files both from the classpath and the filesystem.
3.1. Using getResourceAsStream()
First, let’s look at the usage of the getResourceAsStream() method. We’ll create a class named FileIOUtil and add a method that reads a file from the resources:
static String readFileFromResource(String filePath) {
try (InputStream inputStream = FileIOUtil.class.getResourceAsStream(filePath)) {
String result = null;
if (inputStream != null) {
result = new BufferedReader(new InputStreamReader(inputStream))
.lines()
.collect(Collectors.joining("\n"));
}
return result;
} catch (IOException e) {
LOG.error("Error reading file:", e);
return null;
}
}
In this method, we obtain an InputStream by passing the file’s path as an argument to the getResourceAsStream() method. This file path should be relative to the classpath. We then read the contents of the file using a BufferedReader. The method reads the contents line by line and joins them using the Collectors.joining() method. Finally, we return the contents of the file as a String.
In case of an exception, such as the file not being found, we catch the exception and return null.
3.2. Using Files.newInputStream()
Next, let’s define a similar method using the Files.newInputStream() method:
static String readFileFromFileSystem(String filePath) {
try (InputStream inputStream = Files.newInputStream(Paths.get(filePath))) {
return new BufferedReader(new InputStreamReader(inputStream))
.lines()
.collect(Collectors.joining("\n"));
} catch (IOException e) {
LOG.error("Error reading file:", e);
return null;
}
}
In this method, we use the Files.newInputStream() method to read the file from the filesystem. The file path should be absolute or relative to the project directory. Similar to the previous method, we read and return the contents of the file.
4. Testing
Now, let’s test both methods by reading a sample file. We’ll observe how file paths are passed to the methods in the case of a resource file and an external file.
4.1. Reading Files From Classpath
First, we’ll compare how the methods read a file from the classpath. Let’s create a file named test.txt under the src/main/resources directory and add some content to it:
Hello!
Welcome to the world of Java NIO.
We’ll read this file using both methods and validate the contents:
@Test
void givenFileUnderResources_whenReadFileFromResource_thenSuccess() {
String result = FileIOUtil.readFileFromResource("/test.txt");
assertNotNull(result);
assertEquals(result, "Hello!\n" + "Welcome to the world of Java NIO.");
}
@Test
void givenFileUnderResources_whenReadFileFromFileSystem_thenSuccess() {
String result = FileIOUtil.readFileFromFileSystem("src/test/resources/test.txt");
assertNotNull(result);
assertEquals(result, "Hello!\n" + "Welcome to the world of Java NIO.");
}
As we can see, both methods read the file test.txt and return its contents. We then compare the contents to ensure they match the expected value. The difference between the two methods is the file path we pass as an argument.
The readFileFromResource() method expects a path relative to the classpath. Since the file is directly under the src/main/resources directory, we pass /test.txt as the file path.
On the other hand, the readFileFromFileSystem() method expects an absolute path or a path relative to the current working directory. We pass src/main/resources/test.txt as the file path. Alternatively, we could pass the absolute path to the file like /path/to/project/src/main/resources/test.txt.
4.2. Reading Files From Filesystem
Next, let’s test how the methods read a file from the filesystem. We’ll create a file named external.txt outside the project directory and try to read this file using both methods.
Let’s create test methods to read the file using both methods:
@Test
void givenFileOutsideResources_whenReadFileFromFileSystem_thenSuccess() {
String result = FileIOUtil.readFileFromFileSystem("../external.txt");
assertNotNull(result);
assertEquals(result, "Hello!\n" + "Welcome to the world of Java NIO.");
}
@Test
void givenFileOutsideResources_whenReadFileFromResource_thenNull() {
String result = FileIOUtil.readFileFromResource("../external.txt");
assertNull(result);
}
Here, we pass the relative path to the external.txt file. The readFileFromFileSystem() method reads the file directly from the filesystem and returns its contents.
If we try to read the file using the readFileFromResource() method, it returns null because the file is outside the classpath.
5. Conclusion
In this article, we explored the differences between reading a file from the classpath using getResourceAsStream() and reading a file from the filesystem using Files.newInputStream(). We discussed the use cases and behaviors of both methods and looked at examples that demonstrate their usage.
As always, the code examples are available over on GitHub.