Mrthfx

Here is a line reading a file into a List:

List<String> lines =

    new BufferedReader(

        new InputStreamReader(classLoader.getResourceAsStream(fileName)))

            .lines()

            .collect(Collectors.toList());

Is this correct or should I assign the BufferedReader to a variable to be able to close it later?

Well, in your concrete example, the stream opened by

classLoader.getResourceAsStream(fileName)

is never closed. This stream must be closed - it is most likely a file handle in the local system. You can close it by closing the BufferedReader, which closes the wrapped InputStreamReader, which closes the underlying InputStream. You could instead also store a reference to the original InputStream and only close this.

Please also have a look into try-with-resources, this could potentially make things easier for you here.

You should always close your resources. Closing may not be a big problem for small programs which only use a couple of files quickly, since most mature OSes will close the files for you when the process completes. However, there are usually limits on how many files you can have open at one time. It is good to be tidy, so that you don't hit those limits when you start writing bigger programs. There are also other types of resources, like network and serial ports, which you may want to let others use once your program is done with them, even if it is still running.

An alternative to closing the file manually is using try-with-resources syntax, which ensures that the file will be closed properly even in case of an error:

List<String> lines;

try(BufferedReader reader = new BufferedReader(

        new InputStreamReader(classLoader.getResourceAsStream(fileName)))) {

    lines = reader.lines().collect(Collectors.toList());

}

Wrong answer - Streams must be closed too.

One should alway close, which can be done with try-with-resources.

--However here a Stream<String> is run to its final collect, hence everything is closed.--

List<String> lines =

    new BufferedReader(

        new InputStreamReader(classLoader.getResourceAsStream(fileName),

                StandardCharsets.UTF_8))

            .lines()

            .collect(Collectors.toList());

Or:

try {

    URL url = classLoader.getResource(fileName);

    Path path = Paths.get(url.toURI());

    List<String> lines = Files.readAllLines(path); // Default UTF-8.

    Files.lines(path).forEach(System.out::println);

} catch (URISyntaxException e) {

    ...

}

A minor point is to provide a Charset, otherwise the default platform charset is used, which varies and hence makes the code not portable, especially as the resource is of fixed and known charset.

I stand corrected

From documentation:
Streams have a close() method and implement AutoCloseable interface, but nearly all stream instances do not actually need to be closed after use.

Generally, only streams whose source is an IO channel, for example a BufferedReader.lines will require closing.

Most streams are backed by collections, arrays, or generating functions, which require no special resource management. If a stream does require closing, it can be declared as a resource in a try-with-resources statement.