Author: saqibkhan

As we know that Java NIO supports concurrency and multi threading which enables it to deal with the multiple threads operating on multiple files at same time.But in some cases we require that our file would not get share by any of thread and get non accessible.

For such requirement NIO again provides an API known as FileLock which is used to provide lock over whole file or on a part of file,so that file or its part doesn’t get shared or accessible.

in order to provide or apply such lock we have to use FileChannel or AsynchronousFileChannel,which provides two methods lock() and tryLock()for this purpose.The lock provided may be of two types −

• Exclusive Lock − An exclusive lock prevents other programs from acquiring an overlapping lock of either type.
• Shared Lock − A shared lock prevents other concurrently-running programs from acquiring an overlapping exclusive lock, but does allow them to acquire overlapping shared locks.

Methods used for obtaining lock over file −

• lock() − This method of FileChannel or AsynchronousFileChannel acquires an exclusive lock over a file associated with the given channel.Return type of this method is FileLock which is further used for monitoring the obtained lock.
• lock(long position, long size, boolean shared) − This method again is the overloaded method of lock method and is used to lock a particular part of a file.
• tryLock() − This method return a FileLock or a null if the lock could not be acquired and it attempts to acquire an explicitly exclusive lock on this channel’s file.
• tryLock(long position, long size, boolean shared) − This method attempts to acquires a lock on the given region of this channel’s file which may be an exclusive or of shared type.

Methods of FileLock Class

• acquiredBy() − This method returns the channel on whose file lock was acquired.
• position() − This method returns the position within the file of the first byte of the locked region.A locked region need not be contained within, or even overlap, the actual underlying file, so the value returned by this method may exceed the file’s current size.
• size() − This method returns the size of the locked region in bytes.A locked region need not be contained within, or even overlap, the actual underlying file, so the value returned by this method may exceed the file’s current size.
• isShared() − This method is used to determine that whether lock is shared or not.
• overlaps(long position,long size) − This method tells whether or not this lock overlaps the given lock range.
• isValid() − This method tells whether or not the obtained lock is valid.A lock object remains valid until it is released or the associated file channel is closed, whichever comes first.
• release() − Releases the obtained lock.If the lock object is valid then invoking this method releases the lock and renders the object invalid. If this lock object is invalid then invoking this method has no effect.
• close() − This method invokes the release() method. It was added to the class so that it could be used in conjunction with the automatic resource management block construct.

Example to demonstrate file lock.

Following example create lock over a file and write content to it

package com.java.nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
public class FileLockExample {
   public static void main(String[] args) throws IOException {
  String input = "Demo text to be written in locked mode.";  
  System.out.println("Input string to the test file is: " + input);  
  ByteBuffer buf = ByteBuffer.wrap(input.getBytes());  
  String fp = "D:file.txt";  
  Path pt = Paths.get(fp);  
  FileChannel channel = FileChannel.open(pt, StandardOpenOption.WRITE,StandardOpenOption.APPEND);  
  channel.position(channel.size() - 1); // position of a cursor at the end of file       
  FileLock lock = channel.lock();   
  System.out.println("The Lock is shared: " + lock.isShared());  
  channel.write(buf);  
  channel.close(); // Releases the Lock  
  System.out.println("Content Writing is complete. Therefore close the channel and release the lock.");  
  PrintFileCreated.print(fp);  
   }  
}

package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class PrintFileCreated {
   public static void print(String path) throws IOException {  
  FileReader filereader = new FileReader(path);  
  BufferedReader bufferedreader = new BufferedReader(filereader);  
  String tr = bufferedreader.readLine();    
  System.out.println("The Content of testout.txt file is: ");  
  while (tr != null) {      
     System.out.println("    " + tr);  
     tr = bufferedreader.readLine();  
  }  
   filereader.close();  
   bufferedreader.close();  
   }  
}

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Output

Input string to the test file is: Demo text to be written in locked mode.
The Lock is shared: false
Content Writing is complete. Therefore close the channel and release the lock.
The Content of testout.txt file is: 
To be or not to be?Demo text to be written in locked mode.

In Java for every character there is a well defined unicode code units which is internally handled by JVM.So Java NIO package defines an abstract class named as Charset which is mainly used for encoding and decoding of charset and UNICODE.

Standard charsets

The supported Charset in java are given below.

• US-ASCII − Seven bit ASCII characters.
• ISO-8859-1 − ISO Latin alphabet.
• UTF-8 − This is 8 bit UCS transformation format.
• UTF-16BE − This is 16 bit UCS transformation format with big endian byte order.
• UTF-16LE − This is 16 bit UCS transformation with little endian byte order.
• UTF-16 − 16 bit UCS transformation format.

Important methods of Charset class

• forName() − This method creates a charset object for the given charset name.The name can be canonical or an alias.
• displayName() − This method returns the canonical name of given charset.
• canEncode() − This method checks whether the given charset supports encoding or not.
• decode() − This method decodes the string of a given charset into charbuffer of Unicode charset.
• encode() − This method encodes charbuffer of unicode charset into the byte buffer of given charset.

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Example

Following example illustrate important methods of Charset class.

package com.java.nio;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
public class CharsetExample {
   public static void main(String[] args) {
  Charset charset = Charset.forName("US-ASCII");
  System.out.println(charset.displayName());
  System.out.println(charset.canEncode());
  String str= "Demo text for conversion.";
  //convert byte buffer in given charset to char buffer in unicode
  ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
  CharBuffer charBuffer = charset.decode(byteBuffer);
  //convert char buffer in unicode to byte buffer in given charset
  ByteBuffer newByteBuffer = charset.encode(charBuffer);
  while(newbb.hasRemaining()){
     char ch = (char) newByteBuffer.get();
     System.out.print(ch);
  }
  newByteBuffer.clear();
   }
}

Output

US-ASCII
Demo text for conversion.

As we know that Java NIO supports concurrency and multi-threading which allows us to deal with different channels concurrently at same time.So the API which is responsible for this in Java NIO package is AsynchronousFileChannel which is defined under NIO channels package.Hence qualified name for AsynchronousFileChannel is java.nio.channels.AsynchronousFileChannel.

AsynchronousFileChannel is similar to that of the NIO’s FileChannel,except that this channel enables file operations to execute asynchronously unlike of synchronous I/O operation in which a thread enters into an action and waits until the request is completed.Thus asynchronous channels are safe for use by multiple concurrent threads.

In asynchronous the request is passed by thread to the operating system’s kernel to get it done while thread continues to process another job.Once the job of kernel is done it signals the thread then the thread acknowledged the signal and interrupts the current job and processes the I/O job as needed.

For achieving concurrency this channel provides two approaches which includes one as returning a java.util.concurrent.Future object and other is Passing to the operation an object of type java.nio.channels.CompletionHandler.

We will understand both the approaches with help of examples one by one.

• Future Object − In this an instance of Future Interface is returned from channel.In Future interface there is get() method which returns the status of operation that is handled asynchronously on the basis of which further execution of other task could get decided.We can also check whether task is completed or not by calling its isDone method.

Example

The following example shows the how to use Future object and to task asynchronously.

package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class FutureObject {
   public static void main(String[] args) throws Exception {
  readFile();
   }
   private static void readFile() throws IOException, InterruptedException, ExecutionException {
  String filePath = "D:fileCopy.txt";
  printFileContents(filePath);
  Path path = Paths.get(filePath);		
  AsynchronousFileChannel channel =AsynchronousFileChannel.open(path, StandardOpenOption.READ);
  ByteBuffer buffer = ByteBuffer.allocate(400);
  Future<Integer> result = channel.read(buffer, 0); // position = 0
  while (! result.isDone()) {
     System.out.println("Task of reading file is in progress asynchronously.");
  }
  System.out.println("Reading done: " + result.isDone());
  System.out.println("Bytes read from file: " + result.get()); 
  buffer.flip();
  System.out.print("Buffer contents: ");
  while (buffer.hasRemaining()) {
     System.out.print((char) buffer.get());                
  }
  System.out.println(" ");
  buffer.clear();
  channel.close();
   }
   private static void printFileContents(String path) throws IOException {
  FileReader fr = new FileReader(path);
  BufferedReader br = new BufferedReader(fr);
  String textRead = br.readLine();
  System.out.println("File contents: ");
  while (textRead != null) {
     System.out.println("     " + textRead);
     textRead = br.readLine();
  }
   fr.close();
   br.close();
   }
}

Output

File contents: 
   To be or not to be?
   Task of reading file is in progress asynchronously.
   Task of reading file is in progress asynchronously.
   Reading done: true
   Bytes read from file: 19
   Buffer contents: To be or not to be? 

• Completion Handler −This approach is pretty simple as in this we uses CompletionHandler interface and overrides its two methods one is completed() method which is invoked when the I/O operation completes successfully and other is failed() method which is invoked if the I/O operations fails.In this a handler is created for consuming the result of an asynchronous I/O operation as once a task is completed then only the handler has functions that are executed.

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Example

The following example shows the how to use CompletionHandler to task asynchronously.

package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class CompletionHandlerDemo {
   public static void main (String [] args) throws Exception {
  writeFile();
   }
   private static void writeFile() throws IOException {
  String input = "Content to be written to the file.";
  System.out.println("Input string: " + input);
  byte [] byteArray = input.getBytes();
  ByteBuffer buffer = ByteBuffer.wrap(byteArray);
  Path path = Paths.get("D:fileCopy.txt");
  AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
  CompletionHandler handler = new CompletionHandler() {
     @Override
     public void completed(Object result, Object attachment) {
        System.out.println(attachment + " completed and " + result + " bytes are written.");
     }
     @Override
     public void failed(Throwable exc, Object attachment) {
        System.out.println(attachment + " failed with exception:");
        exc.printStackTrace();
     }
  };
  channel.write(buffer, 0, "Async Task", handler);
  channel.close();
  printFileContents(path.toString());
   }
   private static void printFileContents(String path) throws IOException {
  FileReader fr = new FileReader(path);
  BufferedReader br = new BufferedReader(fr);
  String textRead = br.readLine();
  System.out.println("File contents: ");
  while (textRead != null) {
     System.out.println("     " + textRead);
     textRead = br.readLine();
  }
  fr.close();
  br.close();
   }
}

Output

Input string: Content to be written to the file.
Async Task completed and 34 bytes are written.
File contents: 
Content to be written to the file.

Java NIO package provide one more utility API named as Files which is basically used for manipulating files and directories using its static methods which mostly works on Path object.

As mentioned in Path tutorial that Path interface is introduced in Java NIO package during Java 7 version in file package.So this tutorial is for same File package.

This class consists exclusively of static methods that operate on files, directories, or other types of files.In most cases, the methods defined here will delegate to the associated file system provider to perform the file operations.

There are many methods defined in the Files class which could also be read from Java docs.In this tutorial we tried to cover some of the important methods among all of the methods of Java NIO Files class.

Important methods of Files class.

Following are the important methods defined in Java NIO Files class.

• createFile(Path filePath, FileAttribute attrs) − Files class provides this method to create file using specified Path.

Example

package com.java.nio;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class CreateFile {
   public static void main(String[] args) {
  //initialize Path object
  Path path = Paths.get("D:file.txt");
  //create file
  try {
     Path createdFilePath = Files.createFile(path);
     System.out.println("Created a file at : "+createdFilePath);
  } 
  catch (IOException e) {
     e.printStackTrace();
  }
   }
}

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Output

Created a file at : D:\data\file.txt

• copy(InputStream in, Path target, CopyOption� options) − This method is used to copies all bytes from specified input stream to specified target file and returns number of bytes read or written as long value.LinkOption for this parameter with the following values −
  • COPY_ATTRIBUTES − copy attributes to the new file, e.g. last-modified-time attribute.
  • REPLACE_EXISTING − replace an existing file if it exists.
  • NOFOLLOW_LINKS − If a file is a symbolic link, then the link itself, not the target of the link, is copied.

Example

package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;
public class WriteFile {
   public static void main(String[] args) {
  Path sourceFile = Paths.get("D:file.txt");
  Path targetFile = Paths.get("D:fileCopy.txt");
  try {
     Files.copy(sourceFile, targetFile,
     StandardCopyOption.REPLACE_EXISTING);
  }
  catch (IOException ex) {
     System.err.format("I/O Error when copying file");
  }
  Path wiki_path = Paths.get("D:fileCopy.txt");
  Charset charset = Charset.forName("ISO-8859-1");
  try {
     List<String> lines = Files.readAllLines(wiki_path, charset);
     for (String line : lines) {
        System.out.println(line);
     }
  } 
  catch (IOException e) {
     System.out.println(e);
  }
   }	
}

Output

To be or not to be?

• createDirectories(Path dir, FileAttribute<?>…attrs) − This method is used to create directories using given path by creating all nonexistent parent directories.
• delete(Path path) − This method is used to deletes the file from specified path.It throws NoSuchFileException if the file is not exists at specified path or if the file is directory and it may not empty and cannot be deleted.
• exists(Path path) − This method is used to check if file exists at specified path and if the file exists it will return true or else it returns false.
• readAllBytes(Path path) − This method is used to reads all the bytes from the file at given path and returns the byte array containing the bytes read from the file.

Example

package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class ReadFile {
   public static void main(String[] args) {
  Path wiki_path = Paths.get("D:file.txt");
  Charset charset = Charset.forName("ISO-8859-1");
  try {
     List<String> lines = Files.readAllLines(wiki_path, charset);
     for (String line : lines) {
        System.out.println(line);
     }
  } 
  catch (IOException e) {
     System.out.println(e);
  }
   }	
}

Output

Welcome to file.

• size(Path path) − This method is used to get the size of the file at specified path in bytes.
• write(Path path, byte[] bytes, OpenOption� options) − This method is used to writes bytes to a file at specified path.

Example

package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class WriteFile {
   public static void main(String[] args) {
  Path path = Paths.get("D:file.txt");
  String question = "To be or not to be?";
  Charset charset = Charset.forName("ISO-8859-1");
  try {
     Files.write(path, question.getBytes());
     List<String> lines = Files.readAllLines(path, charset);
     for (String line : lines) {
        System.out.println(line);
     }
  } 
  catch (IOException e) {
     System.out.println(e);
  }
   }
}

Output

To be or not to be?

As name suggests Path is the particular location of an entity such as file or a directory in a file system so that one can search and access it at that particular location.

Technically in terms of Java, Path is an interface which is introduced in Java NIO file package during Java version 7,and is the representation of location in particular file system.As path interface is in Java NIO package so it get its qualified name as java.nio.file.Path.

In general path of an entity could be of two types one is absolute path and other is relative path.As name of both paths suggests that absolute path is the location address from the root to the entity where it locates while relative path is the location address which is relative to some other path.Path uses delimiters in its definition as “\” for Windows and “/” for unix operating systems.

In order to get the instance of Path we can use static method of java.nio.file.Paths class get().This method converts a path string, or a sequence of strings that when joined form a path string, to a Path instance.This method also throws runtime InvalidPathException if the arguments passed contains illegal characters.

As mentioned above absolute path is retrieved by passing root element and the complete directory list required to locate the file.While relative path could be retrieved by combining the base path with the relative path.Retrieval of both paths would be illustrated in following example

Example

package com.java.nio;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.file.FileSystem;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
public class PathDemo {
   public static void main(String[] args) throws IOException {
  Path relative = Paths.get("file2.txt");
  System.out.println("Relative path: " + relative);
  Path absolute = relative.toAbsolutePath();
  System.out.println("Absolute path: " + absolute);
   }
}

So far we know that what is path interface why do we need that and how could we access it.Now we would know what are the important methods which Path interface provide us.

Important methods of Path Interface

• getFileName() − Returns the file system that created this object.
• getName() − Returns a name element of this path as a Path object.
• getNameCount() − Returns the number of name elements in the path.
• subpath() − Returns a relative Path that is a subsequence of the name elements of this path.
• getParent() − Returns the parent path, or null if this path does not have a parent.
• getRoot() − Returns the root component of this path as a Path object, or null if this path does not have a root component.
• toAbsolutePath() − Returns a Path object representing the absolute path of this path.
• toRealPath() − Returns the real path of an existing file.
• toFile() − Returns a File object representing this path.
• normalize() − Returns a path that is this path with redundant name elements eliminated.
• compareTo(Path other) − Compares two abstract paths lexicographically.This method returns zero if the argument is equal to this path, a value less than zero if this path is lexicographically less than the argument, or a value greater than zero if this path is lexicographically greater than the argument.
• endsWith(Path other) − Tests if this path ends with the given path.If the given path has N elements, and no root component, and this path has N or more elements, then this path ends with the given path if the last N elements of each path, starting at the element farthest from the root, are equal.
• endsWith(String other) − Tests if this path ends with a Path, constructed by converting the given path string, in exactly the manner specified by the endsWith(Path) method.

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Example

Following example illustartes the different methods of Path interface which are mentioned above −

package com.java.nio;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.file.FileSystem;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
public class PathDemo {
   public static void main(String[] args) throws IOException {
  Path path = Paths.get("D:/workspace/ContentW/Saurav_CV.docx");
  FileSystem fs =  path.getFileSystem();
  System.out.println(fs.toString());
  System.out.println(path.isAbsolute());
  System.out.println(path.getFileName());
  System.out.println(path.toAbsolutePath().toString());
  System.out.println(path.getRoot());
  System.out.println(path.getParent());
  System.out.println(path.getNameCount());
  System.out.println(path.getName(0));
  System.out.println(path.subpath(0, 2));
  System.out.println(path.toString());
  System.out.println(path.getNameCount());
  Path realPath = path.toRealPath(LinkOption.NOFOLLOW_LINKS);
  System.out.println(realPath.toString());
  String originalPath = "d:\\data\\projects\\a-project\\..\\another-project";
  Path path1 = Paths.get(originalPath);
  Path path2 = path1.normalize();
  System.out.println("path2 = " + path2);
   }
}

In Java NIO pipe is a component which is used to write and read data between two threads.Pipe mainly consist of two channels which are responsible for data propagation.

Among two constituent channels one is called as Sink channel which is mainly for writing data and other is Source channel whose main purpose is to read data from Sink channel.

Data synchronization is kept in order during data writing and reading as it must be ensured that data must be read in a same order in which it is written to the Pipe.

It must kept in notice that it is a unidirectional flow of data in Pipe i.e data is written in Sink channel only and could only be read from Source channel.

In Java NIO pipe is defined as a abstract class with mainly three methods out of which two are abstract.

Methods of Pipe class

• open() − This method is used get an instance of Pipe or we can say pipe is created by calling out this method.
• sink() − This method returns the Pipe’s sink channel which is used to write data by calling its write method.
• source() − This method returns the Pipe’s source channel which is used to read data by calling its read method.

Example

The following example shows the implementation of Java NIO pipe.

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

public class PipeDemo {
   public static void main(String[] args) throws IOException {
  //An instance of Pipe is created
  Pipe pipe = Pipe.open();
  // gets the pipe's sink channel
  Pipe.SinkChannel skChannel = pipe.sink();
  String testData = "Test Data to Check java NIO Channels Pipe.";
  ByteBuffer buffer = ByteBuffer.allocate(512);
  buffer.clear();
  buffer.put(testData.getBytes());
  buffer.flip();
  //write data into sink channel.
  while(buffer.hasRemaining()) {
     skChannel.write(buffer);
  }
  //gets  pipe's source channel
  Pipe.SourceChannel sourceChannel = pipe.source();
  buffer = ByteBuffer.allocate(512);
  //write data into console     
  while(sourceChannel.read(buffer) > 0){
     //limit is set to current position and position is set to zero
     buffer.flip();
     while(buffer.hasRemaining()){
        char ch = (char) buffer.get();
        System.out.print(ch);
     }
     //position is set to zero and limit is set to capacity to clear the buffer.
     buffer.clear();
  }
   }
}

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Output

Test Data to Check java NIO Channels Pipe.

Assuming we have a text file c:/test.txt, which has the following content. This file will be used as an input for our example program.