Technology

Common I/O Tasks in Modern Java

Posted on by miyuru
Common I/O Tasks in Modern Java

Intro

This short article concentrates on jobs that application developers are most likely to experience, especially in web applications, such as:

  • Checking out and composing text files
  • Checking out text, images, JSON from the web
  • Checking out files in a directory site
  • Checking out a ZIP file
  • Producing a momentary file or directory site

The Java API supports lots of other jobs, which are described in information in the Java I/O API guide

This post concentrates on API enhancements considering that Java 8. In specific:

Checking Out Text Files

You can check out a text file into a string like this:

String content = Files.readString(path);

Here, path is a circumstances of java.nio.Pathgotten like this:

var path = Path.of("/usr/share/dict/words");

Before Java 18, you were highly motivated to define the character encoding with any file operations that check out or compose strings. Nowadays, without a doubt the most typical character encoding is UTF-8, however for in reverse compatibility, Java utilized the “platform encoding”, which can be a tradition encoding on Windows. To guarantee mobility, text I/O operations required specifications StandardCharsets.UTF_8This is no longer required.

If you desire the file as a series of lines, call

List lines = Files.readAllLines(path);

If the file is big, procedure the lines slackly as a Stream:

try (Stream lines = Files.lines(path)) {
    . . .
}

Utilize Files.lines if you can naturally process lines with stream operations (such as map filter. Keep in mind that the stream returned by Files.lines requirements to be closed. To guarantee that this takes place, utilize a try-with-resources declaration, as in the preceding code bit.

There is no longer an excellent factor to utilize the readLine technique of java.io.BufferedReader

To divide your input into something else than lines, utilize a java.util.ScannerHere is how you can check out words, separated by non-letters:

Stream tokens = new Scanner(path).useDelimiter("\PL+").tokens();

The Scanner class likewise has techniques for checking out numbers, however it is typically easier to check out the input as one string per line, or a single string, and after that parse it.

Beware when parsing numbers from text files, because their format might be locale-dependent. The input 100.000 is 100.0 in the United States area however 100000.0 in the German location. Usage java.text.NumberFormat for locale-specific parsing. You might be able to utilize Integer.parseInt/Double.parseDouble

Composing Text Files

You can compose a string to a text file with a single call:

String content = . . .;
Files.writeString(path, content);

If you have a list of lines instead of a single string, usage:

List lines = . . .;
Files.write(path, lines);

For more basic output, utilize a PrintWriter if you wish to utilize the printf technique:

var writer = new PrintWriter(path.toFile());
writer.printf(locale, "Hello, %s, next year you'll be %d years old!%n", name, age + 1);

Keep in mind that printf is locale-specific. When composing numbers, make sure to compose them in the suitable format. Rather of utilizing printfthink about java.text.NumberFormat or Integer.toString/Double.toString

Strangely enough, since Java 21, there is no PrintWriter fabricator with a Path criterion.

If you do not utilize printfyou can utilize the BufferedWriter class and compose strings with the write technique. 

var writer = Files.newBufferedWriter(path);
writer.write(line); // Does not write a line separator
writer.newLine();

Keep in mind to close the writer when you are done.

Checking out From an Input Stream

Possibly the most typical factor to utilize a stream is to check out something from a website.

If you require to set demand headers or check out action headers, utilize the HttpClient:

HttpClient client = HttpClient.newBuilder().build();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://horstmann.com/index.html"))
    .GET()
    .build();
HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
String result = response.body();

That is overkill if all you desire is the information. Rather, usage:

InputStream in = new URI("https://horstmann.com/index.html").toURL().openStream();

Check out the information into a byte selection and additionally turn them into a string:

byte[] bytes = in.readAllBytes();
String result = new String(bytes);

Or move the information to an output stream:

OutputStream out = Files.newOutputStream(path);
in.transferTo(out);

Keep in mind that no loop is needed if you just wish to check out all bytes of an input stream.

Do you actually require an input stream? Numerous APIs offer you the alternative to check out from a file or URL.

Your preferred JSON library is most likely to have approaches for checking out from a file or URL. With Jackson jr:

URL url = new URI("https://dog.ceo/api/breeds/image/random").toURL();
Map result = JSON.std.mapFrom(url);

Here is how to check out the pet image from the preceding call:

URL url = new URI(result.get("message").toString()).toURL();
BufferedImage img = javax.imageio.ImageIO.read(url);

This is much better than passing an input stream to the read approach, due to the fact that the library can utilize extra details from the URL to figure out the image type.

The Files API

The java.nio.file.Files class supplies a thorough set of file operations, such as producing, copying, moving, and erasing files and directory sites. The Submit System Basics tutorial supplies a comprehensive description. In this area, I highlight a couple of typical jobs.

Passing Through Entries in Directories and Subdirectories

For many circumstances you can utilize one of 2 approaches. The Files.list technique gos to all entries (files, subdirectories, symbolic links) of a directory site.

try (Stream entries = Files.list(pathToDirectory)) {
    . . .
}

Utilize a try-with-resources declaration to guarantee that the stream things, which monitors the model, will be closed.

If you likewise wish to go to the entries of descendant directory sites, rather utilize the approach Files.walk

Stream entries = Files.walk(pathToDirectory);

Merely utilize stream techniques to home in on the entries that you are interested in, and to gather the outcomes:

try (Stream entries = Files.walk(pathToDirectory)) {
    List htmlFiles = entries.filter(p -> p.toString().endsWith("html")).toList();
    . . .
}

Here are the other techniques for passing through directory site entries:

  • A strained variation of Files.walk lets you restrict the depth of the passed through tree.
  • 2 Files.walkFileTree approaches offer more control over the model procedure, by informing a FileVisitor when a directory site is checked out for the very first and last time. This can be periodically helpful, in especially for clearing and erasing a tree of directory sites. See the guide Strolling the File Tree for information. Unless you require this control, utilize the easier Files.walk approach.
  • The Files.find approach is much like Files.walkhowever you supply a filter that checks each course and its BasicFileAttributesThis is a little more effective than checking out the qualities individually for each file.
  • 2 Files.newDirectoryStream(Path) techniques yields DirectoryStream circumstances, which can be utilized in improved for loops. There is no benefit over utilizing Files.list
  • The tradition File.list or File.listFiles approaches return file names or File items. These are now outdated.

Dealing With ZIP Files

Since Java 1.1, the ZipInputStream and ZipOutputStream classes offer an API for processing ZIP files. The API is a bit cumbersome. Java 8 presented a much better ZIP file system:

try (FileSystem fs = FileSystems.newFileSystem(pathToZipFile)) {
    . . .
}

The try-with-resources declaration makes sure that the close approach is called after the ZIP file operations. That technique updates the ZIP file to show any modifications in the file system.

You can then utilize the techniques of the Files class. Here we get a list of all files in the ZIP file:

try (Stream entries = Files.walk(fs.getPath("/"))) {
    List filesInZip = entries.filter(Files::isRegularFile).toList();
}

To check out the file contents, simply utilize Files.readString or Files.readAllBytes:

String contents = Files.readString(fs.getPath("/LICENSE"));

You can get rid of files with Files.deleteTo include or change files, merely utilize Files.writeString or Files.write

Developing Temporary Files and Directories

Relatively typically, I require to gather user input, produce files, and run an external procedure. I utilize short-term files, which are gone after the next reboot, or a short-lived directory site that I eliminate after the procedure has actually finished.

I utilize the 2 approaches Files.createTempFile and Files.createTempDirectory for that. 

Path filePath = Files.createTempFile("myapp", ".txt");
Path dirPath = Files.createTempDirectory("myapp");

This develops a short-lived file or directory site in an appropriate place (/tmp in Linux) with the offered prefix and, for a file, suffix.

Conclusion

Web searches and AI talks can recommend unnecessarily intricate code for typical I/O operations. There are frequently much better options:

  1. You do not require a loop to check out or compose strings or byte selections.
  2. You might not even require a stream, reader or author.
  3. End up being knowledgeable about the Files techniques for developing, copying, moving, and erasing files and directory sites.
  4. Usage Files.list or Files.walk to pass through directory site entries.
  5. Utilize a ZIP file system for processing ZIP files.
  6. Keep away from the tradition File class.

Find out more

Leave a Reply

Your email address will not be published. Required fields are marked *