Comment utiliser la fonction EnumMap en Java pour les opérations de mappage d'énumération

En Java, le type Enum est un type de données très utile qui peut être utilisé pour représenter des constantes d'énumération. EnumMap est une implémentation Map spéciale en Java, qui ne peut stocker que des paires clé-valeur de type Enum. Dans cet article, je présenterai l'utilisation de la fonction EnumMap et comment utiliser EnumMap en Java pour les opérations de mappage d'énumération.

1. Utilisation de base de la fonction EnumMap

EnumMapa5e7c98c969bd6191bb56b66ed1bff18, V> est une classe générique en Java, où K représente la clé du type d'énumération et V représente la valeur mappée à la clé. Une fois qu'un EnumMap est créé, ses clés doivent provenir du même type d'énumération et toutes les valeurs doivent être du même type. Voici l'utilisation de base de la fonction EnumMap :

EnumMap<Weekday, String> enumMap = new EnumMap<>(Weekday.class);
enumMap.put(Weekday.MONDAY, "星期一");
enumMap.put(Weekday.TUESDAY, "星期二");
enumMap.put(Weekday.WEDNESDAY, "星期三");
enumMap.put(Weekday.THURSDAY, "星期四");
enumMap.put(Weekday.FRIDAY, "星期五");
enumMap.put(Weekday.SATURDAY, "星期六");
enumMap.put(Weekday.SUNDAY, "星期日");

Nous avons d'abord créé un objet EnumMap enumMap et stocké chaque jour de la semaine et le nom chinois correspondant dans EnumMap via la méthode put dans EnumMap. De cette façon, nous avons terminé la création et l’initialisation d’un EnumMap de base.

2. Initialisation de la fonction EnumMap

Dans l'exemple de code ci-dessus, nous utilisons le constructeur par défaut d'EnumMap, qui initialisera automatiquement toutes les valeurs à null. En fait, nous pouvons également utiliser un autre constructeur d'EnumMap pour l'initialisation. Ce constructeur définira une valeur initiale et initialisera toutes les valeurs de l'EnumMap à cette valeur initiale. Voici l'exemple de code d'initialisation de la fonction EnumMap :

EnumMap<Weekday, String> enumMap = new EnumMap<>(Weekday.class);
enumMap.put(Weekday.MONDAY, "星期一");
enumMap.put(Weekday.TUESDAY, "星期二");
enumMap.put(Weekday.WEDNESDAY, "星期三");
enumMap.put(Weekday.THURSDAY, "星期四");
enumMap.put(Weekday.FRIDAY, "星期五");
enumMap.put(Weekday.SATURDAY, "星期六");
enumMap.put(Weekday.SUNDAY, "星期日");

// 使用初始化值，将所有键值对的值都设置为"假期" 
EnumMap defaultEnumMap = new EnumMap<>(Weekday.class);
defaultEnumMap.putAll(Collections.singletonMap(null, "假期"));
EnumMap enumMapWithDefaultValue = new EnumMap<>(defaultEnumMap);
enumMapWithDefaultValue.putAll(enumMap);

Dans l'exemple de code ci-dessus, nous avons utilisé la méthode Collections.singletonMap pour créer une carte contenant une seule paire clé-valeur, dont la clé est nulle et dont la valeur est "vacances ". Ensuite, nous utilisons cette carte comme valeur initiale, créons un nouvel objet EnumMap enumMapWithDefaultValue et copions les paires clé-valeur dans l'enumMap précédemment créé dans ce nouvel objet EnumMap.

Cet exemple de code nous permet de comprendre comment utiliser le constructeur d'EnumMap pour initialiser, et comment utiliser une autre Map comme valeur initiale pour créer un nouvel EnumMap.

3. Parcours de la fonction EnumMap

Le parcours de tous les éléments dans EnumMap est généralement une opération essentielle. Nous pouvons utiliser des itérateurs en Java pour réaliser cette opération. Voici un exemple de code pour parcourir EnumMap :

EnumMap<Weekday, String> enumMap = new EnumMap<>(Weekday.class);
enumMap.put(Weekday.MONDAY, "星期一");
enumMap.put(Weekday.TUESDAY, "星期二");
enumMap.put(Weekday.WEDNESDAY, "星期三");
enumMap.put(Weekday.THURSDAY, "星期四");
enumMap.put(Weekday.FRIDAY, "星期五");
enumMap.put(Weekday.SATURDAY, "星期六");
enumMap.put(Weekday.SUNDAY, "星期日");

// 使用迭代器遍历EnumMap中的所有键值对
Iterator> iterator = enumMap.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry entry = iterator.next();
    Weekday key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + ": " + value);
}

// 使用foreach循环遍历EnumMap中的所有值
for (String value : enumMap.values()) {
    System.out.println(value);
}

Dans cet exemple de code, nous utilisons des itérateurs en Java pour parcourir toutes les paires clé-valeur dans EnumMap. Nous obtenons d’abord le EntrySet de EnumMap, puis utilisons l’itérateur renvoyé par EntrySet pour parcourir toutes les paires clé-valeur en séquence. Pour chaque paire clé-valeur, nous utilisons la méthode getKey pour obtenir la clé et la méthode getValue pour obtenir la valeur et les afficher sur la console.

Nous pouvons également utiliser une boucle foreach pour parcourir toutes les valeurs de l'EnumMap. Utilisez simplement le type d'énumération comme clé pour obtenir la valeur. Cette méthode peut nous éviter d'utiliser fréquemment la méthode getKey pour obtenir la clé.

4. Applications pratiques de la fonction EnumMap

En plus de l'utilisation de base présentée ci-dessus, la fonction EnumMap propose de nombreux scénarios d'application pratiques.

4.1 Opérations de mappage d'énumération

L'utilisation la plus courante d'EnumMap est de mapper les types d'énumération à d'autres valeurs. Par exemple, dans l'exemple de code suivant, nous mappons le type d'énumération Weekday à un nombre (0-6) :

public enum Weekday {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

// 使用EnumMap将Weekday枚举映射到数字
EnumMap<Weekday, Integer> enumMap = new EnumMap<>(Weekday.class);
enumMap.put(Weekday.MONDAY, 0);
enumMap.put(Weekday.TUESDAY, 1);
enumMap.put(Weekday.WEDNESDAY, 2);
enumMap.put(Weekday.THURSDAY, 3);
enumMap.put(Weekday.FRIDAY, 4);
enumMap.put(Weekday.SATURDAY, 5);
enumMap.put(Weekday.SUNDAY, 6);

4.2 Compteur de type d'énumération

Dans certains cas, nous devons implémenter un compteur pour compter une certaine quantité de type d'énumération . EnumMap peut facilement implémenter cette fonction. L'exemple de code est le suivant :

public enum Gender {
    MALE, FEMALE
}

// 使用EnumMap实现枚举类型计数器
EnumMap<Gender, Integer> genderCount = new EnumMap<>(Gender.class);
genderCount.put(Gender.MALE, 0);
genderCount.put(Gender.FEMALE, 0);

List<Gender> genderList = Arrays.asList(
    Gender.MALE, 
    Gender.MALE, 
    Gender.MALE, 
    Gender.FEMALE, 
    Gender.FEMALE
);

for (Gender gender : genderList) {
    genderCount.put(gender, genderCount.get(gender) + 1);
}

System.out.println("男性数量：" + genderCount.get(Gender.MALE));
System.out.println("女性数量：" + genderCount.get(Gender.FEMALE));

Dans l'exemple de code ci-dessus, nous avons d'abord créé un objet EnumMap GenderCount pour enregistrer le nombre de types de genre. Ensuite, nous utilisons la méthode put dans EnumMap pour initialiser le numéro de chaque type Gender à 0. Ensuite, nous utilisons une liste pour simuler la liste de genre et parcourons la liste pour compter le nombre de fois où chaque genre apparaît. Enfin, nous obtenons le nombre d'hommes et de femmes.

4.3 Calculateur de type d'énumération

Semblable au compteur de type d'énumération, EnumMap peut également être utilisé pour implémenter l'addition et la soustraction de types d'énumération. Par exemple, dans l'exemple de code suivant, nous avons implémenté une calculatrice simple pour compter le nombre de fois qu'une certaine lettre anglaise apparaît dans un certain mot :

public enum Letter {
    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z
}

// 使用EnumMap实现枚举类型计算器
EnumMap<Letter, Integer> letterCount = new EnumMap<>(Letter.class);
for (Letter letter : Letter.values()) {
    letterCount.put(letter, 0);
}

String word = "Hello, World!";
for (int i = 0; i < word.length(); i++) {
    char c = word.charAt(i);
    if (c >= 'A' && c <= 'Z') {
        Letter letter = Letter.valueOf(String.valueOf(c));
        letterCount.put(letter, letterCount.get(letter) + 1);
    }
}

for (Letter letter : Letter.values()) {
    if (letterCount.get(letter) > 0) {
        System.out.println(letter + ": " + letterCount.get(letter));
    }
}

Dans l'exemple de code ci-dessus, nous avons d'abord créé un objet EnumMap letterCount , utilisé pour enregistrer le nombre de fois que chaque lettre apparaît. Nous utilisons ensuite une boucle for pour parcourir le type d'énumération Letter, en définissant la valeur initiale de chaque lettre sur 0. Ensuite, nous avons défini une chaîne de mots pour simuler des mots. Nous parcourons chaque caractère du mot et déterminons s’il s’agit d’une lettre majuscule. S'il s'agit d'une lettre majuscule, nous utilisons la méthode Letter.valueOf pour la convertir en type Letter et accumulons le nombre correspondant de types de lettres dans letterCount. Enfin, nous parcourons le type d'énumération Letter et affichons les lettres dont les occurrences sont supérieures à 0 et les heures correspondantes.

Résumé

Dans cet article, nous avons présenté l'utilisation de base, l'initialisation, le parcours, l'application pratique, etc. de la fonction EnumMap. EnumMap est une implémentation de Map très pratique en Java. Elle peut être utilisée avec le type Enum pour implémenter le mappage d'énumération, les statistiques de type énumération, les calculatrices et d'autres applications. Maîtriser l'utilisation d'EnumMap contribuera à améliorer l'efficacité du développement et la qualité du code des programmes Java.

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!