• Purpose:
  • Provide access to native I/O services of an operating system while still maintaining platform independence
• Conceuptualization:
  • A channel is a conduit/gateway that uses a buffer to send and receive data

• Implementations:
  • Vary considerably from one operating system to another
• Interfaces:
  • Provide a uniform (i.e., OS-independent) view of the implementations

• Channel :
  • isOpen()
  • close()
• ReadableByteChannel :
  • read()
• WriteableByteChannel :
  • write()
• ByteChannel :
  • Extends ReadableByteChannel and WriteableByteChannel

• The Channel:
  • FileChannel
• Obtaining a Channel:
  • Using the static open() method in the FileChannel class
  • Using the static newByteChannel() method in the Files class

An Example of Input

javaexamples/nio/ShowWithChannel.java

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.nio.file.*;



/**
 * An application that uses a SeekableByteChannel to read some files
 * and display them on the console.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ShowWithChannel
{
    /**
     * The entry point of the application.
     *
     * @param args  The command line arguments (containing the file names)
     */
    public static void main(String[] args)
    {
        for (int i=0; i<args.length; i++)
        {
            Path path = Paths.get(args[i]);
            
            // Use a try-with-resources statement to ensure that the Channel
            // is closed regardless of what exceptions are thrown
            try (SeekableByteChannel channel = Files.newByteChannel(path))
            {
                String  encoding = System.getProperty("file.encoding");
                Charset charset  = Charset.forName(encoding);                

                // Create a ByteBuffer (with capacity 10)
                ByteBuffer buffer = ByteBuffer.allocate(10);
                
                // Iteratively attempt to read bytes into the buffer 
                // (which changes position)
                while (channel.read(buffer) > 0)
                {
                    // Reset the position to 0 and discard the mark 
                    // (so that it can be decoded)
                    buffer.rewind(); 

                    // Convert the ByteBuffer to a CharBuffer 
                    // (which changes position to limit)
                    CharBuffer chars = charset.decode(buffer);
                    
                    // Print the CharBuffer
                    System.out.print(chars);

                    // Set limit to position and position to 0
                    // (so that the buffer can be used for input again)
                    buffer.flip();
                }
            }
            catch (IOException ioe)
            {
                System.out.printf("Couldn't read %s\n", args[i]);
            }
        }
    }
}
        

An Example of Output

javaexamples/nio/AppendToHistory.java

import java.nio.*;
import java.nio.channels.*;
import java.nio.file.*;
import java.io.*;
import java.util.*;

/**
 * An application that appends the command line arguments to 
 * a "history" file.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class AppendToHistory
{
    /**
     * The entry point of the application.
     *
     * @param args  The command line arguments to record
     */
    public static void main(String[] args)
    {
        Set<OpenOption> options = new HashSet<OpenOption>();
        options.add(java.nio.file.StandardOpenOption.APPEND);
        options.add(java.nio.file.StandardOpenOption.CREATE);
        
        Path path = Paths.get("./history.txt");

        // Use a try-with-resources statement to ensure that the Channel
        // is closed regardless of what exceptions are thrown
        try (SeekableByteChannel channel = Files.newByteChannel(path, options))
        {
            for (int i=0; i<args.length; i++)
            {
                byte[]     data   = args[i].getBytes();
                ByteBuffer buffer = ByteBuffer.wrap(data);

                channel.write(buffer);
            }
        }
        catch (IOException ioe)
        {
            System.out.printf("Unable to open history.txt\n");            
        }
    }
}
        

• Convenience Methods for Input:
  • Files.readAllBytes(Path) returns a byte[]
  • Files.readAllLines(Path) returns a List<String>
• Convenience Methods for Output:
  • Files.write(Path, byte[])

An Example using Convenience Methods

javaexamples/nio/ShowWithConvenienceMethods.java

import java.io.*;
import java.nio.file.*;
import java.util.*;


/**
 * An application that uses convenience methods in Java's "New I/O"
 * package to read some files and display them on the console.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ShowWithConvenienceMethods
{
    /**
     * The entry point of the application.
     *
     * @param args  The command line arguments (containing the file names)
     */
    public static void main(String[] args)
    {
        for (int i=0; i<args.length; i++)
        {
            try
            {
                List<String> lines = Files.readAllLines(Paths.get(args[i]));
                for (String line: lines)
                {
                    System.out.println(line);
                }
            }
            catch (IOException ioe)
            {
                System.out.printf("Couldn't read %s\n", args[i]);
            }
        }
    }
}
        

• Purpose:
  • Controlling access at the process level
• Some Limitations:
  • Specific features are OS-specific
  • Locks are applied per file (not per channel)

• Purpose:
  • Perform a single I/O operation on multiple buffers
• When Writing:
  • Drain data from multiple buffers and send it along on channel
• When Reading:
  • Fill multiple buffers in sequence (until each reaches its limit) from a single channel

• ScatteringByteChannel :
  • Has a read() method that is passed a ByteBuffer[]
• GatheringByteChannel :
  • Has a write() method that is passed a ByteBuffer[]

• DatagramChannel :
  • A channel for datagram-oriented sockets
• SocketChannel :
  • A channel for stream-oriented sockets