sortierung java

public class Sortierung
{
    public static void main(String[] args)
    {
        java.util.Random numberGenerator = new java.util.Random();
        try
        {
            //Überprüft ob ein Parameter für die Feldgröße angegeben wurde und gibt eine Fehlermeldung aus wenn dies nicht der Fall ist
            if(args.length < 1 || args.length > 3)
            {
                System.out.println("Bitte Feldgröße als ersten Parameter, Sortierungsart als zweiten Parameter und die Befüllungsart des Arrays als dritten Parameter angeben");
            }
            else
            {
                //Verändert den Parameter vom String zum Int
                int size = Integer.parseInt(args[0]);
                //Überprüft ob falsche Parameter angegben wurden und gibt eine Fehlermeldung aus
                if(size < 0 )
                {
                    System.out.println("Bitte Feldgröße als positive ganze Zahl angeben");
                }
                else
                {
                    //Erstellt ein Array mit der größe des ersten Parameters
                    int arr[] = new int[size];
                    //Füllt das Array mit zufälligen Zahlen wenn kein zweiter Parameter oder "rand" als Parameter angegben wird
                    if( (args.length == 3 && args[2] == "rand" ) || args.length<3)
                    {
                        for(int i = 0; i < arr.length; i++)
                        {
                            arr[i] = numberGenerator.nextInt();
                        }
                        System.out.println("Befüllungsart Random");
                    }
                    //Füllt das Array aufsteigend wenn "auf" als zweiter Parameter angegben wird
                    else if(args[2] == "auf")
                    {
                        for(int i = 0 ; i < arr.length; i++)
                        {
                            arr[i] = numberGenerator.nextInt();
                        }
                        mergeSort(arr, 0, arr.length-1);
                        System.out.println("Befüllungsart aufsteigend");
                    }
                    //Füllt das Array absteigend wenn "ab" als zweiter Parameter angegeben wird
                    else if(args[2] == "ab")
                    {
                        for(int i = 0; i < arr.length; i++)
                        {
                             arr[i] = numberGenerator.nextInt();
                        }
                        insertionSortDescending(arr);
                        System.out.println("Befüllungsart absteigend");
                    }
                    else
                    {
                        System.out.println("Zweiter Parameter ist für Befüllungsart des Arrays : random, auf, ab");
                    }
                    if(args.length > 1 && args[1] == "insert")
                    {
                            System.out.println("InsertionSort");
                            //Laufzeit Überprüfung InsertionSort
                            long tStart, tEnd, msecs;
                            tStart = System.currentTimeMillis();
                            //Sortiert das Array mit InsertionSort
                            insertionSort(arr);
                            tEnd = System.currentTimeMillis();
                            msecs = tEnd - tStart;
                            //Gibt die Laufzeit in Millisekunden aus
                            System.out.println(msecs);
                    }
                    else if((args.length == 2 && args[1] == "merge" ) || args.length<2)
                    {
                            System.out.println("MergeSort");
                            //Laufzeit Überprüfung MergeSort
                            long tStart, tEnd, msecs;
                            tStart = System.currentTimeMillis();
                            //Sortiert das Array mit MergeSort
                            mergeSort(arr, 0, arr.length-1);
                            tEnd = System.currentTimeMillis();
                            msecs = tEnd - tStart;
                            //Gibt die Laufzeit in Millisekunden aus
                            System.out.println(msecs);

                    }
                    //Gibt aus ob das Feld aufsteigend sortiert ist oder nicht
                    if(isSorted(arr))
                    {
                        System.out.println("Feld sortiert!");
                    }
                    else
                    {
                        System.out.println("Feld NICHT sortiert!");
                    }
                    if(size<101)
                    {
                        for(int i=0; i < arr.length; i++)
                        {
                            System.out.print(arr[i] + " ");
                        }
                    }
                }
            }

        }
        //Fängt exception wenn kein int wert als Parameter angegben wird und gibt eine Fehlermeldung aus
        catch(NumberFormatException e)
        {
            System.out.println("Bitte Feldgröße in einer ganzen Zahl eingeben");
        }

    }
    //Methode für InsertionSort
    public static void insertionSort(int[] array)
    {
        int key = 0;
        for(int j = 0; j < array.length; j++)
        {
            key = array[j];
            int i = j-1;
            while(i>=0 && array[i]>key)
            {
                array[i+1] = array[i];
                i = i-1;
            }
            array[i+1] = key;
        }
    }

    //InsertionSort absteigend
    public static void insertionSortDescending(int[] array)
    {
        int key = 0;
        for(int j = 0; j < array.length; j++)
        {
            key = array[j];
            int i = j-1;
            while(i>=0 && array[i]<key)
            {
                array[i+1] = array[i];
                i = i-1;
            }
            array[i+1] = key;
        }
    }

    //Methode zum überprüfen ob das array aufsteigend sortiert ist
    public static boolean isSorted(int[] array)
    {
        boolean check = true;
        for(int i=0; i < array.length-1; i++)
        {
            if(array[i] > array[i+1])
            {
                check = false;
            }
        }
        return check;
    }

    public static void mergeSort(int[] array, int p, int r)
    {
        if(p<r)
        {
            int q = (p+r)/2;
            mergeSort(array, p, q);
            mergeSort(array, q+1, r);
            merge(array, p, q, r);
        }
    }

    //merge Methode vereint die zwei Teile aus mergeSort
    public static void merge(int[] array, int low, int middle, int high)
    {
        //Erstellt ein Hilfsarray
        int arr[] = new int[array.length];
        for (int i = low; i <= high; i++)
        {
            arr[i] = array[i];
        }

        int i = low;
        int j = middle + 1;
        int k = low;
        // Kopiert das kleinste Element ins Ursprungsarray
        while (i <= middle && j <= high)
        {
            if (arr[i] <= array[j])
            {
                array[k] = arr[i];
                i++;
            } else
            {
                array[k] = arr[j];
                j++;
            }
            k++;
        }
        // Kopiert den rest des linken Teils ins Array
        while (i <= middle)
        {
            array[k] = arr[i];
            k++;
            i++;
        }
    }
}