Comment utiliser l'interface Java List, l'interface Iterator et la boucle foreach

Interface Liste

L'interface Liste hérite de l'interface Collection et appartient à une collection à une seule colonne. Les éléments en double sont autorisés dans la collection List. Tous les éléments sont stockés de manière linéaire et les éléments de la collection sont accessibles via. index dans le programme. Spécifiez les éléments. Les éléments sont stockés séquentiellement, c'est-à-dire que l'ordre dans lequel les éléments sont stockés est cohérent avec l'ordre dans lequel ils sont récupérés.

Collection ArrayList

ArrayList est une classe d'implémentation de l'interface List, qui encapsule un objet tableau de longueur variable dans ArrayList.

 package 集合类;
 import java.util.ArrayList;
 import java.util.Arrays;
 public class FengZhuanglei {
     public static void main(String[] args) {
         ArrayList list=new ArrayList();
         list.add("stu1");
         list.add("stu2");
         list.add("stu3");
         list.add("stu4");
         System.out.println("集合的长度:"+list.size());
         System.out.println("第二个元素是:"+list.get(1));
     }
 }

Résultats d'exécution

Il ressort des résultats d'exécution qu'ArrayList et l'index du tableau commencent tous deux à partir de 0. Étant donné que la couche inférieure de la collection ArrayList utilise un tableau pour enregistrer des éléments, lors de l'ajout ou de la suppression d'éléments à des positions spécifiées , , entraînera la création d'un nouveau tableau, qui est relativement inefficace, il ne convient donc pas à un grand nombre d'ajouts et de suppressions. Cependant, les éléments peuvent être trouvés par indexation, ce qui augmente également l'efficacité de la recherche d'éléments.

Collection LinkedList

Afin de résoudre le problème de faible efficacité dans l'ajout et la suppression d'éléments dans la collection ArrayList, la collection LinkList est introduite. Une liste chaînée circulaire bidirectionnelle est maintenue à l'intérieur de chaque élément de la collection LinkList. list est mémorisé par référence. Son élément précédent et l'élément suivant peuvent connecter tous les éléments. Lors de l'insertion d'un nouvel élément, il vous suffit de modifier la relation de référence entre les éléments, ce qui peut augmenter l'efficacité de l'ajout et de la suppression d'éléments.

 package 集合类;
 import java.util.LinkedList;
 public class LianBiao {
     public static void main(String[] args) {
         LinkedList link =new LinkedList();
         link.add("stu1");
         link.add("stu2");
         link.add("stu3");
         link.add("stu4");
         //打印集合中的元素
         System.out.println(link.toString());
         //在集合中插入元素
         link.add(3,"Student");
         //在集合的第一个位置插入元素
         link.addFirst("李龙");
         System.out.println(link);
         //取出集合中的第一个元素
         System.out.println(link.getFirst());
         //删除集合中的元素
         link.remove(3);
         //删除集合中的第一个元素
         link.removeFirst();
         System.out.println(link);
     }
 }

Exécution des résultats

Interface Iterator

Iterator est principalement utilisé pour parcourir les éléments de Collection. Iterator est également appelé itérateur.

 package 集合类;
 import java.util.ArrayList;
 import java.util.Iterator;
 public class DieDai {
     public static void main(String[] args) {
         ArrayList list=new ArrayList();
         list.add("好好学习");
         list.add("做一个优秀的共产主义接班人");
         list.add("为人民服务");
         list.add("做一个对社会有用的人");
         Iterator it= list.iterator();
         //判断ArrayList是否存在下一个元素
         while(it.hasNext()){
             Object obj=it.next();
             System.out.println(obj);
         }
     }
 }

Résultats d'exécution

Dans le processus de parcours de l'itérateur, utilisez d'abord la méthode hasNext() pour déterminer s'il y a toujours l'élément suivant dans la collection. S'il y a un élément, utilisez la méthode next() pour. supprimer l'élément.

boucle foreach

Améliorez la boucle for. La boucle foreach n'a pas besoin d'obtenir la longueur de la boucle, ni d'accéder aux éléments de la boucle via des index foreach traversera automatiquement chaque élément de la boucle.

 package 集合类;
 import java.util.ArrayList;
 public class FE {
     public static void main(String[] args) {
         ArrayList list=new ArrayList();
         list.add("hello");
         list.add("world");
         for(Object obj: list){
             System.out.println(obj);
         }
     }
 }

Résultats d'exécution

On peut voir que la boucle for améliorée est très pratique dans le processus de parcours de la collection. Il n'y a pas de condition de boucle et pas d'itération. Le nombre de boucles est déterminé par le nombre d'éléments. dans la boucle. À chaque fois lors d'une boucle, la boucle for améliorée mémorise les éléments de la boucle actuelle via des variables, imprimant ainsi les éléments de la collection respectivement.

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!