Explication détaillée des exemples de code de liste, d'ensemble, de parcours de carte et amélioré pour la boucle en Java

Cet article présente principalement l'explication détaillée de la traversée de liste, d'ensemble, de carte et de la boucle for améliorée en Java. Les amis qui en ont besoin peuvent se référer à

Explication détaillée de liste, d'ensemble et de carte en Java. Traversée et boucle for améliorée

La classe de collection Java peut être divisée en trois blocs, à savoir List, Set étendu à partir de l'interface Collection et la collection de type Map stockée sous forme de paires clé-valeur.

Concernant la boucle for améliorée, il convient de noter que la valeur de l'indice du tableau n'est pas accessible à l'aide de la boucle for améliorée, et les méthodes associées d'Iterator sont également utilisées en interne pour le parcours de collection. Si vous effectuez uniquement une simple lecture de parcours, la boucle for améliorée réduira en effet la quantité de code.

Concept de collection :

1. Fonction : utilisé pour stocker des objets
2. parmi lesquels Chaque objet apparaît comme un élément de la collection
3. Les conteneurs Java ont des classes et des tableaux de collection. La différence est

et leurs classes d'implémentation couramment utilisées

Interface de liste :

Les éléments ordonnés par liste peuvent être répétés

Classe d'implémentation : ArrayList : liste de tableaux dynamiques

LinkedList : Liste doublement chaînée

Interface de l'ensemble :

L'ensemble n'est pas ordonné et les éléments ne peuvent pas être répétés

Classe d'implémentation : HashSet : Ensemble de hachage

TreeSet : Tri interne de l'ensemble d'arbres

Interface cartographique :

Stocker les données sous forme de paires clé-valeur - les clés ne peuvent pas être répétées

Classe d'implémentation : HashSet : ensemble de hachage

TreeSet : tri à l'intérieur de l'arborescence

Les classes de collection apparaissant dans JDK1.0 sont toutes thread-safe, mais l'efficacité est faible

Les classes de collection apparaissant dans JDK1.2 n'est pas thread-safe, mais son efficacité est faible. Élevé

les exemples de code sont les suivants :

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

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!