Writing part:

for (int i = 0; i < prices.length; i++) {
    buf.putDouble(prices[i]);
    buf.putInt(units[i]);

    byte[] descsBytes = descs[i].getBytes();
    buf.putInt(descsBytes.length);
    buf.put(descsBytes);
}

Reading part:

while (buf.hasRemaining()) {

    price = buf.getDouble();
    unit = buf.getInt();

    int len = buf.getInt();
    byte[] bytes = new byte[len]; 
    buf.get(bytes);
    desc = new String(bytes);

    System.out.format("You ordered %d" + " units of %s at $%.2f%n",
                unit, desc, price);
    total += unit * price;
}

There is simpler approach to decode a ByteBuffer into a String without any problems, mentioned by Andy Thomas.

String s = StandardCharsets.UTF_8.decode(byteBuffer).toString();

ByteBuffer has a method for put'ting an array of byte. Is there a reason to put them one at a time? I note that put(byte) is abstract as well.

So the for loop is simplified to:

bbuf = bbuf.put(bytes, 6, bytes.length);

http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte:A-

EDIT: The Javadoc specifies that put(byte[]) begins at index 0, so use the form put(byte[], index, length) instead.

public final ByteBuffer put(byte[] src)

Relative bulk put method  (optional operation).

This method transfers the entire content of the given source byte array
into this buffer. An invocation of this method of the form dst.put(a) 
behaves in exactly the same way as the invocation

     dst.put(a, 0, a.length) 

Of course, it really should not matter HOW you insert the String bytes. I am just suggesting discovery experimentation.

1. Allocate a new ByteBuffer and set its size to a number large enough in order to avoid buffer to overflow when putting bytes to it
2. Use the asCharBuffer() API method so as to be able to put characters directly into the byte buffer

3. Using the put(String) API method we can put a String directly to the byte buffer

4. The toString() API method returns the string representation of the ByteBuffer’s contents. Do not forget to flip() the ByteBuffer since the toString() API method displays ByteBuffer’s contents from the current buffer’s position on-wards:

UseByteBufferToStoreStrings:

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
public class UseByteBufferToStoreStrings {

    public static void main(String[] args) {

        // Allocate a new non-direct byte buffer with a 50 byte capacity


    // set this to a big value to avoid BufferOverflowException
        ByteBuffer buf = ByteBuffer.allocate(50); 

        // Creates a view of this byte buffer as a char buffer
        CharBuffer cbuf = buf.asCharBuffer();

        // Write a string to char buffer
        cbuf.put("Your sting");

        // Flips this buffer.  The limit is set to the current position and then
        // the position is set to zero.  If the mark is defined then it is discarded
        cbuf.flip();

        String s = cbuf.toString();  // a string

        System.out.println(s);

    }

}

read more...

StringBuffer buf = ...;
byte[] bytes = buf.toString().getBytes("US-ASCII");

or possibly "ISO-8859-1"

You need to use the buffer's position and limit to determine the number of bytes to read.

// ...populate the buffer...
buffer.flip(); // flip the buffer for reading
byte[] bytes = new byte[buffer.remaining()]; // create a byte array the length of the number of bytes written to the buffer
buffer.get(bytes); // read the bytes that were written
String packet = new String(bytes);

In my opinion you shouldn't really be using the backing array() at all; it's bad practice. Direct byte buffers (created by ByteBuffer.allocateDirect() won't have a backing array and will throw an exception when you try to call ByteBuffer.array(). Because of this, for portability you should try to stick to the standard buffer get and put methods. Of course, if you really want to use the array you can use ByteBuffer.hasArray() to check if the buffer has a backing array.

Check out the CharsetEncoder and CharsetDecoder API descriptions - You should follow a specific sequence of method calls to avoid this problem. For example, for CharsetEncoder:

1. Reset the encoder via the reset method, unless it has not been used before;
2. Invoke the encode method zero or more times, as long as additional input may be available, passing false for the endOfInput argument and filling the input buffer and flushing the output buffer between invocations;
3. Invoke the encode method one final time, passing true for the endOfInput argument; and then
4. Invoke the flush method so that the encoder can flush any internal state to the output buffer.

By the way, this is the same approach I am using for NIO although some of my colleagues are converting each char directly to a byte in the knowledge they are only using ASCII, which I can imagine is probably faster.