HashMap imbriquée

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

Une HashMap imbriquée est une HashMap où les valeurs elles-mêmes sont des HashMaps. C'est utile pour organiser des données hiérarchiques.

Créez une HashMap imbriquée pour stocker les notes des étudiants par matière :

// Créer la HashMap externe (étudiant -> matières)
Dictionary<string, Dictionary<string, int>> studentGrades = new Dictionary<string, Dictionary<string, int>>();

// Créer une HashMap interne pour un étudiant (matière -> note)
Dictionary<string, int> alexGrades = new Dictionary<string, int>();

// Ajouter des notes à la HashMap interne
alexGrades.Add("Math", 90);
alexGrades.Add("Science", 85);

// Ajouter la HashMap interne à la HashMap externe
studentGrades.Add("Alex", alexGrades);

Accéder à une valeur imbriquée :

// Accéder à la note de mathématiques d'Alex
int mathGrade = studentGrades["Alex"]["Math"]; // Retourne 90

Ajoutez un autre étudiant avec ses notes :

// Create another inner HashMap
Dictionary<string, int> sarahGrades = new Dictionary<string, int>();
sarahGrades.Add("Math", 95);
sarahGrades.Add("Science", 92);

// Add to the outer HashMap
studentGrades.Add("Sarah", sarahGrades);

Défi

Moyen

Créez une méthode nommée AddCourseGrade qui prend quatre arguments :

Un Dictionary imbriqué représentant les notes des étudiants : Dictionary<string, Dictionary<string, int>> grades
Un nom d'étudiant (string)
Un nom de cours (string)
Une note (int)

La méthode doit :

Si l'étudiant n'existe pas dans le dictionnaire, créer une nouvelle entrée pour lui
Ajouter le cours et la note au dossier de l'étudiant
Si le cours existe déjà pour cet étudiant, mettre à jour la note
Afficher "Added [course] grade for [student]: [grade]" après l'ajout ou la mise à jour

Aide-mémoire

Un HashMap imbriqué est un HashMap où les valeurs elles-mêmes sont des HashMaps, ce qui est utile pour organiser des données hiérarchiques.

Créer un HashMap imbriqué :

Dictionary<string, Dictionary<string, int>> studentGrades = new Dictionary<string, Dictionary<string, int>>();

// Créer le HashMap interne
Dictionary<string, int> alexGrades = new Dictionary<string, int>();
alexGrades.Add("Math", 90);
alexGrades.Add("Science", 85);

// Ajouter au HashMap externe
studentGrades.Add("Alex", alexGrades);

Accéder aux valeurs imbriquées :

int mathGrade = studentGrades["Alex"]["Math"]; // Retourne 90

Ajouter une autre entrée :

Dictionary<string, int> sarahGrades = new Dictionary<string, int>();
sarahGrades.Add("Math", 95);
sarahGrades.Add("Science", 92);
studentGrades.Add("Sarah", sarahGrades);

Essayez vous-même

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

class Program
{
    public static void AddCourseGrade(Dictionary<string, Dictionary<string, int>> grades, string student, string course, int grade)
    {
        // Écrivez votre code ici
    }
    
    // Ignorez le code principal, il convertit une chaîne en un HashMap
    static void Main(string[] args)
    {
        // Vérifiez si la première ligne pourrait être du JSON
        string firstLine = Console.ReadLine();
        
        Dictionary<string, Dictionary<string, int>> studentGrades = new Dictionary<string, Dictionary<string, int>>();
        string student;
        string course;
        int grade;
        
        // Entrée au format JSON
        if (firstLine != null && firstLine.StartsWith("{") && firstLine.EndsWith("}"))
        {
            try
            {
                // Analysez les notes existantes des étudiants à partir du JSON
                string jsonContent = firstLine.Substring(1, firstLine.Length - 2);
                string studentPattern = @"""([^""]+)""\s*:\s*\{([^\}]+)\}";
                
                MatchCollection studentMatches = Regex.Matches(jsonContent, studentPattern);
                foreach (Match studentMatch in studentMatches)
                {
                    string studentName = studentMatch.Groups[1].Value;
                    string coursesJson = studentMatch.Groups[2].Value;
                    
                    Dictionary<string, int> courseGrades = new Dictionary<string, int>();
                    string coursePattern = @"""([^""]+)""\s*:\s*(\d+)";
                    
                    MatchCollection courseMatches = Regex.Matches(coursesJson, coursePattern);
                    foreach (Match courseMatch in courseMatches)
                    {
                        string courseName = courseMatch.Groups[1].Value;
                        int courseGrade = int.Parse(courseMatch.Groups[2].Value);
                        courseGrades.Add(courseName, courseGrade);
                    }
                    
                    studentGrades.Add(studentName, courseGrades);
                }
                
                // Parse student, course, and grade for the operation
                string studentInput = Console.ReadLine();
                Match studentNameMatch = Regex.Match(studentInput, @"""([^""]+)""");
                student = studentNameMatch.Success ? studentNameMatch.Groups[1].Value : studentInput;
                
                string courseInput = Console.ReadLine();
                Match courseNameMatch = Regex.Match(courseInput, @"""([^""]+)""");
                course = courseNameMatch.Success ? courseNameMatch.Groups[1].Value : courseInput;
                
                grade = int.Parse(Console.ReadLine());
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing JSON input: {ex.Message}");
                return;
            }
        }
        else
        {
            try
            {
                // Traditional input
                student = firstLine;
                course = Console.ReadLine();
                grade = int.Parse(Console.ReadLine());
                
                // Create an example entry
                Dictionary<string, int> johnGrades = new Dictionary<string, int>();
                johnGrades.Add("Math", 88);
                studentGrades.Add("John", johnGrades);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing traditional input: {ex.Message}");
                return;
            }
        }
        
        AddCourseGrade(studentGrades, student, course, grade);
    }
}

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éeRécapitulatif - Gérer un entrepôt Récapitulatif - Opérations HashMap