Ausführliche Erläuterung der Listen-, Mengen- und Kartendurchquerung sowie Beispiele für erweiterten for-Schleifencode in Java

Dieser Artikel stellt hauptsächlich die detaillierte Erklärung der Listen-, Mengen- und Kartendurchquerung und der erweiterten For-Schleife in Java vor. Freunde in Not können sich auf

Detaillierte Erklärung der Listen-, Mengen- und Kartendurchquerung in Java beziehen und erweiterte for-Schleife

Die Java-Sammlungsklasse kann in drei Hauptblöcke unterteilt werden, nämlich Liste, von der Sammlungsschnittstelle erweitertes Set und Sammlungen vom Typ Map, die in Form von Schlüssel-Wert-Paaren gespeichert sind.

In Bezug auf die erweiterte for-Schleife ist zu beachten, dass mit der erweiterten for-Schleife nicht auf den Array-Indexwert zugegriffen werden kann und die zugehörigen Methoden von Iterator auch intern zum Durchlaufen der Sammlung verwendet werden. Wenn Sie nur einfache Traversal-Lesungen durchführen, wird die erweiterte for-Schleife tatsächlich die Codemenge reduzieren.

Konzept der Sammlung:

1. Funktion: Wird zum Speichern von Objekten verwendet
2. Darunter erscheint jedes Objekt als Element der Sammlung
3. Java-Container haben Sammlungsklassen und Arrays, der Unterschied ist

und ihre häufig verwendeten Implementierungsklassen

Listenschnittstelle:

Listengeordnete Elemente können wiederholt werden

Implementierungsklasse: ArrayList: dynamische Array-Liste

LinkedList: Doppelt verknüpfte Liste

Set-Schnittstelle:

Der Satz ist ungeordnet und die Elemente können nicht wiederholt werden

Implementierungsklasse: HashSet: Hash-Set

TreeSet: Interne Sortierung des Baumsatzes

Kartenschnittstelle:

Daten in Form von Schlüssel-Wert-Paaren speichern – Schlüssel dürfen nicht wiederholt werden

Implementierungsklasse: HashSet: Hash-Set

TreeSet: Sortierung innerhalb der Baummenge

Die in JDK1.0 erscheinenden Sammlungsklassen sind alle threadsicher, aber die Effizienz ist gering

Die in JDK1.0 erscheinenden Sammlungsklassen JDK1.2 ist nicht threadsicher, aber die Effizienz ist gering. Hoch

Codebeispiele sind wie folgt:

import java.util.ArrayList; 
import java.util.HashSet; 
import java.util.Iterator; 
import java.util.List; 
import java.util.Set; 
 
public class ListAndSet{ 
 
  public static void main(String[] args) { 
    setTest(); 
    listTest();
  } 
  // 遍历Set集合
  private static void setTest() { 
    Set<string> set = new HashSet<string>(); 
    set.add("A"); 
    set.add("B"); 
    set.add("C");  
    set.add("D"); 
    set.add("E"); 
 
    //set集合遍历方法1:使用iterator 
    Iterator<string> it = set.iterator(); 
    while (it.hasNext()) { 
      String value = it.next(); 
      System.out.println(value); 
    } 
 
    //set集合遍历方法2:使用增强for循环。 
    for(String s: set){ 
      System.out.println(s); 
    } 
  } 
 
  // 遍历list集合 
  private static void listTest() { 
    List<string> list = new ArrayList<string>(); 
    list.add("111"); 
    list.add("222"); 
    list.add("333"); 
    list.add("444"); 
    list.add("555"); 
 
    // 遍历方式1:使用iterator 
    Iterator<string> it = list.iterator(); 
    while (it.hasNext()) { 
      String value = it.next(); 
      System.out.println(value); 
    } 
 
    // 遍历方法2:使用传统for循环进行遍历。 
    for (int i = 0, size = list.size(); i < size; i++) { 
      String value = list.get(i); 
      System.out.println(value); 
    } 
 
    // 遍历方法3:使用增强for循环进行遍历。 
    for (String value : list) { 
      System.out.println(value); 
    } 
  } 
} 
 
//关于Map类型集合的遍历，keySet()与entrySet()方法
//增强For循环 
public class Map{ 
 
  public static void main(String[] args) { 
    // 创建一个HashMap对象,并加入了一些键值对。 
    Map<string, string=""> maps = new HashMap<string, string="">(); 
    maps.put("111", "111"); 
    maps.put("222", "222"); 
    maps.put("333", "333"); 
    maps.put("444", "444"); 
    maps.put("555", "555"); 
 
    // 传统的遍历map集合的方法1; keySet() 
    //traditionalMethod1(maps); 
    // 传统的遍历map集合的方法2; entrySet() 
    //traditionalMethod2(maps); 
    // 使用增强For循环来遍历map集合方法1; keySet() 
    //strongForMethod1(maps); 
    // 使用增强For循环来遍历map集合方法2; entrySet() 
    strongForMethod2(maps); 
  } 
 
  private static void strongForMethod2(Map<string, string=""> maps) { 
    Set<entry<string, string="">> set = maps.entrySet(); 
    for (Entry<string, string=""> entry : set) { 
      String key = entry.getKey(); 
      String value = entry.getValue(); 
      System.out.println(key + " : " + value); 
    } 
  } 
 
  private static void strongForMethod1(Map<string, string=""> maps) { 
    Set<string> set = maps.keySet(); 
    for (String s : set) { 
      String key = s; 
      String value = maps.get(s); 
      System.out.println(key + " : " + value); 
    } 
  } 
 
  // 使用entrySet()方法，获取maps集合中的每一个键值对， 
  private static void traditionalMethod2(Map<string, string=""> maps) { 
    Set<map.entry<string, string="">> sets = maps.entrySet(); 
    // 取得迭代器遍历出对应的值。 
    Iterator<entry<string, string="">> it = sets.iterator(); 
    while (it.hasNext()) { 
      Map.Entry<string, string=""> entry = (Entry<string, string="">) it.next(); 
      String key = entry.getKey(); 
      String value = entry.getValue(); 
      System.out.println(key + " : " + value); 
    } 
  } 
 
  // 使用keySet()方法，获取maps集合中的所有键，遍历键取得所对应的值。 
  private static void traditionalMethod1(Map<string, string=""> maps) { 
    Set<string> sets = maps.keySet(); 
    // 取得迭代器遍历出对应的值。 
    Iterator<string> it = sets.iterator(); 
    while (it.hasNext()) { 
      String key = it.next(); 
      String value = maps.get(key); 
      System.out.println(key + " : " + value); 
    } 
  } 
}

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der Listen-, Mengen- und Kartendurchquerung sowie Beispiele für erweiterten for-Schleifencode in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!