[Belenus666]

So habs jetzt fertig.

Wäre nett wenn einer von euch noch mal kurz drüber schaut,
ob ich noch was verbessern kann.

Datei 1

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package bubblesorte4;

/**
 *
 * @author Eike Ulrichs
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        Bubblesort1 b1 = new Bubblesort1();// Erstellen eines neuen Objektes von Bubblesort

        int[] liste = {1, 3, 2, 6, 4, 5, 7};//Array mit Werten

        b1.init(liste.length, liste);

        System.out.println("Array vor Bubblesort"); //Ausgabe
        b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste

        b1.sortOptimal();//Aufrufen der Methode sortOptimal von Objekt b1 Übergabe der Liste
        {System.out.println("Array nach Bubblesort");}

        b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste

        b1.initReverse();// Aufrufen der Methode initReverse von Objekt b1 Übergabe der Liste
        {System.out.println("Umgekehrter Bubblesort");}

        b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste

        b1.while1(); //Aufrufen der Methode While1 von Objekt b1 Übergabe der Liste
        {System.out.println("Array nach While-Bubblesort");}

        b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste


    }
}

Datei 2

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package bubblesorte4;

/**
 *
 * @author Eike Ulrichs
 */
public class Bubblesort1 {

    static int F[];
    static int swap;
    static int inner;

     void init(int laenge, int X[]) {
        F = new int[laenge];
        F = X;
        swap = 0;
        inner = 0;
}
    public static void sortOptimal() { //Erzeugen der Methode "sortOptimal"
        boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung
        int temp; //temporäre Variable

        while (unsortiert) { //Prüfen der Abbruchbedingung
            unsortiert = false; //Setzen des neuen Boolschen-Wertes
            for (int i = 0; i < F.length - 1; i++) { //Während I kleiner Array-Länge
                if (F[i] > F[i + 1]) {//Wenn Elemant i vom Arrax größer als I+1
                    temp = F[i];// Kopieren von Wert i in temp
                    F[i] = F[i + 1];// Kopieren von Wert i+1 in i
                    F[i + 1] = temp; //Kopieren von Wert temp in i+1
                    unsortiert = true; //Setzen des neuen Boolschen-Wertes
                    swap++;
                }
            }
            inner++;
        }
    }

    public static void initReverse() {// Erzeugen der Methode "initReverse"
        boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung
        int temp;// temporäre Variable
         swap = 0;
         inner = 0;
        while (unsortiert) { // Während unsortiert
            unsortiert = false;// Boolscher-Wert ist "False"
            for (int i = 0; i < F.length - 1; i++) {//Während Element I Des Arrays kleiner Element I-1
                if (F[i] < F[i + 1]) {// Wenn Element I von X kleiner Element I+1
                    temp = F[i];// KOpieren des Wertes XI auf temp
                    F[i] = F[i + 1];//Kopieren des Wertes XI+1 auf XI
                    F[i + 1] = temp;//Kopieren des Wertes temp auf XI+1
                    unsortiert = true;// Wahrheitswert auf "true" setzen
                    swap++;
                }
            }
            inner++;
        }
    }

    public static void display() { //Erzeugen der Methode "display"
        System.out.println(java.util.Arrays.toString(F));
        System.out.println("Die Variablen wurden " + swap + " mal vertauscht" );
        System.out.println("Die innere Schleife wurde " + inner + " mal durchlaufen");
        System.out.println();
    }

    public static void while1() { // Erzeugen der Methode "While"

        int i; // Variable zur abarbeitung der Schleife
        swap = 0;
        inner = 0;
        i = 1;                              // Deklaration der i variable mit Wert 1
        while (i < F.length) {              //1. While_Schleife mit Bedingung i kleiner Arraylänge
            int j = F.length - 1;           //Initialisierung und Deklaration der Variable j mir größe Arraylänge -1
            while (j >= i) {                // Während j größer gleich i
                if (F[j] < F[j - 1]) {      // wenn F[j] kleiner F[j-1]
                    int temp = F[j];        // Initialisierund und Wertezuweisung Variable Temp = F[j]
                    F[j] = F[j - 1];        //Kopieren von Wert F[j-1] auf Wert F[j]
                    F[j - 1] = temp;        // Kopieren von Wert Temp auf F[j-1]
                    swap++;                  //Inkrementieren der Variable swa
                }
                inner++;                    //Inkrementieren der Variable inner
                j = j - 1;                  //Dekrementieren der Variable J
            }
            i = i + 1;                      //Inkrementieren der Variable I
        }


    }
}

Habs jetzt mal in Spoiler gepackt damit das nicht die Seite sprengt.