Itérateur, amélioré pour, collection d'utilisations génériques

interface java.util.Collection
est l'interface de niveau supérieur de la collection, qui définit les méthodes communes de la collection
L'interface ne peut pas créer directement des objets et utilise le polymorphisme pour créer des objets
Collection< ; dans la collection Type de données (générique)> coll = new ArrayList();

Itérateur
La façon de stocker les données dans la collection Le (type de données) est différent, et la façon de supprimer des éléments de la collection est également différente. Java nous fournit un moyen courant de supprimer des éléments, appelé itérateur
L'interface décrivant l'itérateur : java.util. .Iterator

Méthode abstraite dans l'interface :
boolean hasNext() Renvoie true s'il y a encore des éléments sur lesquels parcourir. Déterminez s'il y a des éléments dans la collection, retournez vrai sinon, retournez faux
E next() Renvoie l'élément suivant de l'itération. Supprimez l'élément suivant de la collection

L'itérateur est une interface. Vous devez trouver la classe d'implémentation de l'itérateur. La classe d'implémentation de l'itérateur est la classe interne de chaque collection
Il y a un. dans l'interface Collection : La méthode iterator renvoie un itérateur
Iterator renvoie un itérateur qui parcourt les éléments de cette collection.
La collection ArrayList implémente l'interface Collection et remplace la méthode itérateur. La valeur de retour de la méthode est l'objet de classe d'implémentation de l'itérateur

Remarque : il suffit de savoir que la méthode itérateur renvoie la classe d'implémentation de l'itérateur. .Pas besoin de faire attention à l'objet de classe d'implémentation qui est renvoyé. Cette méthode de transformation est appelée programmation orientée interface

Étapes pour utiliser l'itérateur :
1. Créez un objet de collection. et allez dans Ajouter des éléments à la collection
2. Utilisez la méthode itérateur dans la collection pour obtenir l'objet de classe d'implémentation de l'itérateur, et utilisez l'interface Iterator pour recevoir (polymorphe)
3. Utilisez hasNext et next méthodes dans l'itérateur pour itérer et retirer la collection Elements in

 1 public static void main(String[] args) { 2         //1.创建集合对象,往集合中添加元素 3         //Collection<String> coll = new ArrayList<String>(); 4         Collection<String> coll = new HashSet<String>(); 5         coll.add("姚明"); 6         coll.add("乔丹"); 7         coll.add("詹姆斯"); 8         coll.add("科比"); 9         coll.add("艾弗森");10         //2.使用集合中的方法iterator获取迭代器的实现类对象,使用Iterator接口接收(多态)11         //集合中的数据类型是什么,迭代器的数据类型就是什么,跟着集合走12         Iterator<String> it = coll.iterator();13         //3.使用iterator中的方法hasNext和next方法进行迭代,取出集合中的元素14         //boolean hasNext() 如果仍有元素可以迭代，则返回 true。15         /*boolean b = it.hasNext();16         System.out.println(b);17         //E(String) next() 返回迭代的下一个元素。18         String s = it.next();19         System.out.println(s);20         21         b = it.hasNext();22         System.out.println(b);23         s = it.next();24         System.out.println(s);25         26         b = it.hasNext();27         System.out.println(b);28         s = it.next();29         System.out.println(s);30         31         b = it.hasNext();32         System.out.println(b);33         s = it.next();34         System.out.println(s);35         36         b = it.hasNext();37         System.out.println(b);38         s = it.next();39         System.out.println(s);40         41         b = it.hasNext();42         System.out.println(b);//false,没有元素了43         s = it.next();//没有元素了,在取就报NoSuchElementException没有元素异常44         System.out.println(s);*/45         46         /*47          * 发现以上迭代的过程是一个重复的过程,可以使用循环优化48          * 我们不知道集合中有多少元素,所以可以使用while循环49          * while循环的结束条件:hasNext();返回false50          */51         while(it.hasNext()){52             String s = it.next();53             System.out.println(s);54         }55         System.out.println("-------------------");56         /*57          * for循环方式迭代器,使用不多58          */59         /*for(Iterator<String> it2 = coll.iterator();it2.hasNext();){60             String s = it2.next();//取出元素,移动指针到下一位61             System.out.println(s);62         }*/63     }

Exception de modification simultanée
Pendant le processus d'itération, si la longueur du La collection est modifiée, une exception de modification simultanée se produira.
Pendant le processus de parcours, la longueur de la collection est modifiée, mais l'itérateur ne le sait pas, et une ConcurrentModificationException se produira

Solution :
1. L'itération est une itération, ne modifiez pas la collection
2. Utilisez la méthode add/remove dans la sous-interface ListIterator de l'itérateur pour laisser l'itérateur lui-même ajouter/supprimer des éléments de la collection
De cette façon, l'itérateur lui-même connaît les changements de la collection, aucune exception de modification simultanée ne se produira

void add(E e) Insère l'élément spécifié dans la liste (opération facultative).
void remove() Supprime de la liste le dernier élément renvoyé par next ou previous (opération facultative).

 1  public static void main(String[] args) { 2         ArrayList<String> list = new ArrayList<String>(); 3          4         list.add(null); 5         list.add("abc1"); 6         list.add("abc2"); 7         list.add("abc3"); 8         list.add("abc4"); 9         10         /*11          * 使用迭代器遍历集合12          */13         //获取迭代器14         Iterator<String> it = list.iterator();15         //使用while遍历集合16         while(it.hasNext()){17             String s = it.next();18             19             /*20              * 判断集合中有没有"abc3"这个元素21              * 如果有,增加一个元素"itcast"22              * 编程技巧:使用equals判断的时候,要把已知的变量写在前边,未知的写在后边,防止空指针异常23              */24             //if(s.equals("abc3")){25             if("abc3".equals(s)){26                 //1.迭代就是迭代,不要对集合进行修改27                 //list.add("itcast");28             }29             30             System.out.println(s);31         }32         33         System.out.println("------------------");34         35         /*36          * 2.使用迭代器Iterator的子接口ListIterator中的方法add/remove,让迭代器自己增加往集合中增加元素/移除元素37          */38         ListIterator<String> listIt = list.listIterator();39         while(listIt.hasNext()){40             String s = listIt.next();41             if("abc3".equals(s)){42                 listIt.add("itcast");43             }44             System.out.println(s);45         }46         System.out.println(list);47     }

Amélioré pour
est en interne un itérateur, ce qui simplifie le code d'itération et facilite la traversée

Interface de collection Hériter Itérable , donc toutes les classes d'implémentation de l'interface Collection peuvent utiliser amélioré pour

Remarque : Enhanced for est le format

apparu après JDK1.5 :
pour ( type de données (type de données de la collection/du tableau) nom de la variable : nom de la collection/nom du tableau) {
syso (nom de la variable);
}

Génériques en Java
est le type de données, qui est déterminé lors de la création de l'objet.

Les génériques en Java sont des pseudo-génériques : lors de la compilation (écriture de code en java), lors de l'exécution (classe .) n'a pas
Aléatoire. nombres : nombres pseudo-aléatoires

Avantages des génériques :
1. Pour éviter le transfert forcé, vous pouvez utiliser directement des méthodes spécifiques aux éléments
2. Convertir les exceptions d'exécution dans les exceptions au moment de la compilation (échec de la compilation)

Définir une classe contenant des génériques
Imitez la collection ArrayList
classe publique ArrayList{}
E : est un type de données inconnu, peut être Integer, peut être String, peut être Person
Déterminer le type de données lors de la création de l'objet de classe

Format de définition :
Nom de classe de classe de modificateur{

}

 1 public class GenericClass<E> { 2     private E name; 3  4     public E getName() { 5         return name; 6     } 7  8     public void setName(E name) { 9         this.name = name;10     }11     12     public void method(E e){13         System.out.println(e);14     }

Définir une interface contenant des génériques
Format :
Modifier le nom de l'interface de l'interface Méthode abstraite (paramètre < generic>);
}

1  public interface GenericInterface<E> {2     public abstract void method(E e);3 }

 1 /* 2  * 1.定义接口的实现类,不管泛型,接口泛型是怎么写的,实现类也怎么写 3  *  public class ArrayList<E> implements List<E>{} 4  *  创建实现类对象的时候确定泛型的数据类型 5  */ 6 class GenericInterfaceImpl1<E> implements GenericInterface<E>{ 7  8     @Override 9     public void method(E e) {10         System.out.println(e);11     }12 }

contient la méthode Type générique
n'est pas une méthode générique définie sur la classe, mais un générique défini par la méthode elle-même
format de définition : un générique doit être défini entre le modificateur et le type de valeur de retour avant de pouvoir être modifié avec
Symbole (paramètre ){
}
Les génériques sur la méthode déterminent le type de données lors de l'appel de la méthode et quel type est transmis Données, quel type est un générique (cela n'a rien à voir avec les génériques sur une classe )

 1 public class GenericMethod<E> { 2  3     /* 4      * 定义方法,使用类上的泛型 5      */ 6     public void method(E e){ 7         System.out.println(e); 8     } 9     10     /*11      * 定义一个含有泛型的方法12      */13     public <T> void function(T t){14         System.out.println(t);15     }

泛型的通配符:?,代表任意的数据类型

上限限定:? extends E代表只要是E类型的子类即可
下限限定:? super E代表只要是E类型的父类即可

ArrayList集合的构造方法
ArrayList(Collection c)
参数是一个集合,集合的数据类型有要求,只能是ArrayList泛型的子类或者是本身

ArrayList(Collection c)
参数是一个集合,集合的数据类型有要求,只能是ArrayList泛型的子类或者是本身

 1 /* 2  * 斗地主案例: 3  * 1.准备牌 4  * 2.洗牌 5  * 3.发牌 6  * 4.看牌 7  */ 8 public class DouDiZhu { 9     public static void main(String[] args) {10         //1.准备牌11         //创建存储54张牌的集合12         ArrayList<String> poker = new ArrayList<String>();13         //存储大王小王14         poker.add("大王");15         poker.add("小王");16         //存储52张牌17         //创建序号的数组18         String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};19         //创建花色数组20         String[] colors = {"?","?","?","?"};21         //嵌套遍历两个数组22         for (String number : numbers) {23             for (String color : colors) {24                 //System.out.println(color+number);25                 //把组合的牌放入到集合中26                 poker.add(color+number);27             }28         }29         //System.out.println(poker);30         31         /*32          * 2.洗牌33          * 使用Collections中的方法34          * static void shuffle(List<?> list)  
35          */36         Collections.shuffle(poker);37         //System.out.println(poker);38         39         /*40          * 3.发牌41          * 创建4个集合42          * 遍历poker集合43          * 使用poker集合的索引%3发牌44          */45         ArrayList<String> player01 = new ArrayList<String>();46         ArrayList<String> player02 = new ArrayList<String>();47         ArrayList<String> player03 = new ArrayList<String>();48         ArrayList<String> diPai = new ArrayList<String>();49         //遍历poker集合50         for (int i = 0; i < poker.size(); i++) {51             //获取牌52             String s = poker.get(i);53             //先判断索引是否为底牌的索引 51 52 5354             if(i >=51){55                 //给底牌发牌56                 diPai.add(s);57             }else if(i%3==0){58                 //给玩家1发牌59                 player01.add(s);60             }else if(i%3==1){61                 //给玩家1发牌62                 player02.add(s);63             }else if(i%3==2){64                 //给玩家1发牌65                 player03.add(s);66             }67         }68         //4.看牌69         System.out.println("刘德华:"+player01);70         System.out.println("周润发:"+player02);71         System.out.println("周星驰:"+player03);72         System.out.println("底牌:"+diPai);73     }74 }

 

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!