Benchmarking sorting Strings vs Longs.

BenchmarkSortingStrings.java

package benchmarks;

import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BenchmarkSortingStrings{

    private static SecureRandom random = new SecureRandom();

    private static long START = 0;
    private static long END = 50000000000000L;
    private static int MAX_SIZE = 1000000;

    public static void main(String[] args) {
        System.out.println("Running Sort Test w/ Strings.");
        long[] stringResults = generateStringResults();

        System.out.println("Running Sort Test w/ Longs.");
        long[] longResults = generateLongResults();

        printResults(stringResults, longResults);
    }

    private static long[] generateStringResults() {
        long[] results = new long[MAX_SIZE];
        for (int i = 0; i < MAX_SIZE; i+= 10000) {
            results[i] = testSortString(i);
        }
        return results;
    }

    private static long[] generateLongResults() {
        long[] results = new long[MAX_SIZE];
        for (int i = 0; i < MAX_SIZE; i+= 10000) {
            results[i] = testSortLong(i);
        }
        return results;
    }

    private static void printResults(long[] stringResults, long[] longResults) {
        System.out.println("Elements, Elements in Thousands, String Duration in NS, Long Duration in NS, " +
                "String Duration in MS, Long Duration in MS");
        for (int i = 0; i < stringResults.length; i++) {
            if (stringResults[i] > 0 || longResults[i] > 0) {
                System.out.println(i + ", " + (i / 1000.0) + ", " + stringResults[i] + ", " + longResults[i]
                        + ", " + (stringResults[i] / 1000000.0) + ", " + (longResults[i] / 1000000.0));
            }
        }
    }

    private static long testSortString(int size) {
        List<String> strings = generateStrings(size);
        long start = System.nanoTime();
        Collections.sort(strings);
        return System.nanoTime() - start;
    }

    private static long testSortLong(int size) {
        List<Long> longs = generateLongs(size);
        long start = System.nanoTime();
        Collections.sort(longs);
        return System.nanoTime() - start;
    }

    private static List<String> generateStrings(long size) {
        List<String> strings = new ArrayList<String>();
        for (int i = 0; i < size; i++) {
            strings.add(generateRandomString());
        }
        return strings;
    }

    private static List<Long> generateLongs(long size) {
        List<Long> longs = new ArrayList<Long>();
        for (int i = 0; i < size; i++) {
            longs.add(generateRandomLong());
        }
        return longs;
    }

    private static String generateRandomString() {
        return new BigInteger(130, random).toString(32);
    }

    private static long generateRandomLong() {
        return START + ((long) (random.nextDouble() * (END - START)));
    }
}