Bubblesort allgemeiner schreiben

[OJBestJ]

Hallo zusammen,
ich habe in Eclipse ein Soldatenarray erstellt und sie mit Bubblesort der Größe nach sortiert und ausgegeben. Meine Frage ist wie ich es allgemeiner schreiben könnte, sodass ich nicht mehr an Soldaten gebunden bin und z.B. noch ein Array an Flugzeugen erstellen und sortieren kann, ohne Bubblesort umschreiben zu müssen.
Und noch eine andere Frage nebenbei: wie kann ich mein Sortierbar Interface vom Bubblesort Package in der Soldat Klasse einbinden?
PS: Keine Ahnung wo die Zeile 66 herkommt, kann sie auch nicht löschen.

package Soldat;
import bubblesort.Bubblesort;

class Armee 
{
    private Soldat[]array;
    public Armee(Soldat[] array)
    {
        this.array=array;
    }
}

public class Soldat 
{
    private String name;
    private int größe;
    
    public Soldat(String name, int größe)
    {
        this.name=name;
        this.größe=größe;
    }

    public String toString()
    {
        return name + " " + größe;
    }
    
    public int getGroesse() 
     {
            return größe;
     }
    
    public int istGrößer(Soldat element)
    {
        Soldat einSoldat =  element;
        if (größe < einSoldat.getGroesse()) {
            return -1;
        } else {
            return größe - einSoldat.getGroesse();
        }
    }

public static void main(String[] args)
{
    Soldat[] Armee1=new Soldat[10];
    Armee Test=new Armee(Armee1);
    Armee1[0]= new Soldat("Heiner", 185);
    Armee1[1]= new Soldat("Klaus", 152);
    Armee1[2]= new Soldat("Jürgen", 176);
    Armee1[3]= new Soldat("Otto", 195);
    Armee1[4]= new Soldat("Hans", 167);
    Armee1[5]= new Soldat("Manfred", 144);
    Armee1[6]= new Soldat("Holger", 177);
    Armee1[7]= new Soldat("Kebab", 133);
    Armee1[8]= new Soldat("Günther", 199);
    Armee1[9]= new Soldat("Werner", 184);
    Bubblesort.sortiere(Armee1);
     <armee1.length;i++)
for(int i=0;i<armee1.length;i++)
{
        System.out.println(Armee1[i]);
    }
}
}
</armee1.length;i++)

package bubblesort;
import Soldat.Soldat;

interface Sortierbar
{
    public int istGrößer(Sortierbar element);
}

public class Bubblesort
{

    public static void sortiere (Soldat[] array)
    {
        boolean swap;   
        Soldat temp;     
      do {
          swap = false;
          for (int i = 0; i < array.length-1; ++i) {
              
              if ( array[i].istGrößer(array[i+1]) < 0) {
                  temp = array[i];
                  array[i] = array[i+1];
                  array[i+1] = temp;
                  swap = true;
              }
          }
      } while (swap);
    }
}

</armee1.length;i++)

 

[Tarrew]

Nennt sich Java Generics.

Einzige Voraussetzung ist in deinem Fall, dass die Klassen dein Interface implementieren müssen. (Wobei es auch das Interface "Comparable" schon gibt, was du eventuell hättest nutzen können)

  public static <S extends Sortierbar> void bubbleSort(S[] unsorted) {
//implement me
}

 

[Tobse]

Als ergänzung zu Tarrews Antwort:

In der Java-Bibliothek wird das "allgemeine" Sortieren mittels Comparator verwirklicht. Ein Comparator vergleicht zwei Objekte und gibt ein int < 0, 0 oder int > 1 zurück, respektiv ob das erste objekt "weniger", "gleich" oder "mehr" wie das Zweite ist. Bsp:

Flugzeug[] flugzeuge = ... ;
Soldat[] soldaten = ...;

// sortiert flugzeuge nach geschwindigkeit
Arrays.sort(flugzeuge, (a, b) -> a.getGeschwindigkeit() - b.getGeschwindigkeit());

// sortiert flugzeuge nach anzahl der Sitzplätze
Arrays.sort(flugzeuge, (a, b) -> a.getAnzahlSitzplaetze() - b.AnzahlSitzplaetze());

// sortiert soldaten nach größe
Arrays.sort(soldaten, (a, b) -> a.getGröße() - b.getGröße());

In deinem Sortieralgorithmus kannst du dann mittels comparator.compareTo(a, b) zwei Objekte vergleichen - völlig egal, welchen typ sie haben und nach welchen Kriterien du sortierst.

 

[OJBestJ]

Nennt sich Java Generics.

Einzige Voraussetzung ist in deinem Fall, dass die Klassen dein Interface implementieren müssen. (Wobei es auch das Interface "Comparable" schon gibt, was du eventuell hättest nutzen können)

  public static <s extends="" sortierbar="" style="font-size: 14px;">void bubbleSort(S[] unsorted) {
//implement me
}

</s>
So funktioniert es danke.

Was ist die Bezeichnung für den Einschub mit den größer und kleiner Zeichen in deinem Code? Das habe ich noch nie gesehen und würde mir gerne durchlesen was das macht. Oder ist das einfach nur die Schreibweise um Interfaces in Methoden ein zu binden?

 

[Tobse]

Diese Schreibweise heisst Lambda-Expression. Als beispiel: Alle Aufrufe an machWas bewirken exakt das selbe (und sind aus sicht der JVM auch genau das selbe, weil hier nur der Compiler eingreifft):

interface EinInterfaceMitNurEinerMethode {
    public int tuWas(int a, String b);
}
class EineKlasseDieEtwasTut {
    public static void machWasAnderes(EinInterfaceMitNurEinerMethode o) {
        // ruft in irgendeinem Kontext o.tuWas(int, String) auf.
    }
}

EineKlasseDieEtwasTut x = new EineKlasseDieEtwasTut();

// So ging es von Java 1.0 bis 1.4
class KonkreteKlasseMitEinerMethode implements InterfaceMitNurEinerMethode {
    public int tuWas(int a, String b) {
        return b.length() - a;
    }
}
x.machWas(new KonkreteKlasseMitEinerMethode());

// ab Java 5 gibt es dann Anonyme Klassen
x.machWas(new EinInterfaceMitNurEinerMethode() {
    pulic int tuWas(int a, String b) {
        return b.length() - a;
    }
});

// Ab Java 8 Gibt es jetzt Lambda-Expressions für diese Anwendungsfälle:
x.machWas((a, b) -> { return b.length() - a; });
// ODER
x.machWas((a, b) -> b.length() - a);
// ODER
class KonkreteKlasseMitMehrerenMethoden { // ACHTUNG!: implementiert nicht das Interface
    public static int trololoStatic(int a, String b) {
        return b.length() - a;
    }
    public int yeeehaw(int a, String b) {
        return b.length() - a;
    }
}
KonkreteKlasseMitMehrerenMethoden obj = new KonkreteKlasseMitMehrerenMethoden();

x.machWas(KonkreteKlasseMitMehrerenMethoden::trololoStatic);
x.machWas(obj::yeeehaw);

Mehr dazu

 

[CSHW89]

Meinte der TE nicht das hier?

< S extends Sortierbar >

Das nennt sich Generics. Siehe auch hier: Rheinwerk Computing :: Java ist auch eine Insel - 9 Generics<T>

Wobei das in diesem Fall nicht unbedingt notwendig ist, da Arrays in Java invariant sind. Das bedeutet, dass z.b. Number[] ein Obertyp von Integer[] ist, da Number ein Obertyp von Integer ist. Bei generischen Klassen gilt das nicht. ArrayList< Number > ist kein Obertyp von ArrayList< Integer >. So könnte die Methode auch einfacher wie folgt aussehen:

public static void bubbleSort(Sortierbar[] unsorted) {
  //implement me
}

lg Kevin