Pre allocating collections, maps, stringbuffer

[Stan James]

This little tester seems to tell me there's very little value in specifying the size on the constructor of the classes under test. The output has tabs making it suitable for copy-paste into Excel for graphing nearly flat lines.

Tested on Java 1.4 within WSAD 5.1.2 on laptop with 1.6 ghz, 1 gig of 797mhz memory.

Does this seem like a valid test? I thought about baking up the "entryn" strings in an array before running any tests.

Does it suggest the same thing to you?

import java.util.*;
 
public class PreAllocateTest
{
    public static final int MAX = 100000;
    public static final int STEP = 1000;
    long before = System.currentTimeMillis();
 
    public static void main(String[] args)
    {
        new PreAllocateTest().test();
    }
 
    public void test()
    {
        test(new VectorTest());
        test(new HashMapTest());
        test(new ArrayListTest());
        test(new StringBufferTest());
    }
 
    public void test(ITester tester)
    {
        warmUp(tester);
        for (int presize = 0; presize <= MAX; presize += STEP)
        {
            before = System.currentTimeMillis();
            System.out.print(tester.getName() + "\tPreAllocate\t" + presize + "\t");
            tester.test(presize, MAX);
            report(" MS");
            System.out.println();
            System.gc();
        }
    }
 
    private void warmUp(ITester tester)
    {
        tester.test(MAX, MAX);
        report(tester.getName() + "\tWarmup\t" + MAX + "\tMS");
        System.out.println();
        System.gc();
    }
 
    public void report(String string)
    {
        long elapsed = System.currentTimeMillis() - before;
        System.out.print(string + "\t" + elapsed + "\t");
        before = System.currentTimeMillis();
    }
 
    interface ITester
    {
        public void test(int presize, int count);
        public String getName();
    }
 
    class VectorTest implements ITester
    {
        public void test(int presize, int count)
        {
            Vector vector = new Vector(presize);
            for (int i = 0; i < count; i++)
                vector.add("entry" + i);
        }
        public String getName()
        {
            return "Vector";
        }
    }
    
    class HashMapTest implements ITester
    {
        public void test(int presize, int count)
        {
            Map vector = new HashMap(presize);
            for (int i = 0; i < count; i++)
                vector.put("entry" + i, "entry");
        }
        public String getName()
        {
            return "HashMap";
        }
    }
    
    class ArrayListTest implements ITester
    {
        public void test(int presize, int count)
        {
            List list = new ArrayList(presize);
            for (int i = 0; i < count; i++)
                list.add("entry" + i);
        }
        public String getName()
        {
            return "ArrayList";
        }
    }
    
    class StringBufferTest implements ITester
    {
        public void test(int presize, int count)
        {
            StringBuffer buffer = new StringBuffer(presize);
            for (int i = 0; i < count; i++)
                buffer.append("entry" + i);
        }
        public String getName()
        {
            return "StringBuffer";
        }
    }
}

[William Brogden]

I think the value in allocating collections at the size you expect them to reach instead of letting them expand "automatically" shows up only with really large collections that strain memory management. The new array creation and copying that occurs with automatic expansion is really quite fast.

Bill

[Stan James]

I bet that's right. I ran this up to 100,000 entries to get it to run long enough to measure at all. It would be more interesting on a system that's already running into memory issues. I think I'm not going to bother to pre-allocate until I've seen something cause a problem.

[Stan James]

I tried adding String concatenation to this to compare it to StringBuffer. The warmup() call never returned. I got bored after a few minutes and killed it. I ran it without the warmup and the elapsed time went up on a curve that was getting pretty steep early in the test. Killed again.