Characters are a higher-level abstraction than bytes.  This database API
of yours provides the ability to work with byte arrays, which means you
can store anything you like there.  The database apparently doesn't
intend to try to interpret what you put into the field, so storing and
retrieving data is entirely up to you.

However, there are several ways of storing characters as bytes (almost
analogous to how there are several ways of storing images -- gif, jpeg,
etc.).  It's important to be consistent in how you do it.  The ways of
storing characters as binary data are called encodings.  Common
encodings for characters include ASCII, UTF-8, or ISO8859-1.

If you've got a String, you can get a byte[] from it using:

   byte[] bytes = myString.getBytes("UTF-8");
   setScratchPage(bytes);

and then:

   byte[] bytes = getScratchPad();
   String myString = new String(bytes, "UTF-8");

(And, of course, UTF-8 can be replaced with any other character encoding
name recognized by Java, as well.)  Since your database API is dealing
with in-memory representations, you don't really gain too much by using
streams for this task... but if you want to use a stream, then it looks
like this:

   ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
   OutputStreamWriter writer =
       new OutputStreamWriter(byteOut, "UTF-8");

   try
   {
       writer.write(myString);
   }
   finally
   {
       writer.close();
   }

   byte[] bytes = byteOut.toByteArray();

And...

   ByteArrayInputStream byteIn =
       new ByteArrayInputStream(getScratchpad());
   InputStreamReader reader =
       new InputStreamReader(byteIn, "UTF-8");

   StringBuffer sb = new StringBuffer();

   try
   {
       int i;
       while ((i = reader.read()) != -1)
       {
           sb.append((char) i);
       }
   }
   finally
   {
       reader.close();
   }

   String myString = sb.toString();

As a third option, if you're mixing primitives and text together, you
may want to look at DataOutputStream.  It is more limited in how it can
choose forms of storage (it only allows UTF-8 preceded by a 16-bit byte
count), but makes it easy to read and write various types.  That looks
like this:

   ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
   DataOutputStream dataOut = new DataOutputStream(byteOut);

   try
   {
       dataOut.writeUTF(myString);
       dataOut.writeInt(42);
       dataOut.writeDouble(3.14159265);
   }
   finally
   {
       dataOut.close();
   }

   byte[] bytes = byteOut.toByteArray();

And:

   ByteArrayInputStream byteIn = new ByteArrayInputStream();
   DataInputStream dataIn = new DataInputStream(byteIn);

   try
   {
       myString = dataIn.readUTF();
       myInt = dataIn.readInt();
       myDouble = dataIn.readDouble();
   }
   finally
   {
       dataIn.close();
   }

I can't explain your EOFException without seeing the code.  That should
have worked as well.

It's wrong, in any case.  readFully reads bytes.  It is possible to
convert those bytes back into characters, but you're going the hard way
about it if you do so.