Normally you would use some fixed char encoding.  E.g.

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

One way would be to use a DataOutputStream:

   ByteArrayOutputStream bytestream =
           new ByteArrayOutputStream();
   DataOutputStream datastream =
           new DataOutputStream(bytestream);
   for (double d : aDoubleArray)
       datastream.writeDouble(d);
   datastream.flush();
   byte[] bytes = bytestream.toByteArrray();

which will dump each double as it's raw 8-byte representation to the stream.
Since each double takes exactly 8-bytes regardless of its magnitude, you
probably don't need to include separators in the stream.  If you want them
anyway, then you can add them usng the other methods of DataOutputStream.

Alternatively you can use Double.doubleToLongBits() to convert a double into a
64-bit long with the same bit pattern, and then use bitmanipulation to extract
the 8 individual bytes.

   -- chris

   Note that '&' is not a byte, but a character. It doesn't make sense to
add a '&' to a byte stream; instead, you'd add the ASCII byte-representation
of the '&' character, or the UTF-16LE byte-representation of the '&' (which
is different from the ASCII representation).

   When designing your format, if you're going to have seperators, you have
to make sure that you can distinguish between the seperators and the values.

   An alternative is to use fixed-length value encodings. For example,
always store all your double values as 4 bytes. Then you know where each
double starts or ends, without the use of seperators.

   - Oliver