Article - Préférez la boucle for-each aux boucles for traditionnelles

Problèmes avec la boucle for traditionnelle :

• Les boucles for traditionnelles ont des variables d'index ou des itérateurs, qui peuvent générer des "débris" inutiles et augmenter les risques d'erreur.
• Les erreurs telles que l'utilisation d'un index ou d'un itérateur incorrect peuvent ne pas être détectées par le compilateur.
• La boucle traditionnelle est différente pour les tableaux et les collections, ce qui rend la maintenance et le basculement entre les types difficiles.

Exemple de boucle for traditionnelle dans la collection :

for (Iterator<String> i = collection.iterator(); i.hasNext();) {
    String element = i.next();
    // Processa elemento
}

Exemple de boucle for traditionnelle dans un tableau :

for (int i = 0; i < array.length; i++) {
    String element = array[i];
    // Processa elemento
}

Avantages de la boucle for-each :

• Simplification : élimine les itérateurs et les index inutiles, en se concentrant uniquement sur les éléments.
• Moins d'erreurs : réduit la possibilité d'erreurs associées aux variables de contrôle.
• Flexibilité : fonctionne de la même manière pour les tableaux et les collections, ce qui facilite le basculement entre eux.
• Performance : il n'y a aucune perte de performances par rapport à la boucle for traditionnelle.

Exemple de boucle For-each :

for (String element : collection) {
    // Processa elemento
}

for (String element : array) {
    // Processa elemento
}

Problèmes avec les boucles for traditionnelles dans les itérations imbriquées :

• L'utilisation explicite d'itérateurs dans des boucles imbriquées peut provoquer des erreurs difficiles à détecter.
• Exemple : appeler next() sur le mauvais itérateur peut lever une exception ou générer des résultats inattendus.

Erreur courante dans les boucles imbriquées avec itérateurs :

for (Iterator<Suit> i = suits.iterator(); i.hasNext();) {
    for (Iterator<Rank> j = ranks.iterator(); j.hasNext();) {
        System.out.println(i.next() + " " + j.next());
    }
}

Correction avec des boucles for-each imbriquées :

• L'utilisation de boucles for-each élimine automatiquement ces erreurs car il n'y a pas de contrôle explicite des itérateurs.

Exemple correct avec for-each :

for (Suit suit : suits) {
    for (Rank rank : ranks) {
        System.out.println(suit + " " + rank);
    }
}

Limitations de la boucle for-each :

• Filtrage destructif : ne permet pas de supprimer des éléments lors de l'itération, ce qui rend nécessaire l'utilisation d'un itérateur explicite ou de méthodes telles que removeIf (Java 8).
• Transformation : Si vous devez modifier les éléments d'une liste ou d'un tableau, la boucle for-each ne suffit pas, car vous devez accéder à l'index.
• Itération parallèle : lorsqu'il est nécessaire de parcourir plusieurs collections en parallèle, la boucle for-each ne fonctionne pas correctement, car un contrôle explicite sur les index est requis.

Exemple de transformation avec boucle for traditionnelle :

for (int i = 0; i < list.size(); i++) {
    list.set(i, modify(list.get(i)));
}

Interface itérable :

• La boucle for-each fonctionne avec n'importe quel objet qui implémente l'interface Iterable, ce qui facilite l'itération sur de nouveaux types de collections.

Interface itérable :

public interface Iterable<T> {
    Iterator<T> iterator();
}

Conclusion :

• Préférez toujours les boucles for-each pour plus de clarté, de sécurité et de flexibilité. Utilisez les boucles for traditionnelles uniquement lorsque cela est vraiment nécessaire (transformation, filtrage destructif ou itération parallèle).

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!