Auslagerung von verschachtelten Schleifen

[budi]

Servus,

ich hätte eine Frage an euch und zwar, ob man irgendwie in Java verschatelte Schleifen auslagern kann?
Ich bräuchte die Code-Fragmente noch an ein paar anderen Stellen im Code. Hier der Code:

final List<ShelfConfig> shelfList = ModelProvider.getInstance().getIntronDPlusConfiguration().getShelfConfig();
        for (final ShelfConfig shelf : shelfList)
        {
            final List<CTStation> stationList = shelf.getStationTable().getDigitalStationOrAnalogStationOrDioStation();
            for (final CTStation station : stationList)
            {
                final List<KeyPad> keypadList = station.getKeyPadTable().getKeyPad();
                for (final KeyPad keyPad : keypadList)
                {
                    final List<CTButton> buttonList = keyPad.getButton();
                    for (final CTButton button : buttonList)
                    {
                        if (!button.getCallAttr().isEmpty())
                        {
                            final List<CTCallAttr> callList = button.getCallAttr();
                            for (final CTCallAttr callAttr : callList)
                            {
                                if (isKeyUsingInDestKey(grKey, callAttr))
                                {
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
        }

Ich wandere in diesen Schleifen in meiner Datenstruktur bzw. einem XML-Tree und lese meine Daten aus. Ich würde jetzt sehr gerne die 5 verschatelten Schleifen auslagern und die letzte if-Anweisung an einer anderen Stellen anders implementieren.

Ist das in Java möglich?

 

[maki]

Mit Methoden zB.??

 

[budi]

Für jede Ebene eine Methode?

 

[Foermchen82]

wenn sie unterschiedliche dinge tun müssen, ja

 

[budi]

ähm, ja im Moment will ich nur diese Verschatelungstiefe auslagern,
um auf der untersten Ebene verschiedene Dinge mit meinen Daten zu tun.

 

[maki]

wenn sie unterschiedliche dinge tun müssen, ja

Wieso, Methoden müssen nicht wiederverwendet werden oder unterschiedliche Dinge tun um ausgelagert ("extrahiert" )zu werden, entspricht modernen Best-Practices in jeder Methode höchstens eine "Einrückung" (zB. Schleife) zuzulassen, und die besten Methoden sind 1-3 Zeilen lang und haben einen aussagekräftigen Namen.

 

[budi]

Methoden müssen nicht wiederverwendet werden oder unterschiedliche Dinge tun um ausgelagert ("extrahiert" )zu werden, entspricht modernen Best-Practices

Da stimme ich Dir voll und ganz zu.

 

[maki]

Extract Method

Empfehle das "Refactoring - Changing the design of existing software" Buch von Martin Fowler und natürlich "Clean Code" von Robert Martin.

 

[budi]

Ja ich kenne beide. Das von "Clean Code" habe ich schon gelesen und an dem anderen bin ich im Moment dran. Mit Eclipse lässt sich sowas ja total einfach "extrahieren".

Hier die Zerlegung in Methoden:

public final void deleteSrcKeyInAllButtons(final String key)
    {
        getAllShelfs(key);
    }

    private void getAllShelfs(final String key)
    {
        final List<ShelfConfig> shelfList = ModelProvider.getInstance().getIntronDPlusConfiguration().getShelfConfig();
        for (final ShelfConfig shelf : shelfList)
        {
            getAllStations(key, shelf);
        }
    }

    private void getAllStations(final String key, final ShelfConfig shelf)
    {
        final List<CTStation> stationList = shelf.getStationTable().getDigitalStationOrAnalogStationOrDioStation();
        for (final CTStation station : stationList)
        {
            getAllKeyPads(key, station);
        }
    }

    private void getAllKeyPads(final String key, final CTStation station)
    {
        final List<KeyPad> keypadList = station.getKeyPadTable().getKeyPad();
        for (final KeyPad keyPad : keypadList)
        {
            getAllButtons(key, keyPad);
        }
    }

    private void getAllButtons(final String key, final KeyPad keyPad)
    {
        final List<CTButton> buttonList = keyPad.getButton();
        for (int i = buttonList.size() - 1; i >= 0; i--)
        {
            final CTButton button = buttonList.get(i);
            if (!button.getCallAttr().isEmpty())
            {
                getAllButtonCalls(key, buttonList, button);
            }
        }
    }

    private void getAllButtonCalls(final String key, final List<CTButton> buttonList, final CTButton button)
    {
        final List<CTCallAttr> callList = button.getCallAttr();
        for (int j = callList.size() - 1; j >= 0; j--)
        {
            final CTCallAttr callAttr = callList.get(j);
            if (isKeyUsingInDestKey(key, callAttr))
            {
                callList.remove(callAttr);
                removeButtonWithoutCalls(buttonList, button);
            }
        }
    }

    private void removeButtonWithoutCalls(final List<CTButton> buttonList, final CTButton button)
    {
        if (button.getCallAttr().isEmpty())
        {
            buttonList.remove(button);
        }
    }

    private boolean isKeyUsingInDestKey(final String key, final CTCallAttr callAttr)
    {
        return callAttr.getDestKey() != null && callAttr.getDestKey().equals(grKey);
    }

Habe ich jetzt nur mal so auf die schnelle durchgeführt, die Name der Methoden sind noch
nicht optimal !

Nur ist mir folgendes noch nicht ganz klar: Wie verwende ich diese Stukturen am geschicktesten?
Mal angenommen, ich bräuchte an einer anderen Stelle wieder die unterste Ebene, sprich ich müsste
theoretisch nur die Methode "isKeyUsingInDestKey" ändern. Dann würde sich meiner Meinung nach hier empfehlen, von dieser Klasse zu erben und die unterste Methode zu überschreiben oder?

 

[maki]

Ja ich kenne beide.

Nur ist mir folgendes noch nicht ganz klar: Wie verwende ich diese Stukturen am geschicktesten?
Mal angenommen, ich bräuchte an einer anderen Stelle wieder die unterste Ebene, sprich ich müsste
theoretisch nur die Methode "isKeyUsingInDestKey" ändern. Dann würde sich meiner Meinung nach hier empfehlen, von dieser Klasse zu erben und die unterste Methode zu überschreiben oder?

Hört sich nach dem Template Pattern an, vorraussgesetzt du willst nicht nur erben um die Methode wiederzuverwenden

 

[budi]

Hört sich nach dem Template Pattern an

Aus dem Bauch heraus, würde ich sagen "Ja".
Ich definiere in der abstrakten Klasse das Skellet bzw. den Algorithmus und lasse die Kinder die variable Methode implementieren. Einsprüche ??

 

[maki]

Keine Einsprüche

u.U. bietet sich auch das Strategy Pattern an, um das Template (und dessen verhalten) & Erzeugung zu kapseln.