{"id":326886,"date":"2023-09-09T18:15:10","date_gmt":"2023-09-09T18:15:10","guid":{"rendered":"https:\/\/www.baeldung.com\/?p=165322"},"modified":"2023-09-09T18:15:10","modified_gmt":"2023-09-09T18:15:10","slug":"closing-java-io-streams","status":"publish","type":"post","link":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/2023\/09\/09\/closing-java-io-streams\/","title":{"rendered":"Closing Java IO Streams"},"content":{"rendered":"

<\/p>\n

\"\"<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

It’s important to ensure the proper closing of IO streams within the realm of Java IO operations. This is significant for resource management and code robustness.<\/p>\n

In this tutorial, we’ll explore in detail why it’s necessary to close IO streams<\/strong>.<\/p>\n

2. What Happens When IO Streams Aren’t Closed?<\/h2>\n
<\/div>\n

It’s always a good practice to explicitly close IO streams right after finishing all operations on them. Neglecting to close them may cause various issues.<\/p>\n

In this section, we’ll take a look at these issues.<\/p>\n

2.1. Resource Leakage<\/h3>\n
<\/div>\n

Whenever we open an IO steam, it always takes up a bit of system resources. The resources aren’t released until the IO stream close()<\/em> method is called. <\/strong><\/p>\n

Certain IO stream implementations can close themselves automatically within their finalize()<\/em> method. The finalize()<\/em> method is invoked whenever the garbage collector<\/a> (GC) is triggered.<\/p>\n

However, there’s no guarantee that the GC will be invoked, nor on when it will be called. It’s possible that the resources run out before the GC is called. Therefore, we shouldn’t solely depend on GC to reclaim system resources.<\/strong><\/p>\n

2.2. Data Corruption<\/h3>\n
<\/div>\n

We often wrap a BufferedOutputStream<\/em><\/a> around an OutputStream<\/em><\/a> to provide buffered capability to reduce the overhead of each write operation. It’s a common practice and aims to improve the performance in writing data.<\/p>\n

The internal buffer within the BufferedOutputStream<\/em> is a staging area for data that is for temporary storage. Whenever the buffer reaches a certain size or the flush()<\/em> method is called, the data will be written to the destination.<\/p>\n

After we finish writing data to the BufferedOutputStream<\/em>, it’s possible that the last chunk of data isn’t yet written to the target, leading to data corruption. Calling the close()<\/em> method invokes flush()<\/em> to write the remaining data in the buffer.\u00a0<\/strong><\/p>\n

2.3. File Locking<\/h3>\n
<\/div>\n

When we write data to a file using FileOutputStream<\/em>, some operating systems such as Windows hold the file in our application. This prevents other applications from writing or even accessing the file until the FileOutputStream<\/em> is closed.<\/strong><\/p>\n

3. Closing IO Streams<\/h2>\n
<\/div>\n

Now let’s take a look at a few approaches for closing Java IO streams. These approaches help avoid the issues we discussed above and ensure proper resource management.<\/p>\n

3.1. try-catch-finally<\/em><\/h3>\n
<\/div>\n

This is the traditional way of closing IO streams. We close IO streams in the finally<\/em><\/a> block. This ensures the close()<\/em> method is invoked no matter whether the operations are successful or not<\/strong>:<\/p>\n

InputStream inputStream = null;\r\nOutputStream outputStream = null;\r\ntry {\r\n    inputStream = new BufferedInputStream(wrappedInputStream);\r\n    outputStream = new BufferedOutputStream(wrappedOutputStream);\r\n    \/\/ Stream operations...\r\n}\r\nfinally {\r\n    try {\r\n        if (inputStream != null)\r\n            inputStream.close();\r\n    }\r\n    catch (IOException ioe1) {\r\n        log.error("Cannot close InputStream");\r\n    }\r\n    try {\r\n        if (outputStream != null)\r\n            outputStream.close();\r\n    }\r\n    catch (IOException ioe2) {\r\n        log.error("Cannot close OutputStream");\r\n    }\r\n}<\/code><\/pre>\n
As we’ve demonstrated, the close()<\/em> method could raise an IOException<\/em> as well. Therefore, we must put another try-catch<\/em><\/a> block in the finally<\/em> block when closing the IO streams. This process becomes cumbersome when there are numerous IO streams we have to deal with<\/strong>.<\/p>\n
3.2. Apache Commons IO<\/h3>\n
<\/div>\n
Apache Commons IO<\/a> is a versatile Java library that provides utility classes and methods for IO operations.<\/p>\n
To use it, let’s include the following dependency<\/a> in our pom.xml<\/em>:<\/p>\n
<dependency>\r\n    <groupId>commons-io<\/groupId>\r\n    <artifactId>commons-io<\/artifactId>\r\n    <version>2.13.0<\/version>\r\n<\/dependency><\/code><\/pre>\n
The Apache Commons library simplifies complex tasks such as closing IO streams in a finally<\/em> block:<\/p>\n
InputStream inputStream = null;\r\nOutputStream outputStream = null;\r\ntry {\r\n    inputStream = new BufferedInputStream(wrappedInputStream);\r\n    outputStream = new BufferedOutputStream(wrappedOutputStream);\r\n    \/\/ Stream operations...\r\n}\r\nfinally {\r\n    IOUtils.closeQuietly(inputStream);\r\n    IOUtils.closeQuietly(outputStream);\r\n}<\/code><\/pre>\n
IOUtils.closeQuietly()<\/em> efficiently closes IO streams without the need for null checking and taking care of exceptions that occur during the closing process.<\/strong><\/p>\n
Besides IOUtils.closeQuietly()<\/em>, the library also provides the AutoCloseInputStream<\/em> class to automate the closure of the wrapped InputStream<\/em><\/strong>:<\/p>\n
InputStream inputStream = AutoCloseInputStream.builder().setInputStream(wrappedInputStream).get();\r\nbyte[] buffer = new byte[256];\r\nwhile (inputStream.read(buffer) != -1) {\r\n    \/\/ Other operations...\r\n}<\/code><\/pre>\n
The example above reads data from the InputStream<\/em>. AutoCloseInputStream<\/em> closes the InputStream<\/em> automatically as soon as it reaches the end of the input,<\/strong> which is determined by getting -1<\/em> from the read()<\/em> method in the InputStream<\/em>. In this case, we don’t even need to call the close()<\/em> method explicitly.<\/p>\n
3.3. try-with-resources<\/em><\/h3>\n
<\/div>\n
The try-with-resources<\/em> block was introduced in Java 7. It is considered the preferred way of closing IO streams.<\/p>\n
This approach allows us to define resources within the try<\/em> statement.<\/strong> A resource is an object that must be closed when we finish using it.<\/p>\n
For instance, classes such as InputStream<\/em> and OutputStream <\/em>that implement the AutoClosable<\/em> interface are used as resources. They’ll be automatically closed after the try-catch<\/em> block. This eliminates the need to call the close()<\/em> method in the finally<\/em> block explicitly<\/strong>:<\/p>\n
try (BufferedInputStream inputStream = new BufferedInputStream(wrappedInputStream);\r\n     BufferedOutputStream outputStream = new BufferedOutputStream(wrappedOutputStream)) {\r\n    \/\/ Stream operations...\r\n}\r\n<\/code><\/pre>\n
Further advancements emerged in Java 9, refining the try-with-resources<\/em> syntax. We can declare the resource variables ahead of the try-with-resources<\/em> block, and specify their variable names directly in the try<\/em> statement<\/strong>:<\/p>\n
InputStream inputStream = new BufferedInputStream(wrappedInputStream);\r\nOutputStream outputStream = new BufferedOutputStream(wrappedOutputStream);\r\ntry (inputStream; outputStream) {\r\n    \/\/ Stream operations...\r\n}<\/code><\/pre>\n
4. Conclusion<\/h2>\n
<\/div>\n
In this article, we examined various strategies for closing IO streams, from traditional methods invoking the close()<\/em> method in the finally<\/em> blocks to more streamlined approaches offered by libraries like Apache Commons IO and the elegance of try-with-resources<\/em>.<\/p>\n
With a spectrum of various techniques, we can choose the approach that aligns best with our codebase and ensures smooth and error-free IO operations.<\/p>\n
As usual, the source code presented in the article is available over on GitHub<\/a>.<\/p>\n
\"\"<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n\n
\\\"IT\u96fb\u8166\u88dc\u7fd2
\u7acb\u523b\u8a3b\u518a\u53ca\u5831\u540d\u96fb\u8166\u88dc\u7fd2\u8ab2\u7a0b\u5427!<\/figcaption><\/figure>\r\n<\/br>Find A Teacher Form:\r\n<\/br>https:\/\/docs.google.com\/forms\/d\/1vREBnX5n262umf4wU5U2pyTwvk9O-JrAgblA-wH9GFQ\/viewform?edit_requested=true#responses\r\n<\/br><\/br>Email:\r\n<\/br>public1989two@gmail.com






\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"
\"\"<\/p>\n
Learn why it’s necessary to close IO streams and how to do it.<\/p>\n
<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/div>\n<\/div>","protected":false},"author":1978,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Closing Java IO Streams - ITTeacherITFreelance.hk","description":"Learn why it's necessary to close IO streams and how to do it. \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0"},"footnotes":""},"categories":[6,1307],"tags":[10565],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/326886"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/1978"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=326886"}],"version-history":[{"count":1,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/326886\/revisions"}],"predecessor-version":[{"id":326887,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/326886\/revisions\/326887"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=326886"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=326886"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=326886"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}