Re: How to get the current allocated total size of an ArrayList?
On 2/23/2011 10:43 AM, Robin Wenger wrote:
Assume I setup an ArrayList like:
ArrayList<String> mylines = new ArrayList<String>();
and add lots of lines/strings to it:
while(...)
mylines.add(...);
How can I find out the total size (in Bytes) which is currently allocated by the ArrayList?
There's no way to be sure, but you can get an estimate. First,
suppose that the ArrayList uses some fixed amount of overhead plus space
for its capacity to store object references. Each reference is probably
four or eight bytes, depending on whether you use a 32-bit or 64-bit
JVM. If the ArrayList is large (so the fixed overhead is negligible),
all you need to do is multiply the capacity by four or eight, and you'll
be fairly close.
There are two problems with this, or possibly more. First, it only
counts the memory used by the ArrayList itself, and not by the objects
that it refers to: If you've filled it with four-byte references to
megabyte objects, you'll be counting the fours and not the megs.
Second, there's no way to query the capacity of an ArrayList! You
know it's at least as great as the size(), but it could be larger by an
unknown amount. You could call trimToSize() to set the capacity equal
to the size(), but the equality would come unglued as soon as you added
the next element (or, conceivably, deleted one). If you're populating
an ArrayList that will thereafter remain unchanged, it's possible to
find the capacity -- but if items are coming and going, the exercise is
fairly futile.
Occasionally I get an OutOfMemory exception. Can I prevent this by preallocating everything in one step
in advance instead of doing this little by little with every add()?
You might, yes, if you're just a *tiny* bit too large. Remember,
the ArrayList does not hold those megabyte objects, just references to
them -- and the references are small. Saving the memory for a few
references may save kilobytes, but won't save the megabytes that the
referred-to objects themselves occupy.
You haven't revealed much about the context of your problem, but
even so I suspect very strongly that you're barking up the wrong tree.
It's probably those gazillions of Strings at a couple dozen bytes each
that use up your memory, not the four or eight bytes per String stored
in the ArrayList. Stop worrying about the cigarette butts on the
beach, and turn your attention to the whale carcasses.
--
Eric Sosman
esosman@ieee-dot-org.invalid