Taskflows are a very useful feature in Oracle ADF which provide a modular approach for defining control flow in an application. It allows to create application flow graphs which can be tied together to build the complete application. So instead of considering an application as a collection of different JSF pages, in ADF we would consider an application as a collection of different taskflows.

ADF Taskflows come in two forms:

• Bounded Taskflow
• Unbounded Taskflow

Unbounded Taskflow: A set of activities (JSF Pages/views), control flow rules, and managed beans that interact to allow a user to complete a task. An ADF unbounded task flow consists of all activities and control flows in an application that are not included within any bounded task flow.

• Building Rich Internet Applications with Oracle ADF Business Components & ADF Faces (Amazon.com)

Bounded Taskflow: A specialized form of task flow that, in contrast to an unbounded task flow, has a single entry point and zero or more exit points. It contains its own set of private control flow rules, activities, and managed beans.

A bounded taskflow:

• has single entry point.
• zero or more exit points.
• may accept input parameters.
• may generate return value.
• has its own memory scope called pageflow scope.

The memory scope of a bounded taskflow called pageflow scope allows the developer to declare java bean classes in that scope making it available/accessible across all the JSF pages within the taskflow.

In this article we will look at how to create ADF bounded taskflow using JDeveloper. I am using JDeveloper Studio Edition Version 11.1.2.1.0 for this article.

Creating a new ADF Web Application

:
From the Application Navigator click on New Application and you should see this popup:

Select Fusion Web Application(ADF) and click on Ok to get the next popup:

Enter the Application name as BoundedTaskFlowCreation and then click on Finish button to create a new application. Once you have created a new application you would get this view:

With this you have your new ADF application setup. You would see 2 projects: Model and ViewController (assuming you didn’t change the defaults apart from adding new application name while creating the new application). The Model project contains all the code which deals with ADF Data binding layer called- ADFBC and ViewController project contains all the view related code like the JSF pages, the java classes which act as managed beans for those JSF pages.

Creating a new bounded taskflow

Right click on the ViewController project and click on New:

In the new window select JSF/Facelets from the Web Tier categories in the right and then select ADF Taskflow from the right and click on Ok as shown below:

In the Create Taskflow window enter the File Name which would be the name of the bounded taskflow, let the Directory be default, check the Create as Bounded Taskflow check box and uncheck the Create with Page Fragments checkbox. After you have entered the details, your screen would be more or less like:

A bounded taskflow is represented by an XML config file which contains the views/pages part of the taskflow, the control flow structure i.e navigation from one page/view to another which can also include conditional flows, any java bean classes which are referenced by the views/pages within the taskflow which are called as Managed beans. And creating a bounded taskflow with pagefragements will not allow it to be launched independently and hence I am creating a bounded taskflow without page fragments. A bounded taskflow with page fragments would allow us to create only JSFF files i.e JSF fragment files.

Once you have clicked on Ok, you will be shown the Bounded Taskflow Diagrammatic view as shown below:

Generally lot of the work with taskflows can be easily done using the diagrammatic view. Most of us should be familiar with the GUI builders which are used for creating Swing applications or Flex applications. When we drag and drop components on the taksflow diagram, there is code generated in the XML which corresponds to the components added. You should be able to see the component palette on the right hand side and the Properties Inspector window at the bottom (the screenshot shown above shows the two windows). If you are not able to see these windows, you can always add them from the View menu.

In the component palette you can see a plethora of components which can be added to the taskflow. Search for View and then drag drop the View(ADF Task Flow.Components) on to the taskflow area. And then enter the name of the view as: firstPage. You should now see a view component in the taskflow as shown below:

Note that after adding the View component no JSF/JSP page has been created. To create a JSF page for that view double click on the view component to get the following popup:

You can select/choose from the Layouts or just select the Blank option to create a new JSF page. In the same way described above add another view: secondPage.

One can see a light green shade around firstPage component. This indicates that the default activity for the bounded taskflow is firstPage. One can change the default activity by selecting the bounded taskflow and changing the Default Activity property from the Property Inspector window.

Now I want to navigate from firstPage to secondPage drag and drop the Control Flow case by dragging from firstPage to secondPage and name that navigation as gotoSecond. The taskflow diagram would be as shown below:

And after all this lets have a look at the XML for the first-bounded-task-flow.xml:

<?xml version="1.0" encoding="windows-1252" ?>
<adfc-config xmlns="http://xmlns.oracle.com/adf/controller" version="1.2">
  <task-flow-definition id="first-bounded-task-flow">
    <default-activity>firstPage</default-activity>
    <view id="firstPage">
      <page>/firstPage.jsf</page>
    </view>
    <view id="secondPage">
      <page>/secondPage.jsf</page>
    </view>
    <control-flow-rule id="__1">
      <from-activity-id>firstPage</from-activity-id>
      <control-flow-case id="__2">
        <from-outcome>gotoSecond</from-outcome>
        <to-activity-id>secondPage</to-activity-id>
      </control-flow-case>
    </control-flow-rule>
  </task-flow-definition>
</adfc-config>

Now double click on firstPage view to get the firstPage.jsf and switch to the Source view. Now add the following code to the firstPage.jsf between the af:form tag:

<af:outputText value="This is first page" id="ot1"/>
<af:commandButton text="Goto Second Page" id="cb1" action="gotoSecond"/>

The above code shows- an output text to show some text and a button to navigate to the next page. The action attribute above is assigned the name of the control flowcase created above.

Now go back to the first-bounded-task-flow and double click on the secondPage view to get secondPage.jsf. In the secondPage.jsf add the following code between af:form tag:

<af:outputText value="This is second page" id="ot1"/>

Now you have a bounded taskflow and go to the bounded taskflow and right click and then click on Run for the application to be deployed. It will run an Integrated Web Logic server and deploy the application to it.

Once the application runs- you will get a page which shows:

Now clicking on the button would take you to the next page.

I have uploaded the project for anyone who wants to look into the project.

JSF Books:

• Java Server Faces in Action (Amazon.com)
• Mastering Java Server Faces (JSF)
• Core Java Server Faces (JSF) (Amazon.com)

If you are interested in receiving the future java articles and tips from us, please subscribe here.

If you have any doubts on ADF or Java Server faces (JSF), please post it in the comments section.

The Pro Java 7 NIO.2 book is all about the latest enhancements to the File NIO APIs added as part of Java 7.

The book covers

• New Path and Paths API: A brief overview of the Path and Paths classes and how these can be used to represent a file/directory. Also explained are the different parts of a Path.
• Obtaining the Metadata of a given file: This covers obtaining the metadata of the file like ownership, permissions, size, modification, creation time and how this information various between a Unix and Windows platforms.
• Managing Symbolic and Hard links for files: Creating Symbolic and Hard links to files and directories.
• New Files API with new utility methods to operate on files and directories: A new Files class is added which provides lot of utility methods to operate on the files and directories. This book covers few of those APIs by providing simple sample programs.
• Recursively visiting the directory using the FileVisitor API: This chapter shows how one can recursively visit different directories and also provides sample code for different scenarios where this API can be used.
• Watch Service API: This new API allows the developer to watch a given directory for various operations like modify, create and delete and lets developer write code to be notifies of such events.
• Random Access Files: This chapter covers the API support for random access of files.
• Socket APIs: This chapter covers various ways in which one can write Client-Server applications and provides code samples for both blocking and non blocking APIs.
• Asynchronous APIs: This chapters covers performing Asynchronous read and write operations on file and also Asynchronous socket programming.

Salient features of the book

• covers all of the NIO enhancements added as part of Java 7.
• provides complete code samples to help reader to try out the APIs.
• starts chapter with a brief overview of the APIs, but more importance is on the complete code examples.
• more of an hands on book and not suitable for reading without trying out the code.

Intended Audience

This book is for people who are familiar with Java and have experience working or using File APIs. If you are familiar with the NIO APIs then that’s an added benefit. I would recommend this book if you want to explore the NIO2 enhancements added as part of Java 7. You need not read this book end-to-end in one sitting, one can always use this book as a reference and pick it up as and when you want to explore the API which it covers.

Buy this book

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 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.

In this example we make use of ServerSocketChannel and SocketChannel to create a simple Echo application where in the Server would print the data sent by the client.

The code is explained with the required comments:

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

/**
 * This creates a server on a particular IP address and the port.
 *
 */
public class ServerClass {

  public static void main(String[] args) {

    // Create a Server socket channel.
    try (ServerSocketChannel serverSocket = ServerSocketChannel.open()) {

      // Bind the server socket channel to the IP address and Port
      serverSocket.bind(new InetSocketAddress("127.0.0.1", 6667));
      System.out.println("Waiting for client connections");

      while (true) {
        
        //Wait and Accept the client socket connection. 
        try (SocketChannel socketChannel = serverSocket.accept()) {
          
          //Printing the address of the client.
          System.out.println("Obtained connection from: "+socketChannel.getRemoteAddress().toString());
          
          //Creating a reader for reading the content on the socket input stream.
          Scanner socketReader = new Scanner(socketChannel.socket().getInputStream());
          while(socketReader.hasNext()){
            
            //Reading the content of the socket input stream.
            System.out.println(socketReader.nextLine());
            
          }

        } catch(IOException ex){
          ex.printStackTrace();
        }
      }

    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }

}

and the client which connects to the server is:

import java.io.IOException;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;

public class CilentClass {
  
  public static void main(String[] args) {
    
    //Create a client socket.
    try(SocketChannel socketChannel = SocketChannel.open()){
      
      //Bind the client socket to the server socket.
      socketChannel.connect(new InetSocketAddress("127.0.0.1", 6667));
      
      //Writing to the socket channel.
      PrintWriter writer = new PrintWriter(socketChannel.socket().getOutputStream(), true);
      writer.println("Client sending instruction 1");
      writer.println("Client sending instruction 2");
      writer.println("Client sending instruction 3");
      writer.println("Client sending instruction 4");
      
    }catch(IOException ex){
      ex.printStackTrace();
    }
    
  }
}

ByteBuffer provides plethora of methods to fetch data from the buffer and to add data to the buffer. The below code shows the use of those APIs:

import java.nio.ByteBuffer;

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

    //Create a directBuffer of size 200 bytes
    ByteBuffer directBuffer = ByteBuffer.allocateDirect(200);
    
    //Create a nonDirectBuffer of size 200 bytes
    ByteBuffer nonDirectBuffer = ByteBuffer.allocate(200);
    
    //Get the capacity of the buffer
    System.out.println("Capacity "+nonDirectBuffer.capacity());
    
    //Get the position of the buffer
    System.out.println("Position "+nonDirectBuffer.position() );
    
    //Add data of different types to the buffer
    nonDirectBuffer.putChar('A');
    nonDirectBuffer.putInt(10);
    nonDirectBuffer.putDouble(0.98);
    
    //Get the position of the buffer, would print 14 as its has 14 bytes of data
    System.out.println("Position "+nonDirectBuffer.position() );
    nonDirectBuffer.putFloat(8.9f);
    
    //Fetch the data from buffer
    System.out.println(nonDirectBuffer.getChar(0));
    
    //A char is of 2 bytes, so fetch the integer at index 0+2=2bytes
    System.out.println(nonDirectBuffer.getInt(2));
    
    //A int is of 4 bytes so fetch the double value at index 2+4=6bytes
    System.out.println(nonDirectBuffer.getDouble(6));
    
    //A double is of 8 bytes so fetch the float value at index 6+8=14bytes
    System.out.println(nonDirectBuffer.getFloat(14));
   
  }
}

Lazy Initialization is a technique where one postpones the instantiation of a object until its first use. In other words the instance of a class is created when its required to be used for the first time. The idea behind this is to avoid unnecessary instance creation. But there are concerns related to using such approaches in a concurrent scenario. But before that lets see how lazy initialization looks:

class ResourceManager{
  private Resource resource;
  public Resource getResource(){
    if ( resource == null ){
      resource = new Resource();
    }
    return resource;
  }
}

When the above code is executed in a multi threaded program the concern that immediately comes to the mind is the “Race condition”.
Thread A would check that resource == null so it goes inside to create the instance but might go into Runnable status before it creates the Resource instance.
Thread B also checks that resource == null and it goes ahead, creates the instance and uses it for its operations.
Thread A comes back to running status and it also continues to create its own instance and start using it.

Now in the above case suppose we wanted both Thread A and Thread B to work on the same instance, but due to the race condition they would work on different instances. If the Resource instances has state information associated with it then it because a critical problem. Lets stop here and then see how Singleton is related to this.

Singleton

Singleton is one of the Creational Design Patterns discussed in the GoF Design Patterns. The main idea behind the Singleton pattern is to control the creation of objects for a given class such that at any time there’s only one instance of that particular class. So lets see how we can implement the Singleton pattern:

class Resource{
  private static Resource instance;
  public static Resource getInstance(){
    if ( instance == null){
      instance = new Resource();
    }
    return instance;
  }
}

where in the above example Resource is a singleton. This is very similar to the concept of lazy initialization and this as well suffers from the issues seen while using this is a multi threaded environment/program.

Double Checked Locking

One way to solve the problem with Lazy initialization and singleton in a multi threaded program is to declare the getInstance() or getResource() method as synchronized. But its a huge overhead because everytime the method is invoked it has to go through the process of waiting for the lock and then obtaining the lock and its unnecessary because its only once that the instance is created and all subsequent invocations would just return that instance.

To work around this issue, Double Checked Locking is the pattern used. In this approach the methods are not synchronized instead the instance creation code is put in a synchronized block. Let me show an example:

class Resource{
  private static Resource instance;
  public static Resource getInstance(){
    if ( instance == null ){
      synchronized(Resource.class){
        if ( instance == null ){
          instance = new Resource();
        }
      }/end of synchronized block.
    }
    return instance;
  }
}

In the above code there are two null checks- one outside the synchronized block and one within it. The synchronized block is executed at most once and any other thread trying to get instance would have to wait until the instantiation to complete.

The above approach also has some issues. The initialization of an object and the creation of instance of that class are 2 different operations. Once the instance of the class has been created that instance is then used to initialize the values of its state either with default values or some user defined values. Now between these 2 operations another thread might invoke the method to get the instance and sees that the instance is already not null and then proceeds with using that instance. Though its the correct instance we wanted the thread to use but that instance hasn’t been initialized yet. This issue is called as Unsafe Publication. Java Concurrency in Practice book has a really good chapter on Java Memory Model and issues related to Safe Publication and Unsafe Publication of instances.

Lazy Initialization holder class idiom

One can read about this Lazy Initialization holder class Idiom in the interview with Joshua Bloch here. It has been covered in Effective Java by Joshua Bloch and also in Java Concurrency in Practice. Let me just share that idea here:

class Resource{
  private static class ResourceHolder{
    static final Resource instance = new Resource();
  }
  public static Resource getInstance(){
    return ResourceHolder.instance;
  }
}

This takes advantage of:

• Eager Initialization
• Class not initialized unless its used/loaded by the class loader the first time its used.

Another interesting discussion related to this on JavaRanch.

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.

In our previous post we saw in detail about the foreach. map, flatMap and collect methods in the Iterable trait. In this post we will look into detail about reduceLeft, reduceRight, foldLeft, foldRight methods of the Iterable trait. These methods are almost similar in the way the operate on the collection so it should be easier to study them together.

reduceLeft/reduceRight: The scala doc declares this method as:

reduceLeft[B >: A](op: (B, A) ⇒ B): B

which means that this method accepts a function which takes in 2 parameters and returns one value. And the way this method works is that it applies the operation/passed function on 2 elements at a time starting from left, and result of each application is used to compare with the next element until the end of list.
Lets use this reduceLeft to find out the largest and smallest elements in the collection of numbers:

scala> numbers.reduceLeft((x,a) => if ( x < a ) a else x)
res86: Int = 42
//smallest element
scala> numbers.reduceLeft((x,a) => if ( x < a) x else a)
res87: Int = 2

reduceRight is exactly similar to reduceLeft the only different being reduceRight applies the operation/passed function on the elements starting from the right of the list.

scala> val numbers = List(4,21,2,4,62,345,67)
numbers: List[Int] = List(4, 21, 2, 4, 62, 345, 67)

//finding maximum
scala> numbers.reduceRight((x,v) => if (x > v) x else v)
res0: Int = 345

//finding minimum
scala> numbers.reduceRight((x,v) => if (x < v) x else v)
res1: Int = 2

foldLeft/foldRight: Exactly similar to the way reduceLeft/reduceRight work with a slight difference being foldLeft/foldRight take in an initial value and then apply the initial value to the first element(either leftmost/rightmost) before proceeding like reduceLeft/reduceRight.
Suppose we want to find the sum of the elements in a list (I can use the “sum” method directly, but for understanding I would use foldLeft/reduceLeft):

scala> val numbers = List(1,2,3,4,5,6,7,8,9,10)
numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//initial seed value of 0 gave the correct sum
scala> numbers.foldLeft(0)((sum,x) => sum + x)
res0: Int = 55

//initial seed value of 10 added 10 to the final sum.
scala> numbers.foldLeft(10)((sum,x) => sum + x)
res1: Int = 65

One another use of foldLeft is to find the factorial:

//factorial of 5
scala> 1.to(5).foldLeft(1)((prod,x)=>prod*x)
res3: Int = 120

//factorial of 6
scala> 1.to(6).foldLeft(1)((prod,x)=>prod*x)
res4: Int = 720

scanLeft/scanRight: It functions exactly similar to foldLeft/foldRight, but instead of returning one value these methods return a collection of values. These collection of values are nothing but the intermediate values obtained while the passed function was applied on the list of numbers.
Lets look at the same factorial example using scanLeft/scanRight:

scala> 1.to(6).scanLeft(1)((prod,x)=>prod*x)
res5: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 1, 2, 6, 24, 120, 720)

scala> 1.to(6).scanRight(1)((prod,x)=>prod*x)
res7: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 6, 30, 120, 360, 720, 720)

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.