Le résumé le plus complet de l'utilisation de la boucle for, une nouvelle fonctionnalité de Java-javaDidacticiel-php.cn

1. Présentation de la boucle for améliorée

La boucle For améliorée, également appelée boucle Foreach, est utilisée pour parcourir des tableaux et des conteneurs (classes de collection). Lorsque vous utilisez une boucle foreach pour parcourir les éléments d'un tableau et d'une collection, il n'est pas nécessaire d'obtenir les longueurs du tableau et de la collection, et il n'est pas nécessaire d'accéder aux éléments du tableau et aux éléments de collection basés sur des index, ce qui améliore considérablement l'efficacité et rend le code beaucoup plus simple. .

2. Explication du site officiel d'Oracle

Alors, quand devriez-vous utiliser une boucle for-each ? N’importe quand, c’est bien. Cela embellit vraiment votre code. Malheureusement, vous ne pouvez pas l'utiliser partout. Considérez ces cas, par exemple, la suppression de méthodes. Afin de supprimer l'élément actuel, le programme doit accéder à l'itérateur. La boucle for-each masque l'itérateur, vous ne pouvez donc pas appeler la fonction de suppression. Par conséquent, la boucle for-each ne fonctionne pas pour filtrer les éléments. Les boucles qui nécessitent le remplacement d'éléments lors d'une itération dans une collection ou un tableau ne sont pas non plus applicables. Enfin, il ne convient pas à une utilisation dans des boucles parallèles sur plusieurs itérations de collection. Les concepteurs doivent être conscients de ces pièges et concevoir consciemment une structure simple et épurée pour éviter ces situations. Si vous êtes intéressé, vous pouvez consulter l'API sur le site officiel. Si vous ne savez pas comment trouver l'API sur le site officiel, veuillez cliquer pour ouvrir le site officiel pour afficher la méthode API.

3. Amélioré pour le format

for(集合或者数组元素的类型 变量名 ： 集合对象或者数组对象){
 
引用变量名的java语句;
 
}

Copier après la connexion

Lorsque vous voyez les deux points (:), il se lit comme "entrez". La boucle ci-dessus se lit comme "mettez chaque élément TimerTask dans c Traversal". . " Comme vous pouvez le constater, la construction for-each fonctionne parfaitement avec les génériques. Il conserve tous les types de sécurité tout en supprimant l’encombrement restant. Étant donné que vous n'avez pas besoin de déclarer l'itérateur, vous n'avez pas besoin de fournir une déclaration générique pour celui-ci. (Le compilateur l'a déjà fait dans votre dos, vous n'avez pas besoin de vous en soucier.)

Une expérience simple :

Amélioré pour parcourir le tableau<. 🎜>

package cn.jason01;
//增强for遍历数组
public class ForTest01 {
 public static void main(String[] args) {
 int[] array={1,2,3};
 for(int element: array){
 System.out.println(element);
 }
 }
}

Copier après la connexion

2. Améliorer pour parcourir la collection

package cn.jason01;
 
import java.util.ArrayList;
 
public class ForTest {
 public static void main(String[] args) {
 // 泛型推断，后面可以写可以不写String
 ArrayList<String> array = new ArrayList();
 array.add("a");
 array.add("b");
 array.add("c");
 for (String string : array) {
 System.out.println(string);
 }
 
 }
}

Copier après la connexion

4. Améliorer le principe sous-jacent de pour <🎜. >

Regardez d'abord le code

package cn.jason01;
 
import java.util.ArrayList;
import java.util.Iterator;
 
/**
 * 增强for底层原理
 *
 * @author cassandra
 * @version 1.1
 */
public class ForTest {
    public static void main(String[] args) {
        // 泛型推断，后面可以写可以不写String.规范一些是要写上的。
        ArrayList<String> array = new ArrayList();
        // 添加元素
        array.add("a");
        array.add("b");
        array.add("c");
 
        // 增强for实现
        System.out.println("----enhanced for----");
        for (String string : array) {
            System.out.println(string);
        }
 
        // 反编译之后的效果，也就是底层实现原理
        System.out.println("---reverse compile---");
        String string;
        for (Iterator iterator = array.iterator(); iterator.hasNext(); System.out.println(string)) {
            string = (String) iterator.next();
 
        }
 
        // 迭代器实现
        System.out.println("------Iterator------");
        for (Iterator<String> i = array.iterator(); i.hasNext(); System.out.println(i.next())) {
 
        }
 
        // 普通for实现
        System.out.println("-----general for-----");
        for (int x = 0; x < array.size(); x++) {
            System.out.println(array.get(x));
        }
    }
}

Copier après la connexion

Comme vous pouvez le voir dans le code ci-dessus, la couche inférieure est implémentée par les itérateurs. Améliorée pour masquer les itérateurs, donc là. Il n'est pas nécessaire de créer des itérateurs, le code est donc beaucoup plus simple. C'est également la raison de l'introduction du for amélioré, qui vise à réduire le code, à faciliter la traversée des collections et des tableaux et à améliorer l'efficacité.

Remarque : étant donné que amélioré pour masque l'itérateur, lorsque vous utilisez amélioré pour parcourir des collections et des tableaux, vous devez d'abord déterminer s'il est nul, sinon une exception de pointeur nul sera levée. La raison est très simple. La couche inférieure doit utiliser un tableau ou un objet de collection pour appeler la méthode iterator() afin de créer un itérateur (Iterator est une interface, il doit donc être implémenté par une sous-classe). une exception sera certainement levée.

5. Améliorer l'applicabilité et les limites de pour

1 Applicabilité

Applicable à la traversée d'ensembles et de tableaux.

2. Limitations :

①La collection ne peut pas être nulle car la couche sous-jacente est un itérateur.

②L'itérateur est masqué, la collection ne peut donc pas être modifiée (ajoutée ou supprimée) lors du parcours de la collection.

③La marque de coin ne peut pas être définie.

6. Explication détaillée de l'utilisation améliorée

1. Amélioré pour une utilisation dans les tableaux

package cn.jason05;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 增强for用法
 *
 * @author cassandra
 */
public class ForDemo {
 public static void main(String[] args) {
 // 遍历数组
 int[] arr = { 1, 2, 3, 4, 5 };
 for (int x : arr) {
 System.out.println(x);
 }
 }
}

Copier après la connexion

2. 🎜>

package cn.jason05;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 增强for用法
 *
 * @author cassandra
 */
public class ForDemo {
 public static void main(String[] args) {
 // 遍历集合
 ArrayList<String> array = new ArrayList<String>();
 array.add("hello");
 array.add("world");
 array.add("java");
 
 for (String s : array) {
 System.out.println(s);
 }
 
 // 集合为null，抛出NullPointerException空指针异常
 List<String> list = null;
 if (list != null) {
 for (String s : list) {
 System.out.println(s);
 }
 }
 
 // 增强for中添加或修改元素，抛出ConcurrentModificationException并发修改异常
 for (String x : array) {
 if (array.contains("java"))
 array.add(1, "love");
 }
 
 }

Copier après la connexion

3. Les génériques sont parfaitement combinés avec améliorés pour

Remarque : Il doit être parfaitement combiné avec les génériques, sinon vous devez le faire manuellement. téléchargez-le Transformation

1. Il n'y a pas d'effet générique, et la classe améliorée pour

Étudiant

ne peut pas être utilisée

package cn.jason01;
 
public class Student {
 private String name1;
 private String name2;
 
 public Student() {
 super();
 }
 
 public Student(String name1, String name2) {
 super();
 this.name1 = name1;
 this.name2 = name2;
 }
 
 public String getName1() {
 return name1;
 }
 
 public void setName1(String name1) {
 this.name1 = name1;
 }
 
 public String getName2() {
 return name2;
 }
 
 public void setName2(String name2) {
 this.name2 = name2;
 }
 
}

Copier après la connexion

Code de test

package cn.jason01;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Test02 {
 public static void main(String[] args) {
 // 创建集合1
 List list1 = new ArrayList();
 list1.add("a");
 list1.add("b");
 list1.add("c");
 
 // 创建集合2
 List list2 = new ArrayList();
 list2.add("d");
 list2.add("e");
 list2.add("f");
 // 创建集合三
 List list3 = new ArrayList();
 
 // 遍历第一和第二个集合，并添加元素到集合三
 for (Iterator i = list1.iterator(); i.hasNext();) {
 // System.out.println(i.next());
 String s = (String) i.next();
 for (Iterator j = list2.iterator(); j.hasNext();) {
 // list2.add(new Student(s,j.next()));
 String ss = (String) j.next();
 list3.add(new Student(s, ss));
 }
 }
 
 // 遍历集合三，并输出元素
 Student st;
 for (Iterator k = list3.iterator(); k.hasNext(); System.out
 .println(new StringBuilder().append(st.getName1()).append(st.getName2()))) {
 st = (Student) k.next();
 }
 }
}

Copier après la connexion

Si vous supprimez les deux lignes de code commenté dans le code ci-dessus, le programme signalera une erreur, car la collection ne déclare pas le type de l'élément, et l'itérateur ne sait naturellement pas de quel type il s'agit. Par conséquent, s'il n'y a pas de génériques, une transformation vers le bas est requise. Seuls les itérateurs peuvent être utilisés et les améliorations pour ne peuvent pas être utilisées.

2. Génériques et améliorations pour

Modification générique du code ci-dessus

package cn.jason01;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
/**
 * 增强for和泛型完美结合
 *
 * @author cassandra
 */
public class Test03 {
 public static void main(String[] args) {
 // 创建集合1
 List<String> list1 = new ArrayList<String>();
 list1.add("a");
 list1.add("b");
 list1.add("c");
 
 // 创建集合2
 List<String> list2 = new ArrayList<String>();
 list2.add("d");
 list2.add("e");
 list2.add("f");
 // 创建集合三
 List<Student> list3 = new ArrayList<Student>();
 
 //// 遍历第一和第二个集合，并添加元素到集合三
 for (String s1 : list1) {
 for (String s2 : list2) {
 list3.add(new Student(s1, s2));
 }
 }
 
 // 遍历集合三，并输出元素
 for (Student st : list3) {
 System.out.println(new StringBuilder().append(st.getName1()).append(st.getName2()));
 }
 }
}

Copier après la connexion

Quatre méthodes pour le parcours de la collection de listes

Il existe une méthode iterator() dans l'interface Collection, qui renvoie un type Iterator. Il existe un itérateur appelé Iterator. Il existe une méthode listIterator() dans List, il existe donc un collecteur supplémentaire ListIterator. Ses sous-classes LinkedList, ArrayList et Vector implémentent toutes les interfaces List et Collection, elles peuvent donc être parcourues à l'aide de deux itérateurs.

Test de code

package cn.jason05;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
 
/**
 * 这是List集合遍历四种方法
 *
 * @author cassandra
 */
 
public class ForDemo01 {
 public static void main(String[] args) {
 // 创建集合
 List<String> list = new ArrayList<String>();
 list.add("hello");
 list.add("world");
 list.add("java");
 
 // 方法1，Iterator迭代器遍历
 Iterator<String> i = list.iterator();
 while (i.hasNext()) {
 String s = i.next();
 System.out.println(s);
 }
 
 // 方法2，ListIterator迭代器遍历集合
 ListIterator<String> lt = list.listIterator();
 while (lt.hasNext()) {
 String ss = lt.next();
 System.out.println(ss);
 }
 
 // 方法3，普通for遍历集合
 for (int x = 0; x < list.size(); x++) {
 String sss = list.get(x);
 System.out.println(sss);
 }
 
 // 方法4，增强for遍历集合
 for (String ssss : list) {
 System.out.println(ssss);
 }
 
 }
}

Copier après la connexion

5.Set collection traversal 2 méthodes

Parce que la collection Set n'a pas get (int index), donc il n'y a pas de boucle for ordinaire, et il n'y a pas de méthode listIterator() dans Set, donc il n'y a pas d'itérateur ListIterator. Il n'y a donc que deux façons de traverser.

Test de code

package cn.jason05;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class ForTest03 {
 public static void main(String[] args) {
 Set<String> set = new HashSet<String>();
 set.add("hello");
 set.add("world");
 set.add("java");
 
 // 方法1，Iterator迭代器遍历集合
 Iterator<String> it = set.iterator();
 while (it.hasNext()) {
 System.out.println(it.next());
 }
 
 // 方法2，增强for遍历集合
 for (String s : set) {
 System.out.println(s);
 }
 
 }
}

Copier après la connexion

7.Résumé

Améliorer l'applicabilité et les limites de pour

Applicabilité : convient à la traversée de collections et de tableaux.

Limitations :

①La collection ne peut pas être nulle car la couche sous-jacente est un itérateur.

②Impossible de définir une marque de coin.

③L'itérateur est masqué, la collection ne peut donc pas être modifiée (ajoutée ou supprimée) lors du parcours de la collection.

2. Améliorez la combinaison de for et de génériques dans la collection pour profiter des nouvelles fonctionnalités.

3. Il est très important de vérifier les nouvelles fonctionnalités du site officiel. Pour savoir ce qu'elles sont, vous devez également savoir pourquoi. Ce n'est que lorsque vous les comprenez dans votre esprit que vous pourrez les utiliser librement.

Le résumé ci-dessus de l'utilisation la plus complète de la boucle for, une nouvelle fonctionnalité de Java, est tout le contenu partagé par l'éditeur. J'espère qu'il pourra vous donner une référence, et j'espère que vous soutiendrez le. Site Web chinois PHP.

Pour des articles plus pertinents sur le résumé le plus complet de l'utilisation des boucles for, les nouvelles fonctionnalités de Java, veuillez faire attention au site Web PHP chinois !