"Automatisierte", variable verschachtele for-Schleife

[DerSophist]

Ich suche eine Methode, mit der es möglich ist verschachtele for-Schleifen sozusagen Variabel zu machen.
Denn wenn man eine verschachtelte Schleife mit einer Verschachtlung sieht das ja so aus:

for (int i = 0; i<10; i++) {
    for (int j  = 0; j<10; j++) {
         //Beliebiger Code...
    }

Wenn ich jetzt noch eine Verschachtelung haben möchte, müsste ich jetzt eine weitere Schleife in der Schleife hinzufügen usw.
Ist es jetzt aber irgendwie möglich, dass man einfach nur sagt, ich hätte gerne x Verschachtelungen, und dann halt den Code, und dann hat man x verschachtelte for-Schleifen? Also ganz automatisiert und ohne, dass man das alles jedes mal tippen muss, wenn man z.B. 100 verschachtelte Schleifen will?

 

[httpdigest]

Ich frage erst gar nicht, warum du 100 verschachtelte Schleifen haben möchtest, aber: Rekursion ist hier die Lösung.
Schreibe eine Methode mit einer einzigen for-Schleife und rufe dieselbe Methode innerhalb der for-Schleife wieder auf.
Zusätzlich brauchst du natürlich eine dynamische Liste, in der du die Indizes der Schleifen hochzählst und eine Abbruchbedingung.

 

[DerSophist]

Ich frage erst gar nicht, warum du 100 verschachtelte Schleifen haben möchtest, aber: Rekursion ist hier die Lösung.
Schreibe eine Methode mit einer einzigen for-Schleife und rufe dieselbe Methode innerhalb der for-Schleife wieder auf.
Zusätzlich brauchst du natürlich eine dynamische Liste, in der du die Indizes der Schleifen hochzählst und eine Abbruchbedingung.

Das mit den 100 war nur ein Beispiel.
Meinst du so etwas hier:

public void schleife() {
     for (int i=0; i<10; i++) {
     //code
     }
}

 

[httpdigest]

Ja gut, das ist zumindest schon mal eine Methode, die eine for-Schleife enthält. Aber sowas bräuchtest du doch sowieso... was ist daran jetzt speziell? Da fehlt jetzt halt noch einiges, wie zum Beispiel der rekursive Aufruf und Datenstrukturen (z.B. eine java.util.List) die du den rekursiven Aufrufen als Parameter mitgibst, um die Schleifenindizes zu speichern, sowie eine Abbruchbedingung für die rekursiven Aufrufe (welche der Anzahl deiner "Schleifen" entspricht).

 

[DerSophist]

Könnte man das so machen:

public class VerschachtelteSchleifen {

       private int anzahlAnSchleifen = 5;

       public void schleife(int schleifenindizes) {
              for (int i=0; i<schleifenindizes; i++) {
                      if (anzahlAnSchleifen > 0) {
                             anzahlAnSchleifen--;
                             schleife(schleifenindizes);
                      }
              }
       }

}

Sowas dann um 5 verschachtelte Schleifen zu haben, die dann alle den gleichen Schleifenindize haben?

 

[Xyz1]

Könnte man das so machen

Nein, so:

public static <T> void doSth(T first, List<T> l, Consumer<T> c, Function<T, T> s, Predicate<T> p) {
	for (T t : l) {
		if (p.test(first)) {
			return;
		}
		c.accept(t);
		doSth(s.apply(first), l, c, s, p);
	}
}

public static void main(String[] args) {
	doSth(1, List.of(1, 2, 3), (e) -> System.out.println(e), (e) -> e + 1, (e) -> e >= 3);
}

Wahlweise zieht man auch das test vor die Schleife.

 

[thecain]

Soll man das jetzt verstehen. Mach doch verständliche Variablennamen. Dann wirds sicher besser

 

[Xyz1]

T first, List<T> l, Consumer<T> c, Function<T, T> s, Predicate<T> p)
=
first, elements, consumer, supplier, predicate

Besser verständlich? Über die Reihenfolge lässt sich streiten genau so wie über einen zusätzl. accumulator. Über die Zweckmäßigkeit auch... ich versuche gerade alle Kombinationen von 3 Buchstaben auszugeben - und klappt nicht.

 

[Xyz1]

Vielleicht so

public static <A, B> void doSth(A to_test, Predicate<A> predicate, Function<A, A> supplier, List<B> list, Consumer<AbstractMap.SimpleEntry<A, B>> consumer, Consumer<A> end_consumer) {
	if (predicate.test(to_test)) {
		end_consumer.accept(to_test);
		return;
	}
	for (B b : list) {
		consumer.accept(new SimpleEntry<>(to_test, b));
		doSth(supplier.apply(to_test), predicate, supplier, list, consumer, end_consumer);
	}
}

public static void main(String[] args) {
	ArrayList<Character> list = new ArrayList<>();
	doSth(0, (a) -> a > 2, (a) -> a + 1, List.of('a', 'b', 'c'), (c) -> list.add(c.getValue()), (a) -> {
		System.out.println(list);
		list.clear();
	});
}

@httpdigest wird da mehr wissen.

 

[Xyz1]

Dann wirds sicher besser

Doch noch hin ge kriegt. Das ist der verallgemeinerte Backtracking-Algorithmus:

public static <A, B> void doSth(A to_test, Predicate<A> predicate, Function<A, A> supplier, List<B> list,
		Predicate<AbstractMap.SimpleEntry<B, List<B>>> predicate2, List<B> list2, Consumer<List<B>> end_consumer) {
	if (predicate.test(to_test)) {
		end_consumer.accept(list2);
		return;
	}
	for (B b : list) {
		if (predicate2.test(new SimpleEntry<>(b, list2))) {
			list2.add(b);
			doSth(supplier.apply(to_test), predicate, supplier, list, predicate2, list2, end_consumer);
			list2.remove(list2.size() - 1);
		}
	}
}

public static void main(String[] args) {
	doSth(0, (a) -> a > 2, (a) -> a + 1, List.of('a', 'b', 'c'), (c) -> c.getValue().size() < 3, new ArrayList<>(), (b) -> System.out.println(b));
}