Problem mit einer Methode die gewissen Inhalt einer Array löschen soll

[Juicerz]

Hallo zusammen,

Ich habe ein kleine Frage und zwar versuche ich die Methode getAllBooks zum laufen zu bringen, aber irgendwie klappt das nicht.

Die Methode getAllBooks soll eine Liste mit allen Objekten vom Enum-Typ Buch aus dem Array readingList zurückgeben... alle anderen entfernen war mein Ansatz.

Hoffe ihr könnt mir helfen... irgendwie stell ich mich gerade blöde an.

Lg

 

[Juicerz]

public class ReadingList {
    
    private ArrayList<ReadingMaterial> readingList;
    
    public ReadingList() {
        this.readingList = new ArrayList<ReadingMaterial>();
    }
    
    public void addMaterial(ReadingMaterial readingMaterial) {
        this.readingList.add(readingMaterial);
        Collections.sort(readingList);
    }
    
    public ArrayList<ReadingMaterial> getAllBooks(){
        Bookware search = Bookware.valueOf("Book");
        for (int i = 0; i < readingList.size(); i++) {
            if (readingList.get(i).equals(search)) {
                readingList.remove(i);
            }
        }
        return readingList;
    }
    
    public String toString() {
        String readingListString = "***INHALT***\n";
        for (ReadingMaterial z : this.readingList) {
            if(z != null) {
                readingListString += z + "\n";
            }
        }
        return readingListString;
    }

}

 

[DrPils]

In deiner Arraylist sind Objekte vom Typ ReadingMaterial.
Dein Enum ist vom Typ Bookware
Du vergleichst nun ReadingMaterial mit Bookware.
Der vergleich gibt nie true zurück, dementsprechend wird nichts aus deiner Arraylist entfernt.

Wenn ich deinen Code richtig interpretiere würdest du sowieso die gewünschten Bücher entfernen.
Du solltest dir überlegen ob es evtl besser wäre eine neue Liste mit den gewünschten Büchern zurückzugeben.

 

[Juicerz]

Ich habe mir in der Klasse ReadingMaterial eine Methode geschrieben:
Enum-Klasse heisst neu Type.

    public boolean isType(Type type) {
        if (this.type == type) {
            return true; 
        } else {
            return false;
        }
    }

Ich dachte, ich benutze die Methode um das Problem zu lösen, aber jetzt kann ich meine Idee selber nicht zu Ende bringen. Kann mir einer helfen? xD

Die Methode getAllBooks soll eine Liste mit allen Objekten vom Typ Buch (Enum-Klasse Type) aus der ArrayList readingList zurückgeben. Jetzt kam ich auf die Idee eine Methode zu schreiben, die den Typ vergleicht, aber wie kann ich die jetzt hier genau anwenden...

Mein letzter Kläglicher Versuch die Methode zu schreiben:

    public ArrayList<Type> getAllBooks() {
        ArrayList<Type> books = new ArrayList<Type>();
        String search = "Buch";  
        for (int i = 0; i < readingList.size(); i++) {
            if (readingList.get(i).equals(search)) {
                books.add(readingList.get(i));
            }
        }
        return books;
    }

Enum-Klasse:

public enum Type {
    
    Buch,
    Magazin;

}

Klasse ReadingMaterial:

public class ReadingMaterial implements Comparable {
    
    private String name;
    private int pages;
    private Type type;
    
    public ReadingMaterial(String name, int pages, String type) {
        this.name = name;
        this.pages = pages;
        this.type = Type.valueOf(type);
    }
    
    public int getPages() {
        return this.pages;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String toString() {
        String readingmaterialString = this.pages + " " + this.name + " " + this.type;
        return readingmaterialString;
    }

    public int compareTo(ReadingMaterial other) {
        if (this.pages == other.pages) {
            return 0;
        } else if (this.pages > other.pages) {
            return 1;
        } else {
            return -1;
        }
    }
    
    public boolean isType(Type type) {
        if (this.type == type) {
            return true;   
        } else {
            return false;
        }
    }
    
}

Klasse ReadingList:

public class ReadingList {
    
    private ArrayList<ReadingMaterial> readingList;
    
    public ReadingList() {
        this.readingList = new ArrayList<ReadingMaterial>();
    }
    
    public void addMaterial(ReadingMaterial material) {
        readingList.add(material);
        Collections.sort(readingList);
    }
    
//    public ArrayList<Type> getAllBooks() {
//        ArrayList<Type> books = new ArrayList<Type>();
//        String search = "Buch";   
//        for (int i = 0; i < readingList.size(); i++) {
//            if (readingList.get(i).equals(search)) {
//                books.add(readingList.get(i));
//            }
//        }
//        return books;
//    }
    

}

 

[Flown]

Nebenbei: Man programmiert immer gegen Interfaces (man entkoppelt sich von der Implementierung: ArrayList -> List.

Du bist schon fast am Ziel. Deine ReadingMaterial besitzt doch schon eine Abfrage auf den richtigen Typ:

public List<ReadingMaterial> getAllBooks() {
  List<ReadingMaterial> books = new ArrayList<>();
  for (ReadingMaterial material : readingMaterials) {
    if (material.isType(Type.Buch)) {
      books.add(material);
    }
  }
  return books;
}

Außerdem
- laut Conventions sind Enums immer capitalized i.e. BUCH und MAGAZIN.
- anstatt jedes Mal die Liste beim einfügen zu sortieren, gleich das Element sortiert einfügen
- Comparable mit den richtigen Generics ausfüllen: Comparable<ReadingMaterial>
- Unnötige Variablen und Tautologien vermeiden (e.g. public boolean isType(Type type) { return this.type == type; } reicht völlig, auch das compareTo könnte man mit return Integer.compare(this.pages, other.pages); vereinfachen)
-

 

[Juicerz]

Nebenbei: Man programmiert immer gegen Interfaces (man entkoppelt sich von der Implementierung: ArrayList -> List.

Du bist schon fast am Ziel. Deine ReadingMaterial besitzt doch schon eine Abfrage auf den richtigen Typ:

public List<ReadingMaterial> getAllBooks() {
  List<ReadingMaterial> books = new ArrayList<>();
  for (ReadingMaterial material : readingMaterials) {
    if (material.isType(Type.Buch)) {
      books.add(material);
    }
  }
  return books;
}

Außerdem
- laut Conventions sind Enums immer capitalized i.e. BUCH und MAGAZIN.
- anstatt jedes Mal die Liste beim einfügen zu sortieren, gleich das Element sortiert einfügen
- Comparable mit den richtigen Generics ausfüllen: Comparable<ReadingMaterial>
- Unnötige Variablen und Tautologien vermeiden (e.g. public boolean isType(Type type) { return this.type == type; } reicht völlig, auch das compareTo könnte man mit return Integer.compare(this.pages, other.pages); vereinfachen)
-

- Man programmiert immer gegen Interfaces (man entkoppelt sich von der Implementierung: ArrayList -> List.
Das musst du mir genauer erklären... Sorry. 🙂

- laut Conventions sind Enums immer capitalized i.e. BUCH und MAGAZIN.
Danke für den Hinweis!

- Comparable mit den richtigen Generics ausfüllen: Comparable<ReadingMaterial>
Hab ich gerade vorhin gecheckt, deshalb haben die Schnittstellen immer Stress gemacht und wollten immer NOCH eine compareTo hinzufügen, haha.

- Unnötige Variablen und Tautologien vermeiden (e.g. public boolean isType(Type type) { return this.type == type; } reicht völlig, auch das compareTo könnte man mit return Integer.compare(this.pages, other.pages); vereinfachen)
Möglichst wenig QuellCode und wenig Verwirrung, wa.

    public ArrayList<ReadingMaterial> getAllBooks() {
        ArrayList<ReadingMaterial> books = new ArrayList<ReadingMaterial>();
        for (ReadingMaterial z : readingList) {
            if (z.isType(Type.BUCH)) {
                books.add(z);
            }
        }
        return books;
    }

 

[Flown]

- Man programmiert immer gegen Interfaces (man entkoppelt sich von der Implementierung: ArrayList -> List.
Das musst du mir genauer erklären... Sorry. 🙂

Es gibt mehrere Implementierungen von dem Interface List (siehe: All Known Implementing Classes).

Nehmen wir jetzt mal deine Methode würde so aussehen:

public List<ReadingMaterial> getAllBooks() {....}

Dann würden die Klassen/Clients die deine Klasse/Methode verwenden sozusagen mit dem Vertrag/Contract des Interfaces arbeiten (die Methoden sind garantiert implementiert).

Du verwendest in deiner Methode: List<ReadingMaterial> books = new ArrayList<>(); die ArrayList als Implementierungsdetail. Das kann aber deinen Clients/Nutzer der Methode aber sehr egal sein was die Ausprägung (Implementierung) des Interfaces List ist.

Weiters angenommen, kommt eine neue Implementierung einer List die 1000 mal schneller ist als eine ArrayList in die JDK, dann möchtest du die auch verwenden und austauschen.
Da du jetzt einfach in deinem Code List<ReadingMaterial> books = new AwesomeList<>(); änderst hat sich an der Methodensignatur nichts geändert und deine Clients (verwender deiner Methode) müssen nicht den Code ändern, weil sich nur das Detail geändert hat.
Gibst du aber eine ArrayList in deiner Methodensignatur an, dann müsstest du es gegen AwesomeList austauschen und alle deine Clients müssten auch deren Code ändern (-> das ist der Hauptgrund - eine kleine Änderung sollte keine Flut an changes triggern).

 

[Juicerz]

Es gibt mehrere Implementierungen von dem Interface List (siehe: All Known Implementing Classes).

Nehmen wir jetzt mal deine Methode würde so aussehen:

public List<ReadingMaterial> getAllBooks() {....}

Dann würden die Klassen/Clients die deine Klasse/Methode verwenden sozusagen mit dem Vertrag/Contract des Interfaces arbeiten (die Methoden sind garantiert implementiert).

Du verwendest in deiner Methode: List<ReadingMaterial> books = new ArrayList<>(); die ArrayList als Implementierungsdetail. Das kann aber deinen Clients/Nutzer der Methode aber sehr egal sein was die Ausprägung (Implementierung) des Interfaces List ist.

Weiters angenommen, kommt eine neue Implementierung einer List die 1000 mal schneller ist als eine ArrayList in die JDK, dann möchtest du die auch verwenden und austauschen.
Da du jetzt einfach in deinem Code List<ReadingMaterial> books = new AwesomeList<>(); änderst hat sich an der Methodensignatur nichts geändert und deine Clients (verwender deiner Methode) müssen nicht den Code ändern, weil sich nur das Detail geändert hat.
Gibst du aber eine ArrayList in deiner Methodensignatur an, dann müsstest du es gegen AwesomeList austauschen und alle deine Clients müssten auch deren Code ändern (-> das ist der Hauptgrund - eine kleine Änderung sollte keine Flut an changes triggern).

Sehr interessant, wurde mir so nie gelehrt. Auch das mit den Enum hab ich gerade nachgeschaut, in den Büchern klein geschrieben. Da muss man sich schon ein wenig wundern... Danke!

 

[Juicerz]

Könnte man eigentlich ein Enum-Type auch direkt als Instanzvariable bestimmen? Quasi den kompletten Konstruktor, etc. umgehen?

 

[Juicerz]

War eine sehr dumme Frage...

private Type type = Type.Buch;