Benchmarking neatify

Netification

import java.util.Random;
import java.util.logging.Level;
import java.util.stream.LongStream;

import net.tuis.ubench.UBench;
import net.tuis.ubench.UUtils;


public class NeatNums {
    
    private static final int GROUP_LENGTH = 3;
    private static final char DEFAULT_DELIMITER_CHAR = ' ';


    public static String neatify(final long number,
            final char delimiter) {
        final char[] charArray = Long.toString(number).toCharArray();
        final StringBuilder sb = new StringBuilder();

        int index;

        if (charArray[0] == '-') {
            sb.append('-');
            index = 1;
        } else {
            index = 0;
        }

        sb.append(charArray[index++]);

        for (; index < charArray.length; ++index) {
            if ((charArray.length - index) % GROUP_LENGTH == 0) {
                sb.append(delimiter);
            }

            sb.append(charArray[index]);
        }

        return sb.toString();
    }

    public static String neatify(final long number) {
        return neatify(number, DEFAULT_DELIMITER_CHAR);
    }


    public static String neatifyRL(final long val) {
        return neatifyRL(val, ' ', 3);
    }

    public static String neatifyRL(final long val, final char pad, final int span) {
        if (val < 0) {
            if (val == Long.MIN_VALUE) {
                long minblock = (long)Math.pow(10, span);
                // recursive hot-fix for otherwise impossible-to-make-positive value.
                return neatifyRL(val / minblock, pad, span) + pad + neatifyRL(-(val % minblock), pad, span);
            }
            return "-" + neatifyRL(-val, pad, span);
        }

        final String raw = Long.toString(val);
        int end = raw.length() - span * ((raw.length() - 1) / span);
        int start = 0;
        StringBuilder sb = new StringBuilder(raw.length() + (raw.length() / span) + 1);
        while (start < raw.length()) {
            sb.append(pad);
            sb.append(raw.substring(start, end));
            start = end;
            end = start + span;
        }
        return sb.substring(1);
    }



    public static void main(String[] args) {
        Random rand = new Random();

        final long[] tobeneat = LongStream.generate(rand::nextLong).limit(1000).toArray();

        UUtils.setStandaloneLogging(Level.INFO);
        UBench bench = new UBench("NumberPad");
        bench.addTask("OP", () -> LongStream.of(tobeneat).mapToObj(v -> neatify(v)).mapToInt(String::length).sum());
        bench.addTask("RL", () -> LongStream.of(tobeneat).mapToObj(v -> neatifyRL(v)).mapToInt(String::length).sum());

        bench.press(10000).report();

        //        LongStream.generate(rand::nextLong).limit(1000).mapToObj(val -> neatify(val, ',', 4)).forEach(System.out::println);
        //        System.out.println("Test " + Long.MAX_VALUE + " -> " + neatify(Long.MAX_VALUE, ',', 4));
        //        System.out.println("Test " + 0 + " -> " + neatify(0, ',', 4));
        //        System.out.println("Test " + Long.MIN_VALUE + " -> " + neatify(Long.MIN_VALUE, ',', 4));
        //        
        //        for (long v = -10; v <= 10000; v++) {
        //            String x = Long.toString(v);
        //            String g = neatify(v, ',', 4);
        //            String gns = g.replaceAll(",+", "");
        //            if (!gns.equals(x)) {
        //                System.out.printf("Failed %d got %s not %s\n", v, g, x);
        //            }
        //        }
    }


}

Task NumberPad -> OP: (Unit: MILLISECONDS)
  Count    :    10000      Average  :   0.2130
  Fastest  :   0.1888      Slowest  :   6.9253
  95Pctile :   0.2632      99Pctile :   0.4653
  TimeBlock : 0.266 0.225 0.225 0.200 0.203 0.208 0.200 0.203 0.199 0.202
  Histogram :  9710   268    15     2     4     1

Task NumberPad -> RL: (Unit: MILLISECONDS)
  Count    :    10000      Average  :   0.3518
  Fastest  :   0.3101      Slowest  :  14.3632
  95Pctile :   0.5687      99Pctile :   0.6429
  TimeBlock : 0.459 0.357 0.372 0.332 0.336 0.347 0.332 0.329 0.327 0.327
  Histogram :  9848   141     2     4     3     2