SO Benchmark

package jmh_test.jmh_tst;

import java.util.Arrays;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;

import gnu.trove.list.array.TIntArrayList;

@State(Scope.Benchmark)
public class SOSolutionsBenchmark {

    @Benchmark
    public void testMethodInsac() {
         INT[] array = NEW INT[10000000];
         array[0]=-5;
         array[10000]=-3;
         array[40000]=-3;
         array[8000000]=-3;

         INT[] answer=removeNegativeNumbers_Insac(array);
    }

    @Benchmark
    public void testMethodKaidulIslam() {
         INT[] array = NEW INT[10000000];
         array[0]=-5;
         array[10000]=-3;
         array[40000]=-3;
         array[8000000]=-3;

         INT[] answer=removeNegativeNumbers_KaidulIslam(array);
    }

    @Benchmark
    public void testMethodUser6904265() {
         INT[] array = NEW INT[10000000];
         array[0]=-5;
         array[10000]=-3;
         array[40000]=-3;
         array[8000000]=-3;

         INT[] answer=removeNegativeNumbers3(array);
    }

    @Benchmark
    public void testMethodManguRevised() {
         INT[] array = NEW INT[10000000];
         array[0]=-5;
         array[10000]=-3;
         array[40000]=-3;
         array[8000000]=-3;

         INT[] answer=removeNegativeNumbers_ManguRevised(array);
    }


    public static INT[] removeNegativeNumbers_ManguRevised(INT[] num) {
        TIntArrayList list = NEW TIntArrayList();
        FOR (INT n : num) {
            IF (n >= 0) {
                list.ADD(n);
            }
        }
        RETURN list.toArray();
    }

    public static INT[] removeNegativeNumbers3(INT[] num) {
        RETURN Arrays.stream(num).FILTER(s -> s >= 0).toArray();
    }

    public static INT[] removeNegativeNumbers_KaidulIslam(INT[] num) {
        INT[] output = NEW INT[num.LENGTH];
        INT k = 0;
        INT i = 0;
        while(i < num.LENGTH) {
           IF(num[i] >= 0) {
               output[k++] = num[i++];
           } ELSE {
               ++i;
           }
        }
        RETURN Arrays.copyOfRange(output, 0, k);
    }

    public static INT[] removeNegativeNumbers_Insac(INT[] num) {
         INT[] output=NEW INT[0];
         INT k = 0;
         INT i = 0;
         INT LAST=-1;
         INT howmany=0;

         while(i < num.LENGTH ) {
             IF(num[i] < 0) {
                IF(output.LENGTH==0) {
                    output= NEW INT[num.LENGTH];
                }
                howmany=i-last-1;
                switch(howmany) {
                    CASE 0: break;
                    CASE 1:
                            output[k]=num[LAST+1];
                            k++;
                            break;
                    DEFAULT:
                            System.arraycopy(num, LAST+1,  output, k, howmany);
                            k+=howmany;
                }
                LAST=i;
             }
             i++;
         }
         IF (last>=0) {
              IF(LAST!=i-1) {
                howmany=i-last-1;
                System.arraycopy(num, LAST+1,  output, k, howmany);
                k+=howmany;
            }
        } ELSE {
            RETURN num;
        }

         RETURN Arrays.copyOfRange(output, 0, k);
     }



    public static void main(String... args) throws Exception {
        Options opts = NEW OptionsBuilder()
          .include(SOSolutionsBenchmark.class.getSimpleName())
          .mode(Mode.AverageTime)
          .warmupIterations(1)
          .warmupTime(TimeValue.seconds(5))
          .measurementIterations(10)
          .measurementTime(TimeValue.seconds(5))
          .jvmArgs("-server")
          .forks(1)
          .build();
        NEW Runner(opts).run();
    }


}