Problem with StringBuffer

[Tatu Saloranta]

Wolfgang Muees wrote:
> 
> Am Mit, 29 Mär 2000 schrieb Tatu Saloranta:
> > I finally found out the reason for 'memory leak' on my Java program,
> > and the culprit in this case was StringBuffer - implementation.
> >
...
> > (or length of the buffer via setLength()). The problem here is that
> > as soon as I encounter a long token (~4000 chars in this case),
> > _all_ tokens after that will use up the same 4k memory
> 
> The right solution for this problem is IMO: don't reuse StringBuffer.
> It is designed primary as an input buffer for a single string.

I think I disagree here; at least if there's no other class for similar
purpose. I am interested in optimizing Java-programs, and in general,
one of the most efficient optimizations is to recycle objects. Object
creation is not a cheap operation. Especially in this case, where
StringBuffer does allocate a character array, it means there are at
least 2 memory allocations and other initialization code. If the
array truncation can be done when the array is being copied (during
destringify() or whatever the method was), it won't add a new array
allocation.

An alternative would then be a replacement for StringBuffer that would
be designed to be reusable. Not a huge task, and perhaps it might be
worth the effort, at least in my case.

In any case, I guess it all depends on how difficult it is to alleviate
the problem. The fundamental problem I guess is that although it is
String() instance that should really do the truncation (so as not to
use huge char array for storing just few characters), it is StringBuffer
that is responsible for doing that; String just takes the given array
and length, and after that passively just uses what it got. JDK-fix
notes that, and alleviates the problem so that none of the resulting
strings have higher than 100% overhead. :-)

In any case I think it's an oversight in developers of Java base
classes;
if they had known the problem, there would be something in description
of StringBuffer - class to indicate it's not supposed to be reused.

-+ Tatu +-