Iterator, erweitert für generische Nutzungssammlung

java.util.Collection-Schnittstelle
ist die Schnittstelle der obersten Ebene der Sammlung, die die allgemeinen Methoden der Sammlung definiert
Die Schnittstelle kann keine Objekte direkt erstellen und verwendet Polymorphismus zum Erstellen von Objekten
Sammlung< ;in der Sammlung Datentyp (generisch)> coll = new ArrayList();

Iterator
Die Art und Weise, Daten zu speichern in der Sammlung Der (Datentyp) ist anders, und die Art und Weise, Elemente aus der Sammlung zu entfernen, ist auch anders. Java bietet uns eine gängige Methode zum Entfernen von Elementen, genannt Iterator
Die Schnittstelle, die den Iterator beschreibt: java.util .Iterator

Abstrakte Methode in Schnittstelle:
boolean hasNext() Gibt true zurück, wenn noch Elemente zum Durchlaufen vorhanden sind. Bestimmen Sie, ob Elemente in der Sammlung vorhanden sind, geben Sie true zurück, wenn nicht, geben Sie false zurück
E next() Gibt das nächste Element der Iteration zurück. Nehmen Sie das nächste Element in der Sammlung heraus.

Der Iterator ist eine Schnittstelle. Sie müssen die Implementierungsklasse des Iterators finden. Die Implementierungsklasse des Iterators ist die interne Klasse jeder Sammlung.
Es gibt eine Methode in der Collection-Schnittstelle: Die Iterator-Methode gibt einen Iterator zurück
Iterator gibt einen Iterator zurück, der die Elemente dieser Sammlung durchläuft.
Die ArrayList-Sammlung implementiert die Collection-Schnittstelle und überschreibt die Iterator-Methode. Der Rückgabewert der Methode ist das Implementierungsklassenobjekt des Iterators.

Hinweis: Wir müssen nur wissen, dass die Iterator-Methode die Implementierungsklasse des Iterators zurückgibt . Es muss nicht darauf geachtet werden, welches Implementierungsklassenobjekt zurückgegeben wird. Diese Art der Transformation wird als schnittstellenorientierte Programmierung bezeichnet.

Schritte zur Verwendung des Iterators:
1. Erstellen Sie ein Sammlungsobjekt und gehen Sie zu Elemente zur Sammlung hinzufügen
2. Verwenden Sie die Iterator-Methode in der Sammlung, um das Implementierungsklassenobjekt des Iterators abzurufen, und verwenden Sie die Iterator-Schnittstelle zum Empfangen (polymorph)
3. Verwenden Sie hasNext und next Methoden im Iterator zum Iterieren und Herausnehmen der Sammlungselemente 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     }

Ausnahme für gleichzeitige Änderung
Während des Iterationsprozesses, wenn die Länge der Wenn die Sammlung geändert wird, tritt eine gleichzeitige Änderungsausnahme auf.
Während des Durchlaufvorgangs wird die Länge der Sammlung geändert, der Iterator erkennt dies jedoch nicht und es tritt eine ConcurrentModificationException auf.

Lösung :
1. Iteration ist Iteration. Ändern Sie die Sammlung nicht
2. Verwenden Sie die Add/Remove-Methode in der Subschnittstelle ListIterator des Iterators, damit der Iterator selbst Elemente hinzufügen/entfernen kann die Sammlung
Auf diese Weise kennt der Iterator selbst die Sammlungsänderungen, es tritt keine gleichzeitige Änderungsausnahme auf

void add(E e) Fügt das angegebene Element in die Liste ein (optionaler Vorgang).
void remove() Entfernt das letzte von next oder previous zurückgegebene Element aus der Liste (optionaler Vorgang).

 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     }

Erweitert für
hat einen Iterator im Inneren, der den Iterationscode vereinfacht und das Durchlaufen erleichtert

Sammlungsschnittstelle Inherit Iterable , sodass alle Implementierungsklassen der Collection-Schnittstelle „Enhanced for“ verwenden können. Datentyp (Datentyp der Sammlung/des Arrays) Variablenname: Sammlungsname/Array-Name) {
syso (Variablenname);
}

Generika in Java
ist der Datentyp, der beim Erstellen des Objekts festgelegt wird

Generics in Java sind Pseudo-Generika: Beim Kompilieren (Schreiben von Code in Java) gibt es beim Ausführen von (. class) kein

Zufallszahlen: Pseudozufallszahlen

Vorteile von Generika:

1. Um eine erzwungene Übertragung zu vermeiden, können Sie direkt elementspezifische Methoden verwenden
2. Laufzeit konvertieren Ausnahmen in Ausnahmen zur Kompilierungszeit (Kompilierungsfehler)

Definieren Sie eine Klasse, die Generika enthält
Imitieren Sie die ArrayList-Sammlungöffentliche Klasse ArrayList{} E: ist ein unbekannter Datentyp, kann eine Ganzzahl sein, kann ein String sein, kann eine Person sein
Bestimmen Sie den Datentyp beim Erstellen des Klassenobjekts

Definitionsformat:
Modifikatorklasse Klassenname {

}





Definieren Sie eine Schnittstelle, die Generika enthält

Format:

Modifikator Schnittstelle Schnittstellenname 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     } Abstrakte Methode (Parameter );

}

enthält generische Typmethode

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

ist keine generisch für die Klasse definiert, aber ein generisch, das durch die Methode selbst definiert wird

Definitionsformat: Ein generisches muss zwischen dem Modifikator und dem Rückgabewerttyp definiert werden, bevor es mit

 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 }

Symbol geändert werden kann Methodenname (Parameter ) {

}

Generics der Methode bestimmen den Datentyp beim Aufruf der Methode und welche Art übergeben wird. Daten, welcher Typ ist ein Generic (das hat nichts mit Generics zu tun). eine Klasse)

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

上限限定:? 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 }

 

Das obige ist der detaillierte Inhalt vonIterator, erweitert für generische Nutzungssammlung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!