Gibt es eine Möglichkeit, geschachtelte n-Level-Schleifen in Java zu machen?

Es klingt wie Sie vielleicht möchten, schauen Sie in die Rekursion.

InformationsquelleAutor der Antwort

Möchten Sie vielleicht, um zu erklären, was Sie wirklich wollen, zu tun.

Werden, wenn die äußeren for Schleifen tut nichts, aber die Steuerung ein Graf, dann der verschachtelte for loops sind einfach nur ein komplizierter Weg von der Iteration durch eine Zahl, die gehandhabt werden kann, indem eine einzige for Schleife.

Beispiel:

for (x = 0; x < 10; ++x) {
  for (y = 0; y < 5; ++y) {
    for (z = 0; z < 20; ++z) {
      DoSomething();
    }
  }
}

Ist äquivalent zu:

for (x = 0; x < 10*5*20; ++x) {
  DoSomething();
}

InformationsquelleAutor der Antwort Michael Burr

2015 Bearbeiten: Entlang der gleichen eitel wie die vorherigen Beschwörung, ich habe das folgende Paket, um diese zu bewältigen; https://github.com/BeUndead/NFor

Die Verwendung wäre wie folgt

public static void main(String... args) {
    NFor<Integer> nfor = NFor.of(Integer.class)
            .from(0, 0, 0)
            .by(1, 1, 1)
            .to(2, 2, 3);

    for (Integer[] indices : nfor) {
        System.out.println(java.util.Arrays.toString(indices));
    }
}

was in

[0, 0, 0]
[0, 0, 1]
[0, 0, 2]
[0, 1, 0]
[0, 1, 1]
[0, 1, 2]
[1, 0, 0]
[1, 0, 1]
[1, 0, 2]
[1, 1, 0]
[1, 1, 1]
[1, 1, 2]

Es unterstützt auch andere Bedingungen als lessThan. Die Verwendung es (mit import static NFor.*;):

NFor<Integer> nfor = NFor.of(Integer.class)
        .from(-1, 3, 2)
        .by(1, -2, -1)
        .to(lessThanOrEqualTo(1), greaterThanOrEqualTo(-1), notEqualTo(0));

Ergibt:

[-1, 3, 2]
[-1, 3, 1]
[-1, 1, 2]
[-1, 1, 1]
[-1, -1, 2]
[-1, -1, 1]
[0, 3, 2]
[0, 3, 1]
[0, 1, 2]
[0, 1, 1]
[0, -1, 2]
[0, -1, 1]
[1, 3, 2]
[1, 3, 1]
[1, 1, 2]
[1, 1, 1]
[1, -1, 2]
[1, -1, 1]

Offensichtlich, loops in verschiedenen Längen und unterschiedlichen Klassen (alle boxed, numerische primitives) werden unterstützt. Der Standard (wenn nicht angegeben) ist von(0, ...).von(1, ...); aber zu(...) müssen angegeben werden.

Den NForTest Datei sollte zeigen verschiedene Möglichkeiten, es zu benutzen.

Die grundlegende Prämisse dieser wird einfach Voraus, die 'Indizes', die jeweils wiederum eher als Rekursion.

InformationsquelleAutor der Antwort user2478398

Die grundlegende Idee hinter verschachteln von Schleifen ist Multiplikation.

Erweiterung auf Michael Burr ' s Antwort, wenn die äußeren for Schleifen tut nichts, aber die Steuerung ein Graf, dann der verschachtelte for Schleifen über n zählt, sind einfach nur ein komplizierter Weg von der Iteration über das Produkt der Grafen mit einem einzigen for Schleife.

Nun, wir erweitern diese Idee zu Listen. Wenn Sie Durchlaufen drei Listen, die in geschachtelten Schleifen, das ist einfach ein komplizierter Weg von der Iteration über die Produkt-Listen mit einer einzigen Schleife. Aber wie drückt man das Produkt der drei Listen?

Als erstes benötigen wir einen Ausdruck für das Produkt der Typen. Das Produkt von zwei Arten X und Y ausgedrückt werden kann als ein generischer Typ wie P2<X, Y>. Dies ist nur ein Wert, der besteht aus zwei Werten, einer Art Xdie andere vom Typ Y. Es sieht wie folgt aus:

public abstract class P2<A, B> {
  public abstract A _p1();
  public abstract B _p2();
}

Für ein Produkt von drei Typen, wir haben nur P3<A, B, C>mit der offensichtlichen Dritte Methode. Ein Produkt der drei Listen, dann wird erreicht durch die Verteilung der Liste funktors über das Produkt geben. Also das Produkt von List<X>List<Y>und List<Z> ist einfach List<P3<X, Y, Z>>. Sie können dann die Iteration über diese Liste mit einer einzelnen Schleife.

Den Funktionale Java Bibliothek hat eine List Typ, der das multiplizieren Listen zusammen mit first-class-Funktionen und Produkt-Typen (P2, P3, etc. die ebenfalls in der Bibliothek enthalten).

Beispiel:

for (String x : xs) {
   for (String y : ys) {
     for (String z : zs) {
       doSomething(x, y, z);
     }
   }
}

Ist äquivalent zu:

for (P3<String, String, String> p : xs.map(P.p3()).apply(ys).apply(zs)) {
   doSomething(p._1(), p._2(), p._3());
}

Weiter mit Funktionalen Java, können Sie doSomething erste-Klasse wie folgt. Lassen Sie uns sagen doSomething gibt einen String zurück:

public static final F<P3<String, String, String>, String> doSomething =
  new F<P3<String, String, String>, String>() {
    public String f(final P3<String, String, String> p) {
      return doSomething(p._1(), p._2(), p._3());
    }
  };

Dann können Sie beseitigen die for-Schleife zusammen, und sammeln Sie die Ergebnisse aller Anwendungen von doSomething:

List<String> s = xs.map(P.p3()).apply(ys).apply(zs).map(doSomething);

InformationsquelleAutor der Antwort Apocalisp

Den Preis für das schönste Allgemeinen Ansatz, ich könnte kommen mit in Java 7 ist

//i[0] = 0..1  i[1]=0..3, i[2]=0..4
MultiForLoop.loop( new int[]{2,4,5}, new MultiForLoop.Callback() { 
    void act(int[] i) { 
        System.err.printf("%d %d %d\n", i[0], i[1], i[2] );
    }
}

Oder in Java 8:

//i[0] = 0..1  i[1]=0..3, i[2]=0..4
MultiForLoop.loop( new int[]{2,4,5}, 
   i -> { System.err.printf("%d %d %d\n", i[0], i[1], i[2]; } 
);

Eine Implementierung, die dies unterstützt ist:

/**
 * Uses recursion to perform for-like loop.
 *  
 * Usage is 
 *  
 *    MultiForLoop.loop( new int[]{2,4,5}, new MultiForLoop.Callback() { 
 *        void act(int[] indices) { 
 *            System.err.printf("%d %d %d\n", indices[0], indices[1], indices[2] );
 *        }
 *    }
 *  
 * It only does 0 - (n-1) in each direction, no step or start 
 * options, though they could be added relatively trivially.
 */
public class MultiForLoop {

    public static interface Callback {
        void act(int[] indices);
    }

    static void loop(int[] ns, Callback cb) {
        int[] cur = new int[ns.length];
        loop(ns, cb, 0, cur);
    }

    private static void loop(int[] ns, Callback cb, int depth, int[] cur) {
        if(depth==ns.length) {
            cb.act(cur);
            return;
        }

        for(int j = 0; j<ns[depth] ; ++j ) {
            cur[depth]=j;
            loop(ns,cb, depth+1, cur);
        }
    }
}

InformationsquelleAutor der Antwort Michael Anderson

public void recursiveFor(Deque<Integer> indices, int[] ranges, int n) {

    if (n != 0) {

       for (int i = 0; i < ranges[n-1]; i++) {

          indices.push(i);
          recursiveFor(indices, ranges, n-1);
          indices.pop();
       }
    }

    else {

       //inner most loop body, access to the index values thru indices
       System.out.println(indices);
    }
}

Beispiel nennen:

int[] ranges = {2, 2, 2};

recursiveFor(new ArrayDeque<Integer>(), ranges, ranges.length);

InformationsquelleAutor der Antwort gewizz

Im Interesse der Prägnanz ich Stelle meinen code hier :

void variDepth(int depth, int n, int i) {
    cout<<"\n d = "<<depth<<" i = "<<i;
    if(!--depth) return;
    for(int i = 0;i<n;++i){
        variDepth(depth,n,i);
    }
}
void testVariDeapth()
{   variDeapth(3, 2,0);
}

Ausgabe

 d = 3 i = 0
 d = 2 i = 0
 d = 1 i = 0
 d = 1 i = 1
 d = 2 i = 1
 d = 1 i = 0
 d = 1 i = 1

InformationsquelleAutor der Antwort Ajeet Ganga