Actually very easy to do.  Just create a String from your byte[] buffer
and split it on the 0s.

public class test {
    public static void main (String[] args) throws Exception {
        byte[] buf = { 0x54, 0x48, 0x49, 0x53, 0x00, 0x49, 0x53, 0x00,
         0x41, 0x00, 0x54, 0x45, 0x53, 0x54, 0x00 };

        String str = new String(buf);
        String[] arr = str.split("\u0000");

        for (int i=0; i<arr.length; i++)
            System.out.println(arr[i]);
    }
}

There is no easy way to do it.  That's to say, the /code/ will be trivially
simple once you know what you have to do, but finding out what you have to do
will be tricky unless the C programmers who generate the input are unusually
knowledgeable.

There is no equivalence between character data and binary data, so one is
always turned into the other by using some character encoding or other (often
called a "charset" or a "code page").  In Java, when you convert bytes to text
(or vice versa) you /always/ have to tell the system what character encoding to
use.  (There are some "convenience" methods which use a system-default code
page, but you should avoid those in most circumstances, and you should
/definitely/ avoid them in this case).

So how do you find out what character set has been used by the C programmers ?
The first thing to do is to ask them.  The chances are fairly good that they'll
have no idea what you are talking about.  If not, then presumably they haven't
taken any steps at all to /control/ what code page is being used, and it will
be either:
   some system default, if they are generating the text themselves
or
   whatever character set the /real/ source of the data used.

If they are generating the data themselves, then you can probably get a decent
guess as to what character set they are using by running the following little
Java programs on the machine where they compile their stuff.

   public class Main
   {
       public static void
       main(String[] args)
       {
            System.out.println(
                   "file.encoding: "
                + System.getProperty("file.encoding"));
       }
   }

That will tell you what character set Java thinks is most likely to be a
sensible default for that machine, and it /may/ be correct.  On my system
today, that name is "Cp1252" (which cognoscenti will recognise as meaning I
have a Windows box set up to use an English/Western European character set by
default).

If you can't find any sensible information, then it's probably a good idea to
assume that the data is pure ASCII -- which is a 7-bit encoding which
(therefore) only defines 127 characters, but those 127 characters are common to
all (as far as I know) encodings that your UDP packets are likely to be using.
To use that character encoding use an encoding name of "US-ASCII".

Once you have decided what character set is in use, actually decoding it is
trivial.  Just find the start of the text data in your byte[] buffer (which you
must already know how to do), loop down the buffer looking for the terminating
byte which has value 0 (but see below), and then pass the resulting data into
the String constructor:
   String(byte[] bytes, int offset, int length, String charsetName)
or, if you prefer:
   String(byte[] bytes, int offset, int length, Charset charset)
which will do the conversion for you.

(The potential gotcha about looking for the value 0 is that it assumes that the
data is encoded using an 8-bit (or 7-bit) encoding like "ISO-8859-1", "UTF-8",
or "Cp1252", rather than a 16-bit encoding like "UTF-16" -- but that seems a
safe bet or even C programmers would know that there was a potential problem
and warn you about it.)

If you can, I'd advise getting the C people to send a packet containing /all/
the potential 254 non-zero characters, and then compare what you decode it as
with what they expect it to look like.  Needless to say, you'll have to be
careful about character encoding issues when you do the comparison...

   -- chris