Trimming byte array when converting byte array to string in Java/Scala

Several of the String constructors accepts an offset+length into a byte[] - this eliminates the need to create a new trimmed array before hand.

Using one of the overloaded constructors might look like:

def byteArrayToString(x: Array[Byte]) = {
    val loc = x.indexOf(0)
    if (-1 == loc)
      new String(x)
    else if (0 == loc)
      ""
    else
      new String(x, 0, loc, "UTF-8") // or appropriate encoding
}

Or, a slight variation keeping the indexOf:

def byteArrayToString(arr: Array[Byte]) = {
    val loc = arr.indexOf(0)
    // length passed to constructor can be 0..arr.length
    new String(arr, 0, if (loc >= 0) loc else arr.length, "UTF-8")
}

Or, one line (thanks to find/Option):

def byteArrayToString(arr: Array[Byte]) = {
    new String(arr, 0, arr.find(_ == 0) orElse arr.length, "UTF-8")
}

Thoughts on the encoding:

1. Using an explicit encoding is often recommended, and the same encoding should be used specified in getBytes, as the default may change. Here are the standard charset names.

2. The byte 0 may appear in encoded output before the end of the data, depending on the String input (i.e. NUL) and encoding used.

If you just have one String, I would use .getBytes() -

val x:Array[Byte] = "Hello".getBytes("UTF-8");

Output is

x: Array[Byte] = Array(72, 101, 108, 108, 111)

For more then one String, I would use a ByteArrayOutputStream, like so -

val baos = new java.io.ByteArrayOutputStream(10); //  <-- I might not use 10.
                                                  //  <-- Smells of premature opt.
baos.write("Hello".getBytes("UTF-8"));
baos.write(", World!".getBytes("UTF-8"));

val x:Array[Byte] = baos.toByteArray(); // <-- x:Array[Byte], to specify the type.

Output is

x: Array[Byte] = Array(72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33)

You could do it like so:

val bb = java.nio.ByteBuffer.allocate(10).put("Hello".getBytes)
val s = new String(bb.array, 0, bb.position)

though this won't indicate in the ByteBuffer that you've read anything. The normal pattern would be to flip and use limit, but if you're just grabbing the array you may as well just use position instead and clear when you're done before reading more.