«

My problem: I need to create a buffer that needs a capacity sufficient
to hold a row of 80 characters that will be written out to a file, then
modified, then written out to a file again. In C, this could be done
like:

char linebuf[81];

/* code to insert chars in linebuf; as an example: */
linebuf[0] = 'H';
linebuf[1] = 'i';
linebuf[2] = 0; /* null char to terminate string */

/* write the line */
printf("%s\n", linebuf); // "Hi" is written out followed by a
newline.

/* modify line buffer again; no need to allocate/delete memory */
linebuf[0] = 'Y';
linebuf[1] = 'o';
linebuf[2] = '!';
linebuf[3] = 0;

/* write the line */
printf("%s\n", linebuf); // "Yo!" is written out followed by a
newline.


Now my problem is that in Java, I can't figure out how to do this
without allocating new objects. If a use a StringBuffer/StringBuilder
that has a length of 80 characters, there doesn't seem to be a way to
efficiently print only the number of characters that the current row
actually has. (The setLength method creates a new object.) If I use a
char[] in Java then the output routines ignore the terminating null
byte.

There has got to be a way to do this in Java! Thanks for any help.

<> wrote in message
news: oups.com...
> My problem: I need to create a buffer that needs a capacity sufficient
> to hold a row of 80 characters that will be written out to a file, then
> modified, then written out to a file again. In C, this could be done
> like:
>
> char linebuf[81];
>
> /* code to insert chars in linebuf; as an example: */
> linebuf[0] = 'H';
> linebuf[1] = 'i';
> linebuf[2] = 0; /* null char to terminate string */
>
> /* write the line */
> printf("%s\n", linebuf); // "Hi" is written out followed by a
> newline.
>
> /* modify line buffer again; no need to allocate/delete memory */
> linebuf[0] = 'Y';
> linebuf[1] = 'o';
> linebuf[2] = '!';
> linebuf[3] = 0;
>
> /* write the line */
> printf("%s\n", linebuf); // "Yo!" is written out followed by a
> newline.
>
>
> Now my problem is that in Java, I can't figure out how to do this
> without allocating new objects. If a use a StringBuffer/StringBuilder
> that has a length of 80 characters, there doesn't seem to be a way to
> efficiently print only the number of characters that the current row
> actually has. (The setLength method creates a new object.) If I use a
> char[] in Java then the output routines ignore the terminating null
> byte.

I'll skip the standard warning against premature optimization because you
seem determined that allocating memory is implicitly inefficient. A key
problem with null-terminated strings, of course, is that you have to keep
iterating to find the end.

What's wrong with

char [] buffer = new char [81];
// Fill out the buffer

writer.write (buffer, 0, lastIndexWritten + 1);

OR

writer.write (buffer, 0, positionOfZero(buffer) + 1);

You either already know the length in advance and simply use it when writing
data or you have a little iterator utility function that figures out where
the zero is. Or just wrap the ordinary write (char) in a loop that stops
after the zero.

Cheers,
Matt Humphrey http://www.iviz.com/

On 2006-06-30, <> wrote:
If I use a
> char[] in Java then the output routines ignore the terminating null
> byte.

Are you sure about that? Are you passing the byte to the output
routines??

Lordy