As per Java’s SDK 7 release, lots of enhancements were introduced into the I/O operations in the programming language, delivering to Java programmers a more comprehensive way to accessing the File System and performing more advanced and efficient I/O operations.
NIO stands for Non-Blocking I/O and its core purpose is to deliver a set of classes and interfaces that enable programs to read and write data to small and large files using Buffers (temporal containers for data) and Channels (java.io.channels).
A NIO Channel is a connection to an entity capable of performing I/O operations (e.g. a hardware device, a file, a network socket or a program component). Channels are meant to be multithreaded safe; thus the definition of the FileChannel class with file-locking capabilities on the whole file or a specific region of it (FileLock). This post will cover the basic NIO features to read, create, overwrite and copy a sample text file.
Copying a file
As stated previously, File channels are safe for use by multiple concurrent threads, this means that any operation that involves modifying the file will block any second such operation until it completes. A File channel is connected to an entity (typically a file) that contains a variable-length sequence of bytes that can be manipulated (read-write); it’s current position within the file can be both queried and manipulated, therefore it is considered a seekable file channel.
TransferFrom() is a method designed for transferring bytes into the invoking channel instance from a given readable byte channel. Let’s illustrate this with the following class:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
public class FileCopyExample {
public static void main(String[] args) {
File source = new File("d:\\data\\LoremIpsum.txt");
File dest = new File("d:\\data\\copied\\LoremIpsum.copy.txt");
FileChannel sourceChannel = null;
FileChannel destChannel = null;
try{
//Create the destination file if exists not
if(!dest.exists()){
dest.createNewFile();
}
sourceChannel = new FileInputStream(source).getChannel(); //readable channel
destChannel = new FileOutputStream(dest).getChannel(); //writable channel
destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
}catch (IOException ioe){
System.err.println("Unexpected IO Exception: " + ioe.getMessage());
}finally{
try{
if(sourceChannel != null)
sourceChannel.close();
if(destChannel != null)
destChannel.close();
}catch (IOException ioe2){
ioe2.printStackTrace();
}
}
}
}Lines 21-23 define the corresponding reading and writing file channels to achieve the transferFrom operation. we use the getChannel() method from each input and output stream objects; this returns a file channel object that is connected to the corresponding underlying file. In the example class above we are assuming that the path d:\data\copied is an existing/valid directory. On line 23 we call the transferFrom() to which we are giving three parameters; the source channel, the byte position, and the data length to be written/copied. Finally, close the resources (channels).
Reading file the NIO way
Next, let’s review what NIO offers to read data from files. First, we have ByteBuffer. The name of this class speaks by itself; is simply a byte buffer that we can use to perform efficient reading operations on a file. In the following modified example we’ll create a byte buffer allocating 1 MB for it (1024 bytes) which is typically large enough for a, so to speak, normal plain text file. We also get the corresponding file channel from the input stream object:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ByteBufferExample {
public static void main(String[] args) throws IOException {
FileChannel fileChannel = new FileInputStream(
new File("d:\\data\\LoremIpsum.txt")).getChannel();
int count = 0;
try{
ByteBuffer buffer = ByteBuffer.allocate(1024);
do{
count = fileChannel.read(buffer);
if(count != -1){
buffer.rewind();
for (int i = 0 ; i < count; i++){
System.out.print((char)buffer.get());
}
}
}while (count != -1);
}finally {
if(fileChannel != null)
fileChannel.close();
}
}
} Line 16 defines the do-while loop to start the reading operation. After the buffer has been created with the 1 MB limit (allocation), we are ready to start reading from it. Every time we read a sequence of bytes from the buffer, we need to rewind it (byte position on the buffer is set to zero). Notice how we need to convert each byte read from the buffer to its char representation. Then we use the get() on the buffer object count times and the byte position is incremented per iteration in the for loop. If there’s no more data to read (end of the stream is reached) the channel will return -1.
NOTE: In the previous example, we can substitute theByteBufferwith aCharBuffer, which can be also allocated and rewound.
ReadAllLines and ReadAllBytes
Java (JDK 7+) provides these two handy methods to simplify the reading operation. Keep in mind these are not intended for large text files. If we want to read large text files we should always consider using a FileReader within a BufferedReader or the ByteBuffer classes.
java.nio.file defines the Files class (do not confuse with the java.io.File class), which consists of static methods to access information on files and perform several actions on files and directories.
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class NIOFilesExample {
public static void main(String[] args) throws IOException {
Path filePath = Paths.get("d:\\data", "LoremIpsum.txt");
byte[] bytes = Files.readAllBytes(filePath);
List<String> lines = Files.readAllLines(filePath);
for (String line : lines) {
System.out.println(line);
}
System.out.println("---------------");
for (int i = 0; i < bytes.length; i++){
System.out.print((char)bytes[i]);
}
}
}Take a look at the code above; if you compile and run the program you’ll come to realize that both methods will do exactly the same; the subtle difference is in the way we handle the printout. When using the readAllLines() method we may specify a charset either by using the Charset.forName() method to resolve the given charset name into a Charset object or by using the java.nio.charset.StandardCharsets class.
Files.readAllLines(filePath, Charset.forName("UTF-8"));
Files.readAllLines(filePath, StandardCharsets.UTF_8);Using the newBufferedReader method from Files class
Files class also provides a way to return a BufferedReader instance, which is a wise idea when working with larger text files. The idea behind it is straight forward:
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class NIOFilesExample {
public static void main(String[] args) {
Path path = Paths.get("d:\\data\\LoremIpsum.txt");
try(BufferedReader br = Files.newBufferedReader(path, StandardCharsets.UTF_8)){
String line;
while((line = br.readLine()) != null){
System.out.println(line);
}
}catch (IOException ioex){
ioex.printStackTrace();
}
}
}The snippet above is a more straight-forward (yet efficient) way to read a text file. We use a try-with-resources block to ensure the buffer resource is closed/released from memory. Inside, we get our BufferedReader instance by calling the newBufferedReader() method on the static class Files. After that, we’re pretty much set; just read each line until end of file is reached and print each line on screen.
Using the newInputStream method from Files class
Another way to achieve the same goal is using the unbuffered input stream method newInputStream(). This required more lines of code since we should wrap the input stream into a buffered reader to improve efficiency. This is how it would look like:
public static void main(String[] args) {
Path path = Paths.get("d:\\data\\LoremIpsum.txt");
try (
InputStream is = Files.newInputStream(path);
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr)
) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException ioex) {
ioex.printStackTrace();
}
}Writing and Creating Files with NIO
Just as for the reading operation, the writing operation is also attained by different classes in the NIO packages. Let’s start off with the static method write() available in the Files class. We also use the java.nio.file.StandardOpenOptions to set the open option. CREATE will create and overwrite if the file contents if it already exists.
public static void main(String[] args) throws IOException {
Path path = Paths.get("d:\\data\\NewFile.txt");
String text = "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium.";
Files.write(path, text.getBytes(), StandardOpenOption.CREATE);
}Another standard open option for file creation is CREATE_NEW that will make the program fail if the file already exists. For existing files we have the options WRITE that opens the file for writing and is typically followed by either APPEND or TRUNCATE_EXISTING.
Using the newBufferedWriter for writing large text files.
Using the Files class, we can also write larger amounts of data using a buffered writer object. This time, let’s use standard open options WRITE and APPEND; thus we will assume that the file the program will write to already exists.
public static void main(String[] args) throws IOException {
Path path = Paths.get("d:\\data\\NewFile.txt");
try(BufferedWriter bw =
Files.newBufferedWriter(path, StandardOpenOption.WRITE, StandardOpenOption.APPEND)){
for(int i = 0; i < 1000; i++){
String line = "\nThis is line number " + (i + 1);
bw.write(line);
}
}
}See how simple it gets using the NIO methods in tandem with a try-with-resources block/statement. This is the append operation result in the file:
Using the un-buffered newOutputStream
Once again, we take advantage of the try-with-resources (AKA try-with-syntax) block/statement to declare and define our un-buffered output stream object and wrapping it up in a buffered output stream object:
public static void main(String[] args) throws IOException {
Path path = Paths.get("d:\\data\\NewFile2.txt");
String text = "Hello world!!!!!!!!!!!!!!!!!!!!!!!!!";
try(
OutputStream os = Files.newOutputStream(path, StandardOpenOption.CREATE);
BufferedOutputStream bos = new BufferedOutputStream(os);
){
bos.write(text.getBytes(), 0, text.length());
}
}
DISCLAIMER:
There are some other ways for reading and writing files in Java using the java.nio.file classes; however, the ones shown in this post can be considered as the most common.
Conclusion
The enhancements made on the java I/O side of things are enabling programs to perform more efficient I/O operations. Years ago, reading and writing files required more lines of code than what we can see in the examples throughout this post.
1 comentario en “Java NIO – Reading, Writing and Copying Files”
Los comentarios están cerrados.