Arraylist als Pfadausgabe

[Fohnbit]

Hallo,

ich habe die Klasse: Category:

public class Category {
private Integer id;
    private Integer parent_id;
    private String name;
    private Boolean is_active;
    private Integer position;
    private Integer level;
    private String children;
    private String created_at;
    private String updated_at;
    private String path;
    private List<String> available_sort_by;
    private Boolean include_in_menu;
    private ExtensionAttributes extension_attributes;
    private List<CustomAttribute> custom_attributes;
   private List<Category> children_data;

Diese widerum hat eine List der children_data als Category.

Sie ist also Rekursiv.

Nun benötige ich die ID von:
Default/Cat1/Cat5/demo

Die genannten sind die namen der Kategorien.

Habs nun nicht getestet, aber Rekursiv müsste ich die Category "demo" so finden:

public int getCategoryByName(Category category, String name) {
        if (category.getName().equals(name)) {
            return category.getId();
        }

        for (Category childs : category.getChildren_data()) {
            return getCategoryByName(childs, name);
        }
        return 0;
    }

Aber es könnte sein das eine andere Kategorie in einem anderen Pfad auch "demo" heißt.

Wie könnte ich die Rekursive Liste mit einer Suche nach "Default/Cat1/Cat5/demo" genau finden?

Danke!

 

[mrBrown]

Das "Default/Cat1/Cat5/demo" kannst du am '/' splitten, dann bekommst du eine Liste von Namen.

Dann, nicht rekursiv sondern nur auf einer Ebene, nach "Default" suchen.
Wenn du das gefunden hast, in deren direkten Kindern nach "Cat1" suchen.
Und dass dann solange mit dem jeweils nächsten Pfadelement, bis du am Ende angekommen bist.

Müsste als rekursive Funktion recht leicht umzusetzen sein

 

[Fohnbit]

Hallo,

ja, mit dem Splitten hab ich es mal versucht .. nun, es scheint alle korrekt zurück zu geben, aber geht das auch einfacher? 🙂

Die erste Category "Root Catalog" muss ich überspringen:
Suche nach "Default Category/Werkzeug und Maschinen/Werkzeug" gibt das passende Ergebniss zurück.

public Category getCategoryByName(Category category, String[] name, int level) {
        if (!category.getName().equals("Root Catalog")) {
            if (category.getName().equals(name[level])) {
                if (name.length == level + 1) {
                    // gefunden!
                    return category;
                }
                for (Category childs : category.getChildren_data()) {
                    level++;
                    Category cat = getCategoryByName(childs, name, level);
                    if (cat != null) {
                        return cat;
                    } else {
                        level--;
                    }
                }
            }
            return null;

        } else {
            for (Category childs : category.getChildren_data()) {
                Category cat = getCategoryByName(childs, name, level);
                if (cat != null) {
                    return cat;
                } else {
                    return null;
                }
            }
        }
        return category;
    }

 

[mrBrown]

Ist "Root Catalog" die Wurzel des Baumes oder kann das irgendwo an beliebiger Stelle stehen?

 

[mihe7]

Mal so als Idee:

public Category getCategoryByPath(String[] path) {
    Category current = this;
    // mit i = 1 wird erstes Element ausgelassen
    for (int i = 1; current != null && i < path.length; i++) {
        current = getChildByName(path[i]);
    }
    return current;
}

public Category getChildByName(String name) {
    for (Category child : children_data) {
        if (child.name.equals(name)) {
            return child;
        }
    }
    return null;
}

 

[Fohnbit]

Danke!

@mrBrown Genau, ist die Wurzel und nur die Childs werden durchsucht

@mihe7 hmmm ... ist dein Code auf 2 Ebenen beschränkt? Müsste nicht bei "getChildByName" wiederum die Suche starten?

 

[mihe7]

ist dein Code auf 2 Ebenen beschränkt? Müsste nicht bei "getChildByName" wiederum die Suche starten?

Nein. Bei getChildByName geht es nur darum, die direkte(!) Subkategorie der aktuellen Kategorie anhand des Namens zu finden. getCategoryByPath funktioniert dann einfach folgendermaßen:
1. es wird mit der Kategorie, auf der getCategoryByPath aufgerufen wurde gestartet. Die aktuelle Kategorie ist damit this.
2. Für jedes Pfadelement wird der Reihe nach:
- von der jeweils aktuellen Kategorie die direkte Subkategorie anhand des Pfadelements gesucht
- die so gefundene (oder auch nicht gefundene) Subkategorie wird zur neuen aktuelle Kategorie gemacht

Das ganze geht so lange, bis eine Subkategorie nicht gefunden wurde oder alle Pfadelemente durch sind.

 

[Fohnbit]

@mihe7 vielen Dank.
Ich musst eine Kleinigkeit abändern:

    public Category getCategoryByPath(String[] path) {
        Category current = this;
        // mit i = 1 wird erstes Element ausgelassen
        for (int i = 0; current != null && i < path.length; i++) {
            current = getChildByName(current, path[i]);
        }
        return current;
    }

    public Category getChildByName(Category current, String name) {
        for (Category child : current.getChildren_data()) {
            if (child.name.equals(name)) {
                return child;
            }
        }
        return null;
    }

Da du nur auf die Childs prüfst, wird der "Root name" sowieso übersprungen. Denk du dachtest vom "path" sollte der erst übersprungen werden.

"children_data" würde sich sonst ja auf die interne lokale Variable "children_data" beziehen und nicht auf die der "current".
So wie oben klappt das nun.

 

[mihe7]

Oops, ja beim Aufruf das current vergessen: current = current.getChildByName(path[i]); so gehts objekt-orientiert auch ohne Parameter.

 

[Xyz1]

Sie ist also Rekursiv

Rekursion ist, insofern wir nicht von Methoden sprechen, nicht der richtige Begriff. Sag einfach gerichteter azyklischer Graph dann weiß jeder Bescheid 🙄 leider werden von vielen Anfängern falsche Begriffe verwendet und andere übernehmen dann einfach - ohne kritisch zu hinterfragen....

Zweitens. Rein rekursiv ist das nicht möglich, da eine Category, nimmt man es genau, bei einer Rekursion nur sich selber kennt aber alle in der gleichen Ebene kennen müsste. Also ist diese Aufgabenstellung wirklich Nonsense...

 

[mrBrown]

Doch, Rekursion (oder genauer rekursive Datenstruktur) ist der passende Begriff.