Methoden Die Reihenfolge der Iterator-Elemente umkehren

[JimmyKudo]

Hallo Leute, danke nochmals für die Hilfe letztes mal. Ich habe bereits eine while und for schleife in der next()-methode verwendet, jedes mal kommt dabei eine endlos-schleife zustande. (Die Implementierung soll ohne zu hilfe von String-Methoden auskommen können,, (z.B. prinln, Stringbuilder, usw.)

/*- [gewuenschte Consolen-#ausgabe]
i : 24, j : 24
i : 23, j : 24
i : 22, j : 24
i : 21, j : 24
i : 20, j : 24
i : 19, j : 24
...
i : 2, j : 24
i : 1, j : 24
i : 0, j : 24
i : 1, j : 24
i : 2, j : 24
i : 3, j : 24
...
i : 22, j : 24
i : 23, j : 24
i : 24, j : 24
*/


/*-
[tatsächlicher Consolen output]
i : 24, j : 24
i : 23, j : 24
i : 22, j : 24
i : 21, j : 24
i : 20, j : 24
i : 19, j : 24
...
i : 2, j : 24
i : 1, j : 24
i : 0, j : 24
-1
*/


   int i;
    int j;
    int size = 25;

    public Data() {
        i = size - 1;
        j = size - 1;

    }

    public int geti() {
        return i;
    }

    public int getj() {
        return j;
    }

    public boolean next() {
        int inc = -1;

        while (true) {

            i += inc;
            if (i < 0 || size <= i) {
                i -= inc;
                /*- 0, 24, 0, 24, 0, 24, 0, 24, 0, 24, 0, 24, */
                inc = -inc;
                /*- 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, */

                break;
            }
            return true;
        }

        return false;
    }

    public static void main(String[] args) {

        Data data = new Data();
        do {

            int i = data.geti();
            int j = data.getj();
            System.out.print("i : " + i + ", j : " + j + "\n");

        } while (data.next());

    }

 

[JimmyKudo]

P.S. Die main-methode muss unverändert bleiben.

 

[KonradN]

Du darfst natürlich in der next Methode keine Schleife haben. Das soll ja nur die nächsten Schritte festlegen.

Du hast in der Methode aber schon erkannt, dass du ggf. eine weitere Variable brauchst. Das kann aber dann natürlich keine lokale Variable sein sondern muss eine Instanzvariable sein. Diese Variable kann die nächste Differenz angeben.

Daher sind die Fragen jetzt erst einmal:
a) Wie initialisierst Du die Variablen?
b) Wie ändern sich die Variablen bei jedem next und was gibt next zurück?

Das kannst Du dir ja mal in Ruhe überlegen.

 

[Neumi5694]

Ich hab vor Ewigkeiten mal das hier gefunden, funktioniert für Listen (Arrays.asList() - und schon ist dein Array eine Liste) und mit einer kleinen Anpassung auch direkt für ListIteratoren.

public class ReversedIterable<T> implements Iterable<T> {



        public ReversedIterable(List<T> original) {
            this.original = original;
        }


        @Override
        public Iterator<T> iterator() {
            final ListIterator<T> iter = original.listIterator(original.size());

            return new Iterator<T>() {
                @Override
                public boolean hasNext() {
                    return iter.hasPrevious();
                }

                @Override
                public T next() {
                    return iter.previous();
                }

                @Override
                public void remove() {
                    iter.remove();
                }
            };
        }

        private final List<T> original;
    }

Kann man vielleicht noch etwas vereinfachen, aber ich finde, das ist eine sehr gute Lösung.