Imbriqués pour-chacun sur la même liste en Java?

J'ai une liste de listes d'Entiers que je suis à l'aide de chaînes de build basé sur un fichier d'entrée. L'entrée spécifie paires (par exemple, "3 en 1" indique que 1 remplace 3 dans l'application), et il y a des chevauchements dans les paires (par exemple, "3 en 1" et "1 à 4" signifie que 1 remplace les 3 et 4 remplace 1, donc en fin de compte, 4 remplace 3).

Afin de réduire toutes les paires dans leurs dernières chaînes, j'ai une liste contenant des listes de toutes les paires, puis-je trouver les entrées dans la liste de chevauchement et de les ajouter à la les chaînes que nécessaire, le retrait de la paire qui a été jointe à une autre. C'est ainsi que je suis tenter de faire cela, mais je sais que l'échec est en doublant l'itérateur références:

    for (ArrayList<Integer> outerChain : chains) {
        for (ArrayList<Integer> innerChain : chains) {
            if (outerChain.get(0).equals(innerChain.get(innerChain.size() - 1))) {
                outerChain.remove(0);
                innerChain.addAll(outerChain);
                chains.remove(outerChain);
                break;
            }
        }
    }

Comme un exemple de l'entrée/de la sortie souhaitée de cette opération:

    {<1,3>,<2,7>,<7,9>,<8,12>,<9,1>,<6,8>}

individuels des listes correspondant à des paires d'entrée, la sortie serait:

    {<2,7,9,1,3>,<6,8,12>}

Est-il une manière que je peux nid itérateurs comme ça, telles que les références à l'intérieur de chaque itérateur sont mis à jour lors de la suppression ou de mise à jour pour l'un ou l'autre?

Merci d'avance pour l'aide!

Je sais que c'est pas ce que vous avez demandé, mais pourquoi ne pas le faire avec linéaire de la complexité? Vous pourriez juste faire un tableau de "qui est mon remplacement direct", de trouver les éléments de démarrage des chaînes (ne pas remplacer quoi que ce soit) et de suivre leurs chaînes à l'aide des valeurs du tableau.
Être prudent en comparant Integers avec ==, en dehors d'une gamme étroite (je pense que jusqu'à 128 ou 256?) il n'aura plus de retour que vous en attendez (tout comme les comparaisons de chaînes).
il y aura plusieurs paires de balise sur la fin d'une seule chaîne à la fois, donc si je le conserver hors de séparer et de ne pas mettre à jour la liste, alors je peut trouver (à partir de l'exemple ci-dessus) que je reçois des <2,7,9> et <9,1,3>, mais j'aurais alors besoin de revenir sur ce que je sors de trouver que <2,7,9,1,3>.
J'ai juste mis que là-haut pour mettre un exemple de code, mais merci pour le heads up. Je vais le mettre à jour, donc il n'est pas fait d'un problème.

InformationsquelleAutor Belizzle | 2013-04-29

3

Donc quand devez-vous utiliser la boucle for-each? Tout moment vous pouvez. - Il vraiment
embellit votre code. Malheureusement, vous ne pouvez pas l'utiliser partout.
Considérons, par exemple, la expurgate méthode. Le programme a besoin d'un accès
pour l'itérateur afin de supprimer l'élément en cours. Pour chaque
la boucle se cache l'itérateur, de sorte que vous ne peut pas appeler les supprimer. Par conséquent, l'
pour chaque boucle n'est pas utilisable pour le filtrage. De même, il n'est pas utilisable
pour les boucles où vous avez besoin de remplacer des éléments dans une liste ou d'une matrice, comme vous
le traversent. Enfin, il n'est pas utilisable pour des boucles qui doit itérer
au cours de plusieurs collections en parallèle. Ces lacunes ont été connus
par les concepteurs, qui a pris la décision consciente d'aller avec un chiffon propre,
construction simple qui permettrait de couvrir la grande majorité des cas.

(la Boucle For-each)

Vous ne devriez pas utiliser la boucle for-each lorsque vous supprimez des éléments de la liste ou de tableau tandis que le traverser. Par conséquent, vous devez utiliser explicitement l'itérateur de syntaxe dans votre cas.

Quelque chose comme ceci :
```
Iterator<ArrayList<Integer>> outer = chains.iterator ();
while (outer.hasNext ()) {
    ArrayList<Integer> outerChain = outer.next();
    Iterator<ArrayList<Integer>> inner = chains.iterator ();
    while (inner.hasNext ()) {
        ArrayList<Integer> innerChain = inner.next();
        if (outerChain.get(0).equals(innerChain.get(innerChain.size() - 1))) {
            outerChain.remove(0);
            innerChain.addAll(outerChain);
            outer.remove();
            break;
        }
    }
}
```
InformationsquelleAutor Eran
1

Une fois que vous modifiez une liste dans un itérateur vous ne pouvez pas utiliser un itérateur. Heureusement, vous avez besoin pour commencer à nouveau de toute façon si vous avez une solution naturelle
```
OUTER: while(chains.size() > 1) {
    for (ArrayList<Integer> outerChain : chains) {
            for (ArrayList<Integer> innerChain : chains) {
                if (outerChain.get(0) == innerChain.get(innerChain.size() - 1)) {
                    outerChain.remove(0);
                    innerChain.addAll(outerChain);
                    chains.remove(outerChain);
                    continue OUTER;
                }
            }
        }
    break; //no more matches found.
}
```
- Le problème avec ce type d'approche est que je ne suis pas d'effacer toutes les entrées. En fin de compte, il y a encore des chaînes de gauche, elles sont juste achevé, donc travail hors de votre condition du while, le système pourrait ne jamais se terminer.
- Le système prendra fin le break; qui seront exécutées si il n'y a pas de matches.
- Ye-olde Visual Basic 3 GoTo. Mec, s'en tenir à la programmation structurée s'il vous plaît.
InformationsquelleAutor Peter Lawrey
1

Je ne vois pas de problème avec le double pour chaque boucle, mais je vois un gros problème avec == opérateur, que vous utilisez pour comparer Integer objets. C'est totalement erronée. Vous devez utiliser .equals() méthode à la place.

InformationsquelleAutor Andremoniy

-1

de l'utiliser comme un guide:

    for(int[] i: sampleIntArray)
    {
        for(int current: i)
        {
            //sample code here;
        }
    }

InformationsquelleAutor Nathan Adduci

Vous devez vous connecter pour publier un commentaire.