We all are familiar with reading/writing file in a synchronous way. In Java 7 a new API was added to read/write the contents of the file asynchronously. The API is AsynchronousFileChannel.

In this example lets look at how to read the contents of the file asynchronously. There are two approaches to read the contents asynchronously:
1. To use Future class to wait for the result of the read operation.
2. To use a callback defined by the CompletionHandler to process the result of the Asynchronous operation.

//Using Future class to read the contents of the file.
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.charset.Charset;
import java.nio.file.*;
import java.util.concurrent.*;

public class AsyncFutureRead {

  public static void main(String[] args) {

    //Buffer to read the contents from the file.
    ByteBuffer buffer = ByteBuffer.allocate(100);

    //The file to read the contents from.
    Path path = Paths.get("D:/tests/test.txt");

    //Creating the asynchronous channel to the file which allows reading and writing of content.
    try(AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open(path)){

      //Returns a Future instance which can be used to read the contents of the file.
      Future<Integer> fileResult = asyncChannel.read(buffer, 0);

      //Waiting for the file reading to complete.
      while(!fileResult.isDone()){
        System.out.println("Waiting to complete the file reading ...");
      }

      //Print the number of bytes read.
      System.out.println("Number of bytes read: "+fileResult.get());

      //Reset the current position of the buffer to the beginning and the limit to the current position.
      buffer.flip();

      //Decode the contents of the byte buffer.
      System.out.println("Contents of file: ");
      System.out.println(Charset.defaultCharset().decode(buffer));

    }catch(IOException | InterruptedException | ExecutionException ex){
      ex.printStackTrace();
    }
  }
}

Buy Pro Java 7 NIO.2

Pro Java 7 NIO.2 by Anghel Leonard (buy from Amazon.com / Kindle Edition )

Pro Java 7 NIO.2 addresses the three primary elements that offer new input/output (I/O) APIs in Java 7, giving you the skills to write robust, scalable Java applications.

At times we might want to search for some file in a directory traversing recursively into other directories with in that directory, I know getting the recursive program right at the first time is always a challenge. Or we might want to list all the contents of a directory. For all these operations the NIO2 enhancements in Java 7 provides an API to recursively traverse through a path and another interface which can be extended to provide hooks for performing certain operations when a file is encountered or a directory is encountered.

The method used is: Files.walkFileTree. There are 2 overloaded versions of this method:

public static Path walkFileTree(Path start,
              Set<FileVisitOption> options,
              int maxDepth,
              FileVisitor<? super Path> visitor)
                       throws IOException

and

public static Path walkFileTree(Path start,
    FileVisitor<? super Path> visitor)
             throws IOException

Currently FileVisitOption enum provides an option to specify whether or not to follow the symbolic links. The maxDepth restricts the number of levels the walkFileTree method would traverse into for a given directory.

The FileVisitor interface is the major player in this operation. It has the following methods:

• postVisitDirectory(T dir, IOException exc): Invoked for a directory after entries in the directory, and all of their descendants, have been visited.
• preVisitDirectory(T dir, BasicFileAttributes attrs): Invoked for a directory before entries in the directory are visited.
• visitFile(T file, BasicFileAttributes attrs): Invoked for a file in a directory.
• visitFileFailed(T file, IOException exc): Invoked for a file that could not be visited.

Each of these methods return a FileVisitResult, which is another enum with the following constants:

• CONTINUE: Continue.
• SKIP_SIBLINGS: Continue without visiting the siblings of this file or directory.
• SKIP_SUBTREE: Continue without visiting the entries in this directory.
• TERMINATE: Terminate.

I have created a test dir with the following contents:

and the dir1 contains:

Lets write a program to list all the text files in the folder: “D:\nioTestDir”. First we need to implement the FileVisitor interface. We can make use of SimpleFileVisitor class which implements the FileVisitor interface and provides default operations for all the methods.

class TextFileVisitor extends SimpleFileVisitor<Path>{
  
  PathMatcher matcher;
  
  public TextFileVisitor(){
    
    matcher = FileSystems.getDefault().getPathMatcher("glob:*.txt");
    
  }
  
  @Override
  public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
      throws IOException {
    
    Path fileName = file.getFileName();
    
    if ( matcher.matches(fileName)){
      System.out.println("Found: "+ file);
    }
    
    //Continue to search for other txt files
    return FileVisitResult.CONTINUE;
  }
  
}

and the complete program to find the “*.txt” files is:

public class DirectoryScanner {
  
  public static void main(String[] args) throws IOException {
    
    Path rootPath = Paths.get("D:/nioTestDir");
    Files.walkFileTree(rootPath, new TextFileVisitor());
    
  }

}

the output:

Found: D:\nioTestDir\dir1\dir1Test1.txt
Found: D:\nioTestDir\dir1\dir1Test2.txt
Found: D:\nioTestDir\dir1\dir1Test3.txt
Found: D:\nioTestDir\test1.txt
Found: D:\nioTestDir\test2.txt
Found: D:\nioTestDir\test3.txt

This new API has made it really easy to traverse any given path to get the contents of the file/directory represented by the path. The above example was a simple way to list all the “.txt” files in the given path.

The Files class provides a method- newDirectoryStream to get the Directory contents for a give path instance. There are other overloaded versions of newDirectoryStream method which take in filters to apply on the directory content.

Listing all files in the directory

Using Files.newDirectoryStream method gives an instance of DirectoryStream class which is a Iterable i.e one can get iterate over its contents. Also it implements AutoCloseable, Closeable which means that one can make use of try with resources to close the directory stream after use.

Path basePath = Paths.get("D:/tests");

// Listing the files in the directory
System.out.println("All files:");
try (DirectoryStream<Path> pathList = Files.newDirectoryStream(basePath)) {
  for (Path path : pathList) {
    System.out.println(path.toString());
  }

} catch (IOException e) {

  e.printStackTrace();
}

Output:

All files:
D:\tests\another_test.txt
D:\tests\DirectoryFilterTest.class
D:\tests\somDoc.docx
D:\tests\test1.txt

Applying Filter using GLOB pattern

In the above sample we listed all the files, we can even use regular expression strings to restrict the files to be obtained from the directory. This regular expression structure is called as a GLOB pattern. Some rules for Glob pattern are:

• * represents any number of characters
• ? represents a single character
• {} represents a collection of patterns like {txt,doc}
• [] represents a set of single characters like [A-Z], [0-9]

Using the Glob pattern we would restrict to fetch only the txt files

try (DirectoryStream<Path> pathList = 
  Files.newDirectoryStream(basePath,"*.txt")) {
  for (Path path : pathList) {
    System.out.println(path.toString());
  }

} catch (IOException e) {

  e.printStackTrace();
}

Output:

All text files[Using Glob pattern]:
D:\tests\another_test.txt
D:\tests\test1.txt

Applying filter using the DirectoryStream.Filter class

Another approach to apply filter is to extend the DirectoryStream.Filter class and overrides its accept(Path) method. The paths for which the accept(Path) method returns true would be fetched and listed.
The same example above implemented using DirectoryStream.Filter:

System.out.println("All document files[Using Filter class]");
DirectoryStream.Filter<Path> documentFilter = new DirectoryStream.Filter<Path>() {

  @Override
  public boolean accept(Path entry) throws IOException {
    String fileName = entry.getFileName().toString();
    return fileName != null && fileName.endsWith("txt");
  }

};
try (DirectoryStream<Path> pathList = Files.newDirectoryStream(basePath,
    documentFilter)) {
  for (Path path : pathList) {
    System.out.println(path.toString());
  }

} catch (IOException e) {

  e.printStackTrace();
}

Output:

All document files[Using Filter class]
D:\tests\another_test.txt
D:\tests\test1.txt

Its clear that for filtering based on file names glob patterns is the preferred approach and for filtering based on other parameters like file size, file attributes using DirectoryStream.Filter is the better approach.

The complete code for this can be found here.

We have been exploring the NIO enhancements in Java 7 and in this post I will explain about creating links- Hard links and Soft links in Java. And this feature is part of Java 7.

A link is kind of substitute name to access a particular file/directory, something like an alias to the file/directory. This way it allows us to refer to a file/directory by more than one name. There are 2 types of links that can be created:

• Symbolic Links: These links refer to the file/directory path. And using these links can be used to directly operate on the path they refer to. In my daily work I use a lot of symbolic links and they are really flexible. In this case if the file to which the link refers to is deleted, the link continues to exist but it is not a valid link.
• Hard Links: These links are more stricter than symbolic links which refer to the physical location of the file. If the content of the original file is changed, the link also gets updated whereas if the original file is deleted, the link continues to exist and is valid file.

Creating Symbolic Links in Java

Not all operating systems support creating symbolic links. The program I tried on Windows couldn’t create a symbolic link. But for creating symbolic link we make use of the Files.createSymbolicLink method which takes the link path as well as the target path, where both link and target are instances of type Path.

Creating Hard links in Java

On Windows I was able to create the Hard links and for this we make use of Files.createLink method which takes in link path and the target path.
Lets look at the example where both soft link and hard links are created:
Note: I tried this sample on Windows and Linux, but you can get better results in Linux, because I am not sure how to list the links in Windows.

public class LinkTest {
  public static void main(String[] args) throws IOException {
    Path file1 = Paths.get("test1");
    System.out.println(file1.toRealPath());
    Path hLink = Paths.get("test1.hLink");
    Path sLink = Paths.get("test1.symLink");

    try{
      Files.createSymbolicLink(sLink, file1);

    }catch(UnsupportedOperationException ex){
      System.out.println("This OS doesn't support creating Sym links");
    }

    try{
      Files.createLink(hLink, file1);
      System.out.println(hLink.toRealPath());
    }catch(UnsupportedOperationException ex){
      System.out.println("This OS doesn't support creating Sym links");
    }

  }
}

Buy Pro Java 7 NIO.2

Pro Java 7 NIO.2 by Anghel Leonard (buy from Amazon.com / Kindle Edition )

Pro Java 7 NIO.2 addresses the three primary elements that offer new input/output (I/O) APIs in Java 7, giving you the skills to write robust, scalable Java applications.

• BasicFileAttributeView: A file attribute view that provides a view of a basic set of file attributes common to many file systems. The basic set of file attributes consist of mandatory and optional file attributes as defined by the BasicFileAttributes interface. This view is named as “basic”
• DosFileAttributeView: Extends the BasicFileAttributeView and adds the four supported attributes on file systems that support the DOS attributes. This view is named as “dos”.
• PosixFileAttributeView: This extends the BasicFileAttributeView with attributes supported on file systems that supports POSIX standards such as Unix. This view is named as: “posix”
• UserDefinedFileAttributeView: One can specify custom attributes using this view.
• AclFileAttributeView: This view supports obtaining file’s access control list. It is named as “acl”.
• FileOwnerAttributeView: Any file system that supports file owners would provide this view. This is used to obtain the owner information for the file. This view is named as “owner”.

For each of the views I have also mentioned the view names and its important to know these view names because one can refer to the attributes using [view-name]:attributeName. Before you access the views you need to make sure that the file/file system/file store supports the view. For example On Windows OS you cannot find PosixFileAttributeView and on Unix no DosFileAttributeView. Lets see how one can find out the view supported. One can find out the views supported per file or even at the FileStore level.

FileSystem fileSystem = FileSystems.getDefault();

for(FileStore store : fileSystem.getFileStores()){
  System.out.println(store.toString());
  for (String view : fileSystem.supportedFileAttributeViews()){
    if ( store.supportsFileAttributeView(view)){
      System.out.print(view+",");
    }
  }
  System.out.println("");
}

On my machine the output for the above code is:

Windows (C:)
acl,basic,owner,user,dos
ImptStuff (D:)
acl,basic,owner,user,dos
Entertainment (E:)
acl,basic,owner,user,dos

FileStore gives a list of all partitions on my file system and then for each partition find out the views supported.

Going ahead we would pick one file and then find out the attributes associated with the file.

Basic Attributes view

A basic attributes view would provide: creation time, last modified time, last accessed time, size, file type, file key. All the views have an associated attributes class like BasicFileAttributeView has BasicFileAttrbutes class which can be used to obtain the values of these attributes.

/* Attributes of Basic View */
Path path1 = Paths.get("test1");

BasicFileAttributes basicAttributes =
  Files.readAttributes(path1, BasicFileAttributes.class);

System.out.println("Creation Time: "+basicAttributes.creationTime());
System.out.println("Directory? "+basicAttributes.isDirectory());
System.out.println("File? "+basicAttributes.isRegularFile());
System.out.println("Last accessed on: "+basicAttributes.lastAccessTime());
System.out.println("Last modified on: "+basicAttributes.lastModifiedTime());
System.out.println("File size: "+basicAttributes.size()+"bytes");

The output for the above code:

Creation Time: 2012-06-20T17:32:09.703125Z
Directory? false
File? true
Last accessed on: 2012-07-12T17:00:28.234Z
Last modified on: 2012-07-12T17:00:28.234Z
File size: 61bytes

Files is the class which is used for all the operations related to file attributes- getting and setting their values. One can even use getAttribute method of Files class to get the required attribute:

FileTime lastModifiedTime =
  (FileTime)Files.getAttribute(path1, "basic:lastModifiedTime");

One can even modfiy the attribute values. I am not sure if other values can be modified but I was able to modify the time related information. Again you make use of Files class to modify the attribute values.

/* Modifying file attribute */

FileTime newTime = FileTime.fromMillis(System.currentTimeMillis());
Files.setLastModifiedTime(path1, newTime);

BasicFileAttributeView bAttributesView =
    Files.getFileAttributeView(path1, BasicFileAttributeView.class);
bAttributesView.setTimes(null, newTime, null);

One can make use of Files.setAttribute() to modify the attribute. In the above example we used setLastModifiedTime for modifying the lastModifiedTime attribute, then we made use of BasicFileAttributeView to modify the creation, last modified, and last access attributes by using the setTimes method which takes in 3 parameters representing the last modified, last access time, and creation time as instances of FileTime class.

This was a quick overview of the Basic file attributes. One can explore the other views to find out the attributes supported by that view.

Buy Pro Java 7 NIO.2

Pro Java 7 NIO.2 by Anghel Leonard (buy from Amazon.com / Kindle Edition )

Pro Java 7 NIO.2 addresses the three primary elements that offer new input/output (I/O) APIs in Java 7, giving you the skills to write robust, scalable Java applications.

All of us know that an instance of File doesn’t indicate a file in the file system, unless some one invokes a create or related methods. But its a kind of confusion- you talk about instance of File and then you also talk about file at the disk level. A new class was introduced in Java 7 as part of the NIO enhancements which allows to represent the files at the disk level in the memory/as part of objects in Java and this new class is the Path class. And I have used this class extensively in my posts about Files API here and here and also about WatchService API.

Path is an interface and there is a factory Paths which can be used to create instances of type Path. Lets look at some of the operations/functionality provided by Paths and Path classes.

Defining Path

Paths class provides a get(URI), get(String, String …) methods to obtain a Path instance for given file/directory.

Using Absolute Path

Path path1 = Paths.get("E:/Back Up/OSLabs/priority.c");

Path invalidPath = Paths.get("E:/Back Up/OSLabs/invalid");

try{
  System.out.println(invalidPath.toRealPath());
}
catch(NoSuchFileException ex){
  System.out.println(invalidPath.toString()+" not found");
}
//output: E:\Back Up\OSLabs\invalid not found

In the above example we have a valid path and another invalid path. These Path instances dont really check if the location uses if valid or not, but one can use toRealPath() which checks if the given path is valid or not.

Using Relative Path

Path relPath1 = Paths.get("test1");
Path relPath2 = Paths.get("test2");
System.out.println(relPath1.toRealPath());
//output: C:\Documents and Settings\Mohamed Sanaulla\My Documents\NetBeansProjects\JavaBeatSamples\test1

Using FileSystem to construct Path

Java 7 NIO enhancements added a new FileSystem and FileSystems class to get the instance of underlying file system. An instance of Path can also be created using getPath() method of the FileSystem class.

FileSystem fs = FileSystems.getDefault();
Path fsPath1 = fs.getPath("/dev/Test.java");
Path fsPath2 = fs.getPath("test1");
System.out.println(fsPath1.toRealPath());
System.out.println(fsPath2.toRealPath());
//output:
//C:\dev\Test.java
//C:\Documents and Settings\Mohamed Sanaulla\My Documents\NetBeansProjects\JavaBeatSamples\test1

What all information can be obtained from Path?

Path class provides methods to get the name of the file, the parent path of the file, the root of the file and also an Iterator to get different elements of the Path string. Lets look at an example below:

System.out.println("Information from the Path");
System.out.println("Path Name: "+path1.getFileName());
System.out.println("Path Parent: "+path1.getParent());
System.out.println("Path Root: "+path1.getRoot());
System.out.println("Number of elements in path: "+path1.getNameCount());
for ( int i = 0; i < path1.getNameCount(); i++){
  System.out.println("Element "+i+": "+path1.getName(i));
}
System.out.println("Subpath: "+path1.subpath(0,2));
/*
output:
Information from the Path
Path Name: priority.c
Path Parent: E:\Back Up\OSLabs
Path Root: E:\
Number of elements in path: 3
Element 0: Back Up
Element 1: OSLabs
Element 2: priority.c
Subpath: Back Up\OSLabs*/

Comparing Paths

One can compare the paths using equals() which checks for content equality, compareTo() which can be overridden for correct comparison and the Files.isSameFile method which can be used to check if the two path instances actually refer to the same file on the disk. An example for the same:

System.out.println("Path comparisions");
Path compPath1 = Paths.get("/dev/Test.java");
Path compPath2 = Paths.get("C:/dev/Test.java");
System.out.println("Using Equals: "+compPath1.equals(compPath2));
System.out.println("Using isSameFile: "+Files.isSameFile(compPath1, compPath2));
/*
Output:
Path comparisions
Using Equals: false
Using isSameFile: true
*/

In the above example though compPath1 and compPath2 represented same file their string content was different. Hence equals() told that they are different where as isSameFile told that they are same.

Converting Path to File and URI

One can convert the Path instance into URI format and also create a File instance out of it.

System.out.println("Path conversions");
System.out.println("String: "+fsPath1.toString());
System.out.println("URI: "+fsPath1.toUri());
File fileFsPath1 = fsPath1.toFile();
System.out.println("File: "+fileFsPath1.exists());
/*
Output:
Path conversions
String: \dev\Test.java
URI: file:///C:/dev/Test.java
File: true
*/

Combining different paths

We can create one base path and then build multiple paths from that base path using the resolve() method, something like:

System.out.println("Combining Paths");
Path basePath = Paths.get("C:/dev");
Path newPath1 = basePath.resolve("Test.java");
System.out.println("Same file? "+Files.isSameFile(compPath2, newPath1));
Path newPath2 = basePath.resolve("java/CloneTest.java");
System.out.println(newPath2.toRealPath());
/*
Output:
Combining Paths
Same file? true
C:\dev\java\CloneTest.java
*/

These were some of the APIs associated with Path class.

Buy Pro Java 7 NIO.2

Pro Java 7 NIO.2 by Anghel Leonard (buy from Amazon.com / Kindle Edition )

Pro Java 7 NIO.2 addresses the three primary elements that offer new input/output (I/O) APIs in Java 7, giving you the skills to write robust, scalable Java applications.

In our previous post we did get a taste of the power of the static APIs in the Java Files class and we managed to compare the code written without using the APIs in Java Files and with using the APIs in Java Files.

In this post let me delve further into the other APIs offered by Java Files class and look at the creation, deletion of files and reading and writing to the files.

Creating and Deleting a file:

//Create a new Path
Path newFile = Paths.get("test1");
try {
  Files.deleteIfExists(newFile);
  newFile = Files.createFile(newFile);
} catch (IOException ex) {
  System.out.println("Error creating file");
}
System.out.println(Files.exists(newFile));

Creating a new Pathobject doesn’t create a file on the file system. A Path object just indicates a file/directory or any other resource location. The resource might or might not be present in the identified location.

Writing to the file using BufferedWriter:

In the above code we create a file, which contains no data. Lets now write something to the file:

//Writing to file
try(BufferedWriter writer = Files.newBufferedWriter(
        newFile, Charset.defaultCharset())){
  writer.append("This is first line");
  writer.newLine();
  writer.append("This is second line");
  writer.newLine();
  writer.append("This is third line");
  writer.newLine();
  writer.flush();
}catch(IOException exception){
  System.out.println("Error writing to file");
}

The interesting piece from the above code is:

try(BufferedWriter writer = Files.newBufferedWriter(
        newFile, Charset.defaultCharset())){

where we make use of the static API newBuffredWriter in Java Files to obtain the BufferedWriter for the file. And also we make use of the try-with-resources construct to get rid of the finally clause.

Reading from the file using BufferedReader:

Now that we have some content in the file, lets read the content back and display it on the console.

//Reading from file
try(BufferedReader reader = Files.newBufferedReader(
        newFile, Charset.defaultCharset())){
  String lineFromFile = "";
  System.out.println("The contents of file are: ");
  while((lineFromFile = reader.readLine()) != null){
    System.out.println(lineFromFile);
  }

}catch(IOException exception){
  System.out.println("Error while reading file");
}

We ended up making use of the static API newBufferedReader to read the contents of the file and print it on the console.

The advantage of using the Java Files API is that the code is more readable than before and also the parts of the code encapsulated by the API can be reusable.

Here is the complete code for the above example:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class NewFilesApiTest {
  public static void main(String[] args)  {

    //Creating a new file
    Path newFile = Paths.get("test1");
    try {
      Files.deleteIfExists(newFile);
      newFile = Files.createFile(newFile);
    } catch (IOException ex) {
      System.out.println("Error creating file");
    }
    System.out.println(Files.exists(newFile));

    //Writing to file
    try(BufferedWriter writer = Files.newBufferedWriter(
            newFile, Charset.defaultCharset())){
      writer.append("This is first line");
      writer.newLine();
      writer.append("This is second line");
      writer.newLine();
      writer.append("This is third line");
      writer.newLine();
      writer.flush();
    }catch(IOException exception){
      System.out.println("Error writing to file");
    }

    //Reading from file
    try(BufferedReader reader = Files.newBufferedReader(
            newFile, Charset.defaultCharset())){
      String lineFromFile = "";
      System.out.println("The contents of file are: ");
      while((lineFromFile = reader.readLine()) != null){
        System.out.println(lineFromFile);
      }

    }catch(IOException exception){
      System.out.println("Error while reading file");
    }
  }

}

The output is:

true
The contents of file are:
This is first line
This is second line
This is third line

Buy Pro Java 7 NIO.2

Pro Java 7 NIO.2 by Anghel Leonard (buy from Amazon.com / Kindle Edition )

Pro Java 7 NIO.2 addresses the three primary elements that offer new input/output (I/O) APIs in Java 7, giving you the skills to write robust, scalable Java applications.

We recently wrote about watching a directory using the new APIs introduced as part of Java 7. In this post let me throw some light on another class added to the java.nio package as part of Java 7 update- java.nio.file.Files. Another piece of information related to this is that complete java.nio.file package was added as part of Java 7 release. I am not going to write about all the methods in Files class, instead pick few of the methods and compare how we would perform the same operation pre Java 7 with that of using Files API.

Copying the contents of one file to another

:
Here’s how we would do it in before Java 7- using BufferedReader, BufferedWriter.

//Before Java 7
BufferedReader reader = null;
BufferedWriter writer = null;
try {

  reader = new BufferedReader(
       new FileReader("/tmp/nio/file1"));

  writer = new BufferedWriter(
       new FileWriter("/tmp/nio/file2_old"));
  String dataRead = null;
  while ((dataRead = reader.readLine()) != null) {
    writer.write(dataRead);
    writer.newLine();
  }

} catch (IOException e) {
  System.out.println("IOException encoutnered");
} finally {
  if (reader != null) {
    try {
      reader.close();
    } catch (IOException e) {
      System.out.println("Exception while closing reader");
    }
  }
  if (writer != null) {
    try {
      writer.close();
    } catch (IOException e) {
      System.out.println("Exception while closing the writer.");
    }
  }

}
System.out.println("File created: " +
          new File("/tmp/nio/file2_old").exists());

All of you should be familiar with the above code. Now lets see how this can be done using the Files API:

//After Java 7
Path source = Paths.get("/tmp/nio/file1");
Path target = Paths.get("/tmp/nio/file2_new");
try {
  Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
  System.out.println("Exception while copying usng new API");
}
System.out.println("File created: " + Files.exists(target));

I know you cannot believe your eyes, that’s the power of APIs and no wonder Scala has loads of them. Lets have a look at the new classes used above:

• Path: This is used to represent the location of a file/directory in the file system.
• Paths – This is the factory class to create instances of Path class.
• Files- A new class with lots of helper methods to perform operations on File.

There are overloaded versions of copy method which can take an InputStream and write to a file, read it from a file and write to OutputStream or read and write to a file. The first 2 help us to choose different source and different destination respectively.

We have used the third variant of the copy method. Apart from the source and target destinations, the copy method also accepts some CopyOption which indicate to the copy function whether to replace any existing file among other options which are supported.

Reading all the lines from a file into a List

:
Lets have a look at the pre Java 7 approach

List<String> linesInFile = new ArrayList<String>();
BufferedReader reader2 = null;
try{
  String lineRead = null;
  reader2 = new BufferedReader(new FileReader("/tmp/nio/file3"));
  while ((lineRead = reader2.readLine()) != null){
    linesInFile.add(lineRead);
  }
} catch (IOException e) {
  System.out.println("IO error");
}
System.out.println("Lines read using old style: ");
for (String s : linesInFile){
  System.out.println(s);
}

Pretty straight forward using BufferedReader, but too many unwanted/unrelated code statements.

Lets see how this can be done in using Files API:

//In Java 7
Path sourcePath = Paths.get("/tmp/nio/file3");
try {
  List<String> linesReadNew =
          Files.readAllLines(sourcePath,
                  Charset.defaultCharset());

  System.out.println("Lines read using new style:");
  for(String s : linesReadNew){
    System.out.println(s);
  }
} catch (IOException e) {
  System.out.println("IO Error");
}

So much more concise than the other approach. And the code is easy to read as well. In this example we make use of the readAllLines method of the Files class. It takes a Path instance indicating which file to read and then uses BufferedReader to read through the file but all this is being taken care of the API.

These were just 2 instances of how the new API made the code more concise and easy to understand. There are lot many such methods in the Files class which create a wrapper over the mundane, repeated code written using File API.

In Java 7 there were quite a lot of new things added to the File NIO package (java.nio)- there was a new java.nio.file package and java.nio.file.attribute package. Main highlights of the java.nio.file package are the following classes:

• Path: Its an object used to locate a file or directory in the file system. The value contained in the Path instance is platform dependent. For example on Windows the file separators would be “\” while in a Unix platform it would be “/”.
• Files: This class contains static methods which operate on the Path instance to create files, delete or move the files around and to even get the BufferedReader, BufferedWriter, InputStream, OutputStream among other methods.
• FileSystems: Provides static methods to create instance of FileSystem
• WatchService: A service for watching different locations in the file system for events like modification, creation, deletion. Classes which implement Watchable can be used to register with a watch service. An instance of WatchService can be obtained from the FileSystem instance.
• WatchKey: When a Watchable entity is registered with a WatchService a key which is a WatchKey is generated. Initially the key is in ready state waiting to be notified of any events on the Watchable entity. Once an event occurs the key goes into signaled state and allows to access the events using its pollEvents method. After processing the poll events the key has to be reset by invoking its reset method.

Lets look at an example of watching the “/tmp/nio” directory (Note: this example was executed on Unix platform, file separator would have to be changed for executing this in Windows platform) for Modification and Deletions happening in the directory.
We first have to create a Path instance to indicate this directory:

Path tmpPath = Paths.get("/tmp/nio/");

Obtain a WatchService from the FileSystem class:

WatchService watchService = 
    FileSystems.getDefault().newWatchService();

Now we would have to register the Path created above with the WatchService created above and also specify the kind of events we are interested to watch. For the kind of events we make use of StandardWatchEventKinds class and its fields ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE.

/*
 * Watching the /tmp/nio/ directory
 * for MODIFY and DELETE operations
 */
tmpPath.register(
        watchService,
        StandardWatchEventKinds.ENTRY_MODIFY,
        StandardWatchEventKinds.ENTRY_DELETE);

To watch the directory we place all the processing login in an infinite loop (we can also spawn a different thread to watch, but in this example lets keep it simple). And perform the following tasks:
1. Wait for any key to be signaled by invoking the take() method of the WatchService class. One can even use poll() method but the difference is that take() is a blocking call and waits until some key is signaled.
2. Once a WatchKey is obtained, poll for the events available in the key.
3. For each event find out the type of the event using event.kind().type() and also the Path which the event is acting on by using event.context() method.

The above 3 steps in code would be:

/*
 * Keep polling for events on the watched directory,
 */
for(;;){
    WatchKey key = watchService.take();

    //Poll all the events queued for the key
    for ( WatchEvent<?> event: key.pollEvents()){
        WatchEvent.Kind kind = event.kind();
        switch (kind.name()){
            case "ENTRY_MODIFY":
                System.out.println("Modified: "+event.context());
                break;
            case "ENTRY_DELETE":
                System.out.println("Delete: "+event.context());
                break;
        }
    }
    //reset is invoked to put the key back to ready state
    boolean valid = key.reset();

    //If the key is invalid, just exit.
    if ( !valid){
        break;
    }
}

Dont forget to reset() the key once done with handling the events. Otherwise the key would not be in Ready state to listen to more events.

Combining all the parts discussed above, the complete program would be:

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.*;

public class DirectoryWatcherDemo {

    public static void main(String[] args) throws 
        URISyntaxException, 
        IOException, 
        InterruptedException {

        Path tmpPath = Paths.get("/tmp/nio/");
        WatchService watchService = 
            FileSystems.getDefault().newWatchService();

         //Watching the /tmp/nio/ directory
         //for MODIFY and DELETE operations
        tmpPath.register(
                watchService,
                StandardWatchEventKinds.ENTRY_MODIFY,
                StandardWatchEventKinds.ENTRY_DELETE);

        /*
         * Keep polling for events on the watched directory,
         */
        for(;;){
            WatchKey key = watchService.take();

            //Poll all the events queued for the key
            for ( WatchEvent<?> event: key.pollEvents()){
                WatchEvent.Kind kind = event.kind();
                switch (kind.name()){
                    case "ENTRY_MODIFY":
                        System.out.println("Modified: "+event.context());
                        break;
                    case "ENTRY_DELETE":
                        System.out.println("Delete: "+event.context());
                        break;
                }
            }
            //reset is invoked to put the key back to ready state
            boolean valid = key.reset();

            //If the key is invalid, just exit.
            if ( !valid){
                break;
            }
        }

    }
}

Running the following commands in the terminal in “/tmp/nio” directory:

mohamed@mohamed:/tmp/nio$ ls
mohamed@mohamed:/tmp/nio$ touch t1
mohamed@mohamed:/tmp/nio$ touch t2
mohamed@mohamed:/tmp/nio$ touch t3
mohamed@mohamed:/tmp/nio$ rm t1
mohamed@mohamed:/tmp/nio$ vim t2
mohamed@mohamed:/tmp/nio$ mkdir t4
mohamed@mohamed:/tmp/nio$ rm -r t4
mohamed@mohamed:/tmp/nio$ ls
t2  t3

results in the following output in the directory watching program:

Modified: t1
Modified: t2
Modified: t3
Delete: t1
Delete: .t2.swpx
Delete: .t2.swp
Modified: .t2.swp
Modified: .t2.swp
Modified: t2
Modified: t2
Delete: .t2.swp
Delete: t4

One thing to note here is that we did execute mkdir t4 to create a t4 directory but that wasn’t notified because we didn’t register the ENTRY_CREATE event. Also once the new directory is added one has to register the new directory with the WatchService. I will write about this in a separate post sometime later.

Do drop in your queries or any issues you are facing with the above example and explanation.

In our previous post we went through the basics of Fork-Join Framework introduced as part of Java 7. In this post lets apply the same Fork-Join to implement Merge sort algorithm. The pseudo code for Merge sort can be found here.

In summary the Merge sort algorithm:
1. Divides the array into 1 parts
2. Sort each part individually and merge them to form a smaller sorted array.
3. Merge individual sorted arrays to get the complete sorted array.

We create a task for dividing the array into 2 parts and then merge the arrays in the same task (i.e we dont spawn a new task for merging the arrays).

class DivideTask extends RecursiveTask<int[]> {

  int[] arrayToDivide;

  public DivideTask(int[] arrayToDivide) {
    this.arrayToDivide = arrayToDivide;
  }

  @Override
  protected int[] compute() {
    List<RecursiveTask> forkedTasks = new ArrayList<>();

    /*
     * We divide the array till it has only 1 element. 
     * We can also custom define this value to say some 
     * 5 elements. In which case the return would be
     * Arrays.sort(arrayToDivide) instead.
     */
    if (arrayToDivide.length > 1) {
      
      List<int[]> partitionedArray = partitionArray();
      
      DivideTask task1 = new DivideTask(partitionedArray.get(0));
      DivideTask task2 = new DivideTask(partitionedArray.get(1));
      invokeAll(task1, task2);
      
      //Wait for results from both the tasks
      int[] array1 = task1.join();
      int[] array2 = task2.join();
      
      //Initialize a merged array
      int[] mergedArray = 
              new int[array1.length + array2.length];
      
      mergeArrays(task1.join(), task2.join(), mergedArray);

      return mergedArray;
    }
    return arrayToDivide;
  }
  
  private List<int[]> partitionArray(){
    
    int [] partition1 = Arrays.copyOfRange(arrayToDivide, 0,
              arrayToDivide.length / 2);
      
    int [] partition2 = Arrays.copyOfRange(arrayToDivide,
              arrayToDivide.length / 2,
              arrayToDivide.length);
    return Arrays.asList(partition1,partition2);
    
  }

  private void mergeArrays(
          int[] array1, 
          int[] array2, 
          int[] mergedArray) {
    
    int i = 0, j = 0, k = 0;
    
    while ((i < array1.length) && (j < array2.length)) {
    
      if (array1[i] < array2[j]) {
        mergedArray[k] = array1[i++];
      } else {
        mergedArray[k] = array2[j++];
      }
      
      k++;
    }
    
    if (i == array1.length) {
      
      for (int a = j; a < array2.length; a++) {
        mergedArray[k++] = array2[a];
      }
      
    } else {
      
      for (int a = i; a < array1.length; a++) {
        mergedArray[k++] = array1[a];
      }
      
    }
  }
}

In the above declared task, we override the compute method to partition the array given to be sorted:

int[] arrayPart1 = null;
int[] arrayPart2 = null;
partitionArray(arrayToDivide, arrayPart1, arrayPart2);

if the array given to the task cannot be divided further i.e has only one element, then return that array

return arrayToDivide;

If the partitions were created, then assign each partition to a new task and invoke the tasks created:

DivideTask task1 = new DivideTask(arrayPart1);
DivideTask task2 = new DivideTask(arrayPart2);
invokeAll(task1, task2);

We would then have to wait for the results from both the tasks spawned and then merge their results to create a smaller sorted array:

//Wait for results from both the tasks
int[] array1 = task1.join();
int[] array2 = task2.join();

//Initialize a merged array
int[] mergedArray = 
new int[array1.length + array2.length];

mergeArrays(task1.join(), task2.join(), mergedArray);

return mergedArray;

This way each of the task which spawns more sub tasks would wait for their sub tasks to return a sorted array and then return back the sorted array to the parent task. This operation can be invoked as:

public class ForkJoinTest {

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    int totalNumbers = scanner.nextInt();
    
    int[] numbers = new int[totalNumbers];
    
    for (int i = 0; i < totalNumbers; i++) {
      numbers[i] = scanner.nextInt();
    }
    
    System.out.println("Unsorted array: " 
         + Arrays.toString(numbers));

    DivideTask task = new DivideTask(numbers);
    ForkJoinPool forkJoinPool = new ForkJoinPool();
    forkJoinPool.invoke(task);
    
    System.out.println("Sorted array: " 
         + Arrays.toString(task.join()));

  }
}

Output:

run:
8
8 3 2 9 7 1 5 4
Unsorted array: [8, 3, 2, 9, 7, 1, 5, 4]
Sorted array: [1, 2, 3, 4, 5, 7, 8, 9]
BUILD SUCCESSFUL (total time: 2 seconds)

Another useful variant of Merge sort algorithm can be found here.