Is it faster to add to a collection then sort it, or add to a sorted collection?

/* see http://stackoverflow.com/questions/3607593/is-it-faster-to-add-to-a-collection-then-sort-it-or-add-to-a-sorted-collection */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.TreeSet;

import org.apache.commons.lang.builder.CompareToBuilder;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;

public class SortingTest{

    public static class Thingy implements Comparable<Thingy>{

        public Thingy(final double part1, final double part2, final double part3){
            this.part1 = part1;
            this.part2 = part2;
            this.part3 = part3;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int hashCode(){
            return new HashCodeBuilder() //
            .append(this.part1)
                .append(this.part2)
                .append(this.part3)
                .toHashCode();
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public boolean equals(final Object obj){
            boolean result;
            if(obj instanceof Thingy){
                final Thingy other = (Thingy) obj;
                result = new EqualsBuilder() //
                .append(this.part1, other.part1)
                    .append(this.part2, other.part2)
                    .append(this.part3, other.part3)
                    .isEquals();
            } else{
                result = false;
            }
            return result;
        }

        private final double part1;

        private final double part2;

        private final double part3;

        @Override
        public int compareTo(final Thingy other){

            return

            new CompareToBuilder().append(calcComp(this), calcComp(other))
                .toComparison();
        }

        private static double calcComp(final Thingy th){
            return Math.pow(th.part1 * th.part3, th.part2);
        }
    }

    public interface Transformer<T extends Comparable<T>> {

        String identifier();

        Collection<T> sort(Collection<T> data);
    }

    public static class ArrayListTransformer<T extends Comparable<T>>
        implements Transformer<T>{

        @Override
        public Collection<T> sort(final Collection<T> data){
            final List<T> list = new ArrayList<T>(data);
            Collections.sort(list);
            return list;
        }

        @Override
        public String identifier(){
            return "ArrayListTransformer";
        }
    }

    public static class TreeSetTransformer<T extends Comparable<T>> implements
        Transformer<T>{

        @Override
        public Collection<T> sort(final Collection<T> data){
            return new TreeSet<T>(data);
        }

        @Override
        public String identifier(){
            return "TreeSetTransformer";
        }
    }

    public static class BestOfBothWorldsTransformer<T extends Comparable<T>>
        implements Transformer<T>{

        @Override
        public Collection<T> sort(final Collection<T> data){
            return new ArrayList<T>(new TreeSet<T>(data));
        }

        @Override
        public String identifier(){
            return "BestOfBothWorldsTransformer";
        }
    }

    public static void main(final String[] args){
        final Map<String, Thingy> map = new HashMap<String, Thingy>();
        final Random rnd = new Random();
        for(int i = 0; i < 10000; i++){
            final double a = rnd.nextDouble();
            final double b = rnd.nextDouble();
            final double c = rnd.nextDouble();
            map.put("" + a + b + c, new Thingy(a, b, c));
        }

        final List<Transformer<Thingy>> transformers =
            Arrays.asList(new ArrayListTransformer<Thingy>(),
                new TreeSetTransformer<Thingy>(),
                new BestOfBothWorldsTransformer<Thingy>());

        final Collection<Thingy> thingies = map.values();
        for(final Transformer<Thingy> transformer : transformers){
            final long before1 = System.nanoTime();
            final Collection<Thingy> sorted = transformer.sort(thingies);
            final long after1 = System.nanoTime();
            for(final Thingy thingy : sorted){
            }
            ;
            final long after2 = System.nanoTime();
            System.out.println("Transformer " + transformer.identifier()
                + "\n\tCreation: " + format(after1 - before1)
                + " \n\tIteration: " + format(after2 - after1)
                + " \n\tItem count: " + sorted.size());
        }

    }

    private static String format(final long nanoseconds){
        return "" + nanoseconds + " ns (" + (double) nanoseconds / 1000000000
            + " seconds)";
    }

}