Die umfassendste Zusammenfassung der Verwendung der for-Schleife, einer neuen Funktion von Java

1. Übersicht über die erweiterte for-Schleife

Die erweiterte for-Schleife, auch Foreach-Schleife genannt, wird zum Durchlaufen von Arrays und Containern (Sammlungsklassen) verwendet. Wenn Sie eine foreach-Schleife zum Durchlaufen von Array- und Sammlungselementen verwenden, ist es nicht erforderlich, die Array- und Sammlungslängen abzurufen, und es besteht keine Notwendigkeit, auf Array-Elemente und Sammlungselemente basierend auf Indizes zuzugreifen, was die Effizienz erheblich verbessert und den Code viel einfacher macht .

2. Erklärung von der offiziellen Website von Oracle

Wann sollten Sie also eine for-each-Schleife verwenden? Jederzeit ist in Ordnung. Das verschönert Ihren Code wirklich. Leider kann man es nicht überall nutzen. Betrachten Sie diese Fälle beispielsweise beim Entfernen von Methoden. Um das aktuelle Element zu entfernen, benötigt das Programm Zugriff auf den Iterator. Die for-each-Schleife verbirgt den Iterator, sodass Sie die Löschfunktion nicht aufrufen können. Daher funktioniert die for-each-Schleife nicht zum Filtern von Elementen. Schleifen, die beim Durchlaufen einer Sammlung oder eines Arrays das Ersetzen von Elementen erfordern, sind ebenfalls nicht anwendbar. Schließlich ist es nicht für die Verwendung in parallelen Schleifen über mehrere Sammlungsiterationen hinweg geeignet. Designer sollten sich dieser Fallstricke bewusst sein und bewusst eine klare, einfache Struktur entwerfen, um solche Situationen zu vermeiden. Wenn Sie interessiert sind, können Sie die API auf der offiziellen Website anzeigen. Wenn Sie nicht wissen, wie Sie die API auf der offiziellen Website finden, klicken Sie bitte, um die offizielle Website zu öffnen und die API-Methode anzuzeigen.

3. Erweitert für das Format

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

Wenn Sie den Doppelpunkt (:) sehen, lautet er „einkommen“. Die obige Schleife lautet „jedes TimerTask-Element in c Traversal einfügen“. .“ Wie Sie sehen können, funktioniert das for-each-Konstrukt perfekt mit Generika. Es behält alle Arten von Sicherheit bei und beseitigt gleichzeitig die verbleibende Unordnung. Da Sie den Iterator nicht deklarieren müssen, müssen Sie keine generische Deklaration dafür bereitstellen. (Der Compiler hat es bereits hinter Ihrem Rücken erledigt, Sie müssen sich nicht darum kümmern.)

Eine einfache Erfahrung:

Erweitert für das Durchlaufen des Arrays

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);
 }
 }
}

2. Erweitern Sie for, um die Sammlung zu durchlaufen

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);
 }
 
 }
}

4. Erweitern Sie das zugrunde liegende Prinzip von for

Schauen Sie sich zuerst den Code an

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));
        }
    }
}

Wie Sie dem obigen Code entnehmen können, wird die unterste Ebene durch Iteratoren implementiert, sodass die Iteratoren tatsächlich ausgeblendet sind Es ist nicht erforderlich, Iteratoren zu erstellen, daher ist der Code viel einfacher. Dies ist auch der Grund für die Einführung von Enhanced for, das den Code reduzieren, das Durchlaufen von Sammlungen und Arrays erleichtern und die Effizienz verbessern soll.

Hinweis: Da „Enhanced for“ den Iterator verbirgt, müssen Sie bei Verwendung von „Enhanced for“ zum Durchlaufen von Sammlungen und Arrays zunächst feststellen, ob es null ist, andernfalls wird eine Nullzeigerausnahme ausgelöst. Der Grund ist sehr einfach. Die unterste Ebene muss ein Array oder ein Sammlungsobjekt verwenden, um die Methode iterator () aufzurufen, um einen Iterator zu erstellen (Iterator ist eine Schnittstelle und muss daher von einer Unterklasse implementiert werden). Ausnahme wird definitiv ausgelöst.

5. Verbessern Sie die Anwendbarkeit und Einschränkungen von für

1. Anwendbarkeit

Anwendbar auf das Durchlaufen von Mengen und Arrays.

2. Einschränkungen:

①Die Sammlung darf nicht null sein, da die zugrunde liegende Ebene ein Iterator ist.

②Der Iterator ist ausgeblendet, sodass die Sammlung beim Durchlaufen der Sammlung nicht geändert (hinzugefügt oder gelöscht) werden kann.

③Die Eckmarkierung kann nicht gesetzt werden.

Detaillierte Erläuterung zur Verwendung in Arrays

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);
 }
 }
}

Erweitert für die Verwendung in Sammlungen

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");
 }
 
 }

3. Perfekte Kombination von Generika und verbessert für

Hinweis: Es muss perfekt mit Generika kombiniert werden, andernfalls muss manuell gearbeitet werden Laden Sie es herunter Transformation

1. Es gibt keinen generischen Effekt und die erweiterte Klasse für

Studentenklasse

kann nicht verwendet werden

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;
 }
 
}

Testcode

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();
 }
 }
}

Wenn Sie die beiden Zeilen des kommentierten Codes im obigen Code entfernen, meldet das Programm einen Fehler, da die Sammlung deklariert nicht den Typ des Elements und der Iterator weiß natürlich nicht, um welchen Typ es sich handelt. Wenn also keine Generika vorhanden sind, ist eine Abwärtstransformation erforderlich. Es können nur Iteratoren verwendet werden und keine erweiterten Iteratoren verwendet werden.

2. Generika und Erweiterungen für

Generische Modifikation des obigen Codes

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()));
 }
 }
}

4

Es gibt eine iterator()-Methode in der Collection-Schnittstelle, die einen Iterator-Typ zurückgibt. Es gibt einen Iterator namens Iterator. Es gibt eine listIterator()-Methode in List, daher gibt es einen zusätzlichen Collector ListIterator. Seine Unterklassen LinkedList, ArrayList und Vector implementieren alle die List- und Collection-Schnittstellen, sodass sie mit zwei Iteratoren durchlaufen werden können.

Codetest

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);
 }
 
 }
}

5. Set-Sammlungsdurchlauf 2 Methoden

Weil die Set-Sammlung kein get hat (int index)-Methode, daher gibt es keine gewöhnliche for-Schleife und es gibt keine listIterator()-Methode in Set, daher gibt es keinen ListIterator-Iterator. Es gibt also nur zwei Möglichkeiten zum Durchqueren.

Codetest

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);
 }
 
 }
}

7. Verbessern Sie die Anwendbarkeit und Einschränkungen von for

Anwendbarkeit: Geeignet zum Durchlaufen von Sammlungen und Arrays.

Einschränkungen:

①Die Sammlung darf nicht null sein, da die zugrunde liegende Ebene ein Iterator ist.

②Eckmarkierung kann nicht gesetzt werden.

③Der Iterator ist ausgeblendet, sodass die Sammlung beim Durchlaufen der Sammlung nicht geändert (hinzugefügt oder gelöscht) werden kann.

2. Erweitern Sie die Kombination von for und generics in der Sammlung, um die neuen Funktionen nutzen zu können.

3. Es ist sehr wichtig, die neuen Funktionen der offiziellen Website zu überprüfen. Um zu wissen, was sie sind, müssen Sie auch wissen, warum.

Die obige Zusammenfassung der umfassendsten Verwendung der for-Schleife, einer neuen Funktion von Java, ist der gesamte vom Herausgeber geteilte Inhalt. Ich hoffe, dass er Ihnen eine Referenz geben kann, und ich hoffe, dass Sie ihn unterstützen Chinesische PHP-Website.

Weitere relevante Artikel zur umfassendsten Zusammenfassung der Verwendung der for-Schleife, der neuen Java-Funktion, finden Sie auf der chinesischen PHP-Website!