Méthodes HashMap

Fait partie de la section Logique & Flux du Journey C# de Coddy — leçon 52 sur 66.

Les méthodes de HashMap offrent des moyens puissants de travailler avec vos données de dictionnaire. Explorons quelques méthodes courantes :

Vérifiez si une clé existe dans le dictionnaire :

Dictionary<string, int> inventory = new Dictionary<string, int>();
inventory.Add("apples", 25);

bool hasApples = inventory.ContainsKey("apples");
// hasApples sera true

Obtenir toutes les clés du dictionnaire :

Dictionary<string, int> scores = new Dictionary<string, int>();
scores.Add("Alice", 95);
scores.Add("Bob", 87);

// Obtenir toutes les clés
Dictionary<string, int>.KeyCollection keys = scores.Keys;
foreach (string name in keys)
{
    Console.WriteLine(name);
}

Obtenir toutes les valeurs du dictionnaire :

// Obtenir toutes les valeurs
Dictionary<string, int>.ValueCollection values = scores.Values;
foreach (int score in values)
{
    Console.WriteLine(score);
}

Supprimer un élément du dictionnaire :

scores.Remove("Bob");
// Le dictionnaire ne contient plus que le score d'Alice

Effacer tous les éléments :

scores.Clear();
// Le dictionnaire est maintenant vide

Obtenez le nombre d'éléments dans le dictionnaire en utilisant .Count :

Dictionary<string, int> scores = new Dictionary<string, int>();
scores.Add("Alice", 95);
scores.Add("Bob", 87);

int total = scores.Count;
Console.WriteLine(total);
// Sortie : 2

Défi

Moyen

Créez une méthode nommée ProcessDictionary qui prend un Dictionary<string, int> comme argument et effectue les opérations suivantes :

Affichez Keys: suivi de toutes les clés (une par ligne)
Affichez Values: suivi de toutes les valeurs (une par ligne)
Vérifiez si le dictionnaire contient la clé "total" et affichez Contains 'total': True ou Contains 'total': False
Supprimez la clé "temp" si elle existe
Affichez Count: suivi du nombre d'éléments dans le dictionnaire après ces opérations (utilisez la propriété .Count du dictionnaire)

Aide-mémoire

Vérifiez si une clé existe en utilisant ContainsKey() :

bool hasKey = dictionary.ContainsKey("keyName");

Obtenez toutes les clés d'un dictionnaire :

Dictionary<string, int>.KeyCollection keys = dictionary.Keys;
foreach (string key in keys)
{
    Console.WriteLine(key);
}

Obtenez toutes les valeurs d'un dictionnaire :

Dictionary<string, int>.ValueCollection values = dictionary.Values;
foreach (int value in values)
{
    Console.WriteLine(value);
}

Supprimez un élément en utilisant Remove() :

dictionary.Remove("keyName");

Effacez tous les éléments en utilisant Clear() :

dictionary.Clear();

Obtenez le nombre d'éléments en utilisant .Count :

int count = dictionary.Count;

Essayez vous-même

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

class Program
{
    static void ProcessDictionary(Dictionary<string, int> dict)
    {
        // Écrivez votre code ici
    }
    // Ignorez le code principal, il convertit une chaîne de caractères en HashMap
    static void Main(string[] args)
    {
        Dictionary<string, int> inputDict = new Dictionary<string, int>();
        
        // Lire la première ligne pour vérifier s'il s'agit du format JSON
        string firstLine = Console.ReadLine();
        
        // Vérifier si l'entrée est au format JSON
        if (firstLine != null && firstLine.StartsWith("{") && firstLine.EndsWith("}"))
        {
            try
            {
                // Traiter l'entrée JSON
                string jsonContent = firstLine.Substring(1, firstLine.Length - 2);
                
                // Diviser par les virgules qui ne sont pas entre guillemets
                string pattern = @",(?=(?:[^""]*""[^""]*"")*[^""]*$)";
                string[] entries = Regex.Split(jsonContent, pattern);
                
                foreach (string entry in entries)
                {
                    // Extraire la clé et la valeur à l'aide de regex
                    Match match = Regex.Match(entry, @"""([^""]+)""\s*:\s*(\d+)");
                    if (match.Success)
                    {
                        string keyMatch = match.Groups[1].Value;
                        int valueMatch = int.Parse(match.Groups[2].Value);
                        inputDict.Add(keyMatch, valueMatch);
                    }
                }
                
                ProcessDictionary(inputDict);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing input: {ex.Message}");
            }
        }
        else
        {
            try
            {
                // Process traditional input format
                int n = int.Parse(firstLine);
                
                for (int i = 0; i < n; i++)
                {
                    string[] pair = Console.ReadLine().Split(':');
                    string key = pair[0];
                    int value = int.Parse(pair[1]);
                    inputDict.Add(key, value);
                }
                
                ProcessDictionary(inputDict);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing input: {ex.Message}");
            }
        }
    }
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

1Tableaux multidimensionnels

Bases des tableaux 2D Déclaration et initialisation en 2D Accès aux éléments d'un tableau 2D Boucles imbriquées et tableaux 2D Tableaux irréguliers Opérations matricielles courantes Récapitulatif - Multidimensionnel

4Techniques de contrôle de flux

Retours anticipés Clauses de garde Instructions de saut (goto)Break et Continue Aplatir les conditionnelles imbriquées

7Opérateurs logiques avancés

Évaluation court-circuit Opérateurs logiques conditionnels Priorité des opérateurs Récapitulatif - Opérateurs avancés

10HashMap Partie 2

Méthodes HashMapHashMap imbriquée Récapitulatif - Gérer un entrepôt Récapitulatif - Opérations HashMap