En général, il n’y a pas beaucoup plus à dire sur les maps. Le fait qu’il s’agisse d’une structure de données qui stocke les données selon le principe clé-valeur est suffisant. Mais que faire si vous souhaitez tenter une petite aventure et utiliser une structure de données comme un ArrayList en tant que valeur dans la map ?

Utilisation de structures de données comme valeurs dans une map

Il se peut que vous ayez très peu de collisions dans la hashmap, et vous pourriez vouloir stocker les données d’une manière encore plus particulière.

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> marketingDepartment = new ArrayList<>();
        marketingDepartment.add("Michael");
        marketingDepartment.add("Alice");
        marketingDepartment.add("Jimmy");

        List<String> developerDepartment = new ArrayList<>();
        developerDepartment.add("Bob");
        developerDepartment.add("John");
        developerDepartment.add("Ryan");

        Map<String, List<String>> company = new HashMap<>();
        company.put("Marketing", marketingDepartment);
        company.put("Development", developerDepartment);

        System.out.println("Company: " + company);
    }
}

Voici un exemple de création d'une structure de données qui stocke des informations sur une entreprise spécifique. Cette approche est parfois utilisée lors de la manipulation de bases de données, mais il est conseillé de ne pas en abuser, car la récupération des données à partir de telles structures de données peut s'avérer complexe. Par exemple, supposons que nous souhaitions récupérer le marketeur à l'indice 1.

Main.java


              1234567891011121314151617181920212223242526272829
            
package com.example;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> marketingDepartment = new ArrayList<>();
        marketingDepartment.add("Michael");
        marketingDepartment.add("Alice");
        marketingDepartment.add("Jimmy");

        List<String> developerDepartment = new ArrayList<>();
        developerDepartment.add("Bob");
        developerDepartment.add("John");
        developerDepartment.add("Ryan");

        Map<String, List<String>> company = new HashMap<>();
        company.put("Marketing", marketingDepartment);
        company.put("Development", developerDepartment);

        System.out.println("Company: " + company);

        String marketerAtIndexOne = company.get("Marketing").get(1);
        System.out.println("Marketer at index 1 is: " + marketerAtIndexOne);
    }
}

À première vue, cela ne semble pas compliqué. Il suffit simplement d'utiliser la méthode une fois de plus. Cependant, en programmation, il est essentiel d'éviter le codage en dur.

Le codage en dur est déconseillé et doit être évité autant que possible. Voici un exemple de codage en dur, que nous allons ensuite corriger ensemble :

Main.java


              123456789101112
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Hardcoded value
        double price = 49.99;

        // Using hardcoded value
        double discountedPrice = price * 0.8; // 20% discount
        System.out.println("Discounted Price: " + discountedPrice);
    }
}

Comme vous pouvez le constater, il y a du codage en dur dans le code ci-dessus. Lors de la définition de la remise, nous utilisons un nombre brut. Il est préférable de stocker cette remise dans une variable afin de réutiliser cette valeur ultérieurement. Améliorons le code ci-dessus :

Main.java


              12345678910111213
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Using variables instead of hardcoding
        double price = 49.99;
        double discountPercentage = 0.2; // 20% discount

        // Using variables
        double discountedPrice = price * (1 - discountPercentage);
        System.out.println("Discounted Price: " + discountedPrice);
    }
}

De cette manière, on obtient une variable contenant la valeur de la remise, et dans un programme de grande taille à l'avenir, il suffirait de modifier la valeur de cette unique variable.

Si la valeur avait été codée en dur, il aurait fallu la modifier à chaque occurrence, ce qui augmente considérablement le temps nécessaire pour améliorer ou modifier le code.

Résumé

En résumé, on peut dire que dans les structures de données, divers types de données, y compris d'autres structures de données, peuvent être utilisés. Cela apporte de la commodité à l'utilisation de ces structures de données et de la flexibilité à votre application. Cependant, il ne faut pas oublier la complexité algorithmique, car il s'agit d'un paramètre crucial lors de l'écriture d'une application. Lors de l'utilisation de structures de données à l'intérieur d'autres structures de données, il est assez facile de commettre des erreurs et de compliquer significativement l'exécution d'une opération spécifique.

Restez vigilant à ce sujet, et votre code sera excellent !

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille `n` et effectue une opération en temps constant sur chaque élément ?

2. Quel est le principal inconvénient du codage en dur des valeurs directement dans le code ?

3. Étant donné deux algorithmes avec des complexités temporelles `O(n log n)` et `O(n^2)`, lequel est généralement plus efficace pour de grandes tailles d’entrée ?

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 4

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you give an example of how to store an ArrayList as a value in a map?

What are some best practices to avoid hardcoding in such scenarios?

Can you explain more about the potential challenges of retrieving data from nested data structures?

Glissez pour afficher le menu

Utilisation de structures de données comme valeurs dans une map

Il se peut que vous ayez très peu de collisions dans la hashmap, et vous pourriez vouloir stocker les données d’une manière encore plus particulière.

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> marketingDepartment = new ArrayList<>();
        marketingDepartment.add("Michael");
        marketingDepartment.add("Alice");
        marketingDepartment.add("Jimmy");

        List<String> developerDepartment = new ArrayList<>();
        developerDepartment.add("Bob");
        developerDepartment.add("John");
        developerDepartment.add("Ryan");

        Map<String, List<String>> company = new HashMap<>();
        company.put("Marketing", marketingDepartment);
        company.put("Development", developerDepartment);

        System.out.println("Company: " + company);
    }
}

Main.java


              1234567891011121314151617181920212223242526272829
            
package com.example;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> marketingDepartment = new ArrayList<>();
        marketingDepartment.add("Michael");
        marketingDepartment.add("Alice");
        marketingDepartment.add("Jimmy");

        List<String> developerDepartment = new ArrayList<>();
        developerDepartment.add("Bob");
        developerDepartment.add("John");
        developerDepartment.add("Ryan");

        Map<String, List<String>> company = new HashMap<>();
        company.put("Marketing", marketingDepartment);
        company.put("Development", developerDepartment);

        System.out.println("Company: " + company);

        String marketerAtIndexOne = company.get("Marketing").get(1);
        System.out.println("Marketer at index 1 is: " + marketerAtIndexOne);
    }
}

À première vue, cela ne semble pas compliqué. Il suffit simplement d'utiliser la méthode une fois de plus. Cependant, en programmation, il est essentiel d'éviter le codage en dur.

Le codage en dur est déconseillé et doit être évité autant que possible. Voici un exemple de codage en dur, que nous allons ensuite corriger ensemble :

Main.java


              123456789101112
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Hardcoded value
        double price = 49.99;

        // Using hardcoded value
        double discountedPrice = price * 0.8; // 20% discount
        System.out.println("Discounted Price: " + discountedPrice);
    }
}

Main.java


              12345678910111213
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Using variables instead of hardcoding
        double price = 49.99;
        double discountPercentage = 0.2; // 20% discount

        // Using variables
        double discountedPrice = price * (1 - discountPercentage);
        System.out.println("Discounted Price: " + discountedPrice);
    }
}

Si la valeur avait été codée en dur, il aurait fallu la modifier à chaque occurrence, ce qui augmente considérablement le temps nécessaire pour améliorer ou modifier le code.

Résumé

Restez vigilant à ce sujet, et votre code sera excellent !

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille `n` et effectue une opération en temps constant sur chaque élément ?

2. Quel est le principal inconvénient du codage en dur des valeurs directement dans le code ?

3. Étant donné deux algorithmes avec des complexités temporelles `O(n log n)` et `O(n^2)`, lequel est généralement plus efficace pour de grandes tailles d’entrée ?

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 4

Map Avec d'Autres Structures de Données

Utilisation de structures de données comme valeurs dans une map

Résumé

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille `n` et effectue une opération en temps constant sur chaque élément ?

2. Quel est le principal inconvénient du codage en dur des valeurs directement dans le code ?

3. Étant donné deux algorithmes avec des complexités temporelles `O(n log n)` et `O(n^2)`, lequel est généralement plus efficace pour de grandes tailles d’entrée ?

Map Avec d'Autres Structures de Données

Utilisation de structures de données comme valeurs dans une map

Résumé

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille `n` et effectue une opération en temps constant sur chaque élément ?

2. Quel est le principal inconvénient du codage en dur des valeurs directement dans le code ?

3. Étant donné deux algorithmes avec des complexités temporelles `O(n log n)` et `O(n^2)`, lequel est généralement plus efficace pour de grandes tailles d’entrée ?

Map Avec d'Autres Structures de Données

Utilisation de structures de données comme valeurs dans une map

Résumé

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille n et effectue une opération en temps constant sur chaque élément ?

2. Quel est le principal inconvénient du codage en dur des valeurs directement dans le code ?

3. Étant donné deux algorithmes avec des complexités temporelles O(n log n) et O(n^2), lequel est généralement plus efficace pour de grandes tailles d’entrée ?

Map Avec d'Autres Structures de Données

Utilisation de structures de données comme valeurs dans une map

Résumé

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille n et effectue une opération en temps constant sur chaque élément ?

2. Quel est le principal inconvénient du codage en dur des valeurs directement dans le code ?

3. Étant donné deux algorithmes avec des complexités temporelles O(n log n) et O(n^2), lequel est généralement plus efficace pour de grandes tailles d’entrée ?

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille `n` et effectue une opération en temps constant sur chaque élément ?

3. Étant donné deux algorithmes avec des complexités temporelles `O(n log n)` et `O(n^2)`, lequel est généralement plus efficace pour de grandes tailles d’entrée ?

1. Quelle est la complexité temporelle d’un algorithme qui parcourt un tableau de taille `n` et effectue une opération en temps constant sur chaque élément ?

3. Étant donné deux algorithmes avec des complexités temporelles `O(n log n)` et `O(n^2)`, lequel est généralement plus efficace pour de grandes tailles d’entrée ?