Interface Eigene Objekte in Listen sortieren mit Interface Comparable

[Reggie()]

Ich habe viel gesucht und kaum gute Erklärungen bzw. gute Code-Beispiele gefunden. Ich denke mein Code erklärt es ganz anschaulich. Allerdings habe ich auch eine Frage (unter dem Code)

import java.util.ArrayList;
import java.util.Collections;

public class Pizza implements Comparable<Pizza>{
    String name;
    int kalorien;
    boolean mitKaese;
  
    public Pizza(String name, int kalorien, boolean mitKaese) {
        this.name = name;
        this.kalorien = kalorien;
        this.mitKaese = mitKaese;
    }
   public static void main(String[] args) {
        ArrayList<Pizza> pizzen = new ArrayList<Pizza>();
        pizzen.add(new Pizza("Diavolo", 620, true));
        pizzen.add(new Pizza("Salami", 730, false));
        pizzen.add(new Pizza("Funghi ", 510, true));
        pizzen.add(new Pizza("Hawaii", 520, false));
        System.out.println("-----------VORHER---------");
        for (Pizza p : pizzen) {System.out.println(p.toString());}
        Collections.sort(pizzen);
        System.out.println("-----------NACHHER---------");
        for (Pizza p : pizzen) {System.out.println(p.toString());}
    }
   @Override
    public String toString() {
        String kaese = "ohne";
        if (mitKaese) {kaese = "mit";}
        return String.format("Pizza %s %s Käse hat %d Kalorien", this.name, kaese, this.kalorien);
    }
   @Override
    public int compareTo(Pizza p) {
        if (this.kalorien > p.kalorien) {
            return 1;
        } else if ((this.kalorien < p.kalorien)) {
            return -1;
        } else {
            return 0;
        }
    }
}

Erklärung: Die Methode Collections.sort(liste) benutzt standardmäßig die Methode int compareTo(Objekt o) für eine einfache Sortierung von Collections mit "einfachem Inhalt" wie int oder String. Will man Listen mit eigenen Objekte nach bestimmten Attributen sortieren, dann muss man das Interface Comparable implementieren und die Methode compareTo überschreiben.
AUSGABE:

-----------VORHER---------
Pizza Diavolo mit Käse hat 620 Kalorien
Pizza Salami ohne Käse hat 730 Kalorien
Pizza Funghi  mit Käse hat 510 Kalorien
Pizza Hawaii ohne Käse hat 520 Kalorien
-----------NACHHER---------
Pizza Funghi  mit Käse hat 510 Kalorien
Pizza Hawaii ohne Käse hat 520 Kalorien
Pizza Diavolo mit Käse hat 620 Kalorien
Pizza Salami ohne Käse hat 730 Kalorien

Frage: Wie kann man im Methodenaufruf bestimmen, nach welchem Attribut bzw. ob auf- oder absteigend sortiert werden soll.

 

[stg]

Comparable / compareTo ist dazu gedacht eine natürliche Ordnung zu definieren. Die Sortierung mittels Collections#sort erfolt dann immer aufsteigend. Für eine absteigende Sortierung hilft Collections.reverseOrder
Willst du abweichend davon sortieren, so schau dir das Interface Comparator an: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

 

[Reggie()]

Beispiel für manuelle Sortierung eigener Klasse auf verschiedene Art / Attribute

import java.util.ArrayList;

public class Pizza {
    String name;
    int kalorien;
    boolean mitKaese;
    static ArrayList<Pizza> pizzen = new ArrayList<Pizza>();
   
    public Pizza(String name, int kalorien, boolean mitKaese) {
        this.name = name;
        this.kalorien = kalorien;
        this.mitKaese = mitKaese;
    }
    public static void main(String[] args) {
        backePizza();
        zeigePizzen();
    }
    @Override
    public String toString() {
        String kaese = "ohne";
        if (mitKaese) {kaese = "mit";}
        return String.format("Pizza %s %s Käse hat %d Kalorien%n", this.name, kaese, this.kalorien);
    }
    public static void backePizza() {
        pizzen.add(new Pizza("Diavolo", 620, true));
        pizzen.add(new Pizza("Salami", 730, false));
        pizzen.add(new Pizza("Funghi ", 510, true));
        pizzen.add(new Pizza("Hawaii", 520, false));
    }
    public static void zeigePizzen() {
        //alphabetisch, kalorien, Käse
        String ausgabe = "---------UNSORTIERT---------\n";
        for (Pizza p : pizzen) {ausgabe += p.toString();}
        sortierePizzen(1);
        ausgabe +=   "---SORTIERT NACH KALORIEN---\n";
        for (Pizza p : pizzen) {ausgabe += p.toString();}
        sortierePizzen(2);
        ausgabe +=   "-----SORTIERT NACH KÄSE-----\n";
        for (Pizza p : pizzen) {ausgabe += p.toString();}
        sortierePizzen(0);
        ausgabe +=   "----SORTIERT ALPHABETISCH---\n";
        for (Pizza p : pizzen) {ausgabe += p.toString();}
        System.out.println(ausgabe);
    }
    public static void sortierePizzen(int sortierung) {
        //0 Name alphabetisch, 1 Kalorien 2 mit/ohne Käse
        int anz = pizzen.size();
        if (sortierung == 1) {
            int getauscht = 0;
            while (true) {
                for (int i=0; i<anz-1; i++) {
                    if (pizzen.get(i).kalorien > pizzen.get(i+1).kalorien) {
                        Pizza temp = pizzen.remove(i);
                        pizzen.add(i+1, temp);
                        getauscht++;
                    }
                }
                if (getauscht == 0) {
                    break;
                } else {
                    getauscht = 0;
                }
            }
        } else if (sortierung == 2) {
            int getauscht = 0;
            while (true) {
                for (int i=0; i<anz-1; i++) {
                    if (pizzen.get(i).mitKaese && pizzen.get(i+1).mitKaese == false) {
                        Pizza temp = pizzen.remove(i);
                        pizzen.add(temp);
                        getauscht++;
                    }
                }
                if (getauscht == 0) {
                    break;
                } else {
                    getauscht = 0;
                }
            }
        } else {
            int getauscht = 0;
            while (true) {
                for (int i=0; i<anz-1; i++) {
                    if (pizzen.get(i).name.compareTo(pizzen.get(i+1).name)>0) {
                        Pizza temp = pizzen.remove(i);
                        pizzen.add(i+1, temp);
                        getauscht++;
                    }
                }
                if (getauscht == 0) {
                    break;
                } else {
                    getauscht = 0;
                }
            }
        }
    }
}

 

[Joose]

Hier ein Link der dir ein Beispiel zeigt wie man Comparable bzw Comparator verwenden kann:
https://www.tutorialspoint.com/java/java_using_comparator.htm
Oder ein Beispiel nur mit dem Comparator:
https://examples.javacodegeeks.com/core-java/util/comparator/java-comparator-example/

Anmerkung zu deinem Code: die Endlosschleife while(true) sollte man vermeiden und eine "echte" Abbruchbedingung verwenden.

 

[stg]

Viel mehr kann man nicht "falsch" machen. Schau dir doch mal das Comparator-Interface an, wie ich zuvor vorgeschlagen hab.

Und: Pizza Hawaii und Pizza ohne Käse will eh keiner haben!

 

[Flown]

Mal zur Veranschaulichung, wie man das machen kann:

public class Test {
 
  public static void main(String... args) {
    List<Pizza> pizzen = new ArrayList<>();
    pizzen.add(new Pizza("Diavolo", 620, true));
    pizzen.add(new Pizza("Salami", 730, false));
    pizzen.add(new Pizza("Funghi ", 510, true));
    pizzen.add(new Pizza("Hawaii", 520, false));
    System.out.println("-----------VORHER---------");
    pizzen.forEach(System.out::println);
    System.out.println("-----------NATÜRLICHE ORDNUNG - KALORIEN---------");
    pizzen.sort(Comparator.naturalOrder());
    // oder pizzen.sort(null); oder Collections.sort(pizzen);
    pizzen.forEach(System.out::println);
    System.out.println("-----------NATÜRLICHE ORDNUNG - KALORIEN - ABSTEIGEND---------");
    pizzen.sort(Comparator.reverseOrder());
    pizzen.forEach(System.out::println);
    System.out.println("-----------NAME---------");
    pizzen.sort(Comparator.comparing(Pizza::getName, String.CASE_INSENSITIVE_ORDER));
    // ODER:
    pizzen.sort(new Comparator<Pizza>() {
      @Override
      public int compare(Pizza o1, Pizza o2) {
        return String.CASE_INSENSITIVE_ORDER.compare(o1.getName(), o2.getName());
      }
    });
    pizzen.forEach(System.out::println);
    System.out.println("-----------OHNE KÄSE FIRST & NACH NAME---------");
    pizzen.sort(Comparator.comparing(Pizza::isMitKaese).thenComparing(Pizza::getName, String.CASE_INSENSITIVE_ORDER));
    pizzen.forEach(System.out::println);
  }
 
}

class Pizza implements Comparable<Pizza> {
  private String name;
  private int kalorien;
  private boolean mitKaese;
 
  public Pizza(String name, int kalorien, boolean mitKaese) {
    this.name = name;
    this.kalorien = kalorien;
    this.mitKaese = mitKaese;
  }
 
  public String getName() {
    return name;
  }
 
  public int getKalorien() {
    return kalorien;
  }
 
  public boolean isMitKaese() {
    return mitKaese;
  }
 
  @Override
  public int compareTo(Pizza p) {
    return Integer.compare(kalorien, p.kalorien);
  }
 
  @Override
  public String toString() {
    return String.format("Pizza %s %s Käse hat %d Kalorien", this.name, mitKaese ? "mit" : "ohne", this.kalorien);
  }
}