Hello and welcome to NIO, in this video we will cover the basics of buffer before that let’s focus why we need NIO. NIO was created to allow Java programmers to implement high-speed I/O without having to write custom native code. NIO moves the most time-consuming I/O activities (namely, filling and draining buffers) back into the operating system, thus allowing for a great increase in speed. www.youtube.com/watch?v=rTa68v4Gfrk

1. NIO
Why NIO ?

2. Streams versus blocks
A stream-oriented I/O system deals with data
one byte at a time. An input stream produces
one byte of data, and an output stream
consumes one byte of data .
A block-oriented I/O system deals with data in
blocks
http://www.youtube.com/zarigatongy

3. Buffer Basics
• A buffer is an array of primitive data elements
wrapped inside an object.
• Attributes
– Capacity
– Limit
– Position
– Mark
0 <= mark <= position <= limit <= capacity
http://www.youtube.com/zarigatongy

4. Buffer Types
• ByteBuffer  Direct Buffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer
http://www.youtube.com/zarigatongy

5. ByteBuffer Visual Representation
0
1
X
2
3
4
5
6
0
7
8
10
MARK POSITION
Limit
let's assume that our buffer has a total capacity of Ten bytes
http://www.youtube.com/zarigatongy
9
10
CAPACITY

6. Data in Buffer
buffer.put((byte)'H').put((byte)'e').put((byte)'l').
put((byte)'l').put((byte) ’o’)
0
1
2
h
48
e
65
l
6c
X
MARK
3
l
6c
4
5
6
7
8
9
0
6f
5
10
POSITION
Limit
http://www.youtube.com/zarigatongy
10
CAPACITY

7. Buffer Flipping
buffer.flip()
0
1
2
h
48
e
65
l
6c
X
MARK
3
l
6c
4
5
6
7
8
9
o
6f
0
6
POSITION
Limit
http://www.youtube.com/zarigatongy
10
CAPACITY

8. Buffer Draining
• hasRemaining( )
for (int i = 0; buffer.hasRemaining( ), i++) {
buffer.get( );
}
• remaining( )
int count = buffer.remaining( );
for (int i = 0; i < count, i++) {
buffer.get( );
}
http://www.youtube.com/zarigatongy

9. Buffer Marking
buffer.position(2).mark( ).position(4);
0
1
2
3
4
h
48
r
65
l
6c
l
6c
o
6f
2
MARK
5
6
4
7
6
POSITION
Limit
rewind( ), clear( ), and flip( ) always discard the mark
clear( ) method makes a buffer empty
reset( ) returns the position to a previously set mark
http://www.youtube.com/zarigatongy
8
9
10
CAPACITY

10. Buffer Comparison
• Two buffers are considered to be equal
– Both objects are the same type
– Both buffers have the same number of remaining elements
POSITION
LIMIT
h
68
e
65
l
6c
l
6c
t
74
i
69
l
6c
Buffer
1
l
6c
POSITION
o
6f
Buffer
2
LIMIT
EQUAL Buffer Demo
http://www.youtube.com/zarigatongy

11. Creating Buffer
• Allocation
– ByteBuffer buffer = ByteBuffer.allocate( 1024 );
– CharBuffer charBuffer = CharBuffer.allocate (100);
• Wrap
– byte array[] = new byte[1024]; ByteBuffer buffer =
ByteBuffer.wrap( array );
– char [] myArray = new char [100]; CharBuffer charbuffer =
CharBuffer.wrap (myArray);
– CharBuffer charbuffer = CharBuffer.wrap (myArray, 12, 90);
http://www.youtube.com/zarigatongy

12. Duplicating Buffer
• returns a new byte buffer that shares the old buffer's
content. Changes to the old buffer's content will be
visible in the new buffer, and vice versa.
• The new buffer's capacity, limit, position, and mark
values will be identical to those of this buffer. The new
buffer will be direct if, and only if, this buffer is
direct, and it will be read-only if, and only if, this buffer
is read-only
• CharBuffer buffer = CharBuffer.allocate (8);
buffer.position (3).limit (6).mark( ).position (5);
CharBuffer dupeBuffer = buffer.duplicate( );
http://www.youtube.com/zarigatongy

13. Buffer Slicing
• The slice() method creates a kind of sub-buffer from an
existing buffer
• The content of the new buffer will start at this buffer's
current position. Changes to this buffer's content will
be visible in the new buffer, and vice versa; the two
buffers' position, limit, and mark values will be
independent.
• The new buffer's position will be zero, its capacity and
its limit will be the number of bytes remaining in this
buffer, and its mark will be undefined. The new buffer
will be direct if, and only if, this buffer is direct, and it
will be read-only if, and only if, this buffer is read-only.
http://www.youtube.com/zarigatongy

14. Direct Buffers
• Direct Buffer– The ByteBuffer
– A direct buffer is one whose memory is allocated
in a special way to increase I/O speed
– Given a direct byte buffer, the Java virtual machine
will make a best effort to perform native I/O
operations directly upon it. That is, it will attempt
to avoid copying the buffer's content to (or from)
an intermediate buffer before (or after) each
invocation of one of the underlying operating
system's native I/O operations.
http://www.youtube.com/zarigatongy