C# Java équivalent HashMap

Question

En passant d'un monde Java à un monde C#, existe-t-il un équivalent de HashMap ? Sinon, que recommanderiez-vous ?

Answer 1

Dictionary est probablement le plus proche. System.Collections.Generic.Dictionary met en œuvre le System.Collections.Generic.IDictionary (qui est similaire à l'interface Java Map interface).

Quelques différences notables dont vous devez être conscient :

• Ajouter/obtenir des éléments
  • Le HashMap de Java possède la fonction put y get méthodes pour définir/obtenir des éléments
    • myMap.put(key, value)
    • MyObject value = myMap.get(key)
  • Le dictionnaire de C# utilise [] indexation pour la mise en place et l'obtention d'éléments
    • myDictionary[key] = value
    • MyObject value = myDictionary[key]
• null clés
  • Java HashMap autorise les clés nulles
  • .NET Dictionary lance un ArgumentNullException si vous essayez d'ajouter une clé nulle
• Ajout d'une clé dupliquée
  • Java HashMap remplacera la valeur existante par la nouvelle.
  • .NET Dictionary remplacera la valeur existante par la nouvelle si vous utilisez la fonction [] l'indexation. Si vous utilisez le Add il lancera plutôt un ArgumentException .
• Tentative de récupération d'une clé inexistante
  • Java HashMap retournera null.
  • .NET Dictionary lancera un KeyNotFoundException . Vous pouvez utiliser le TryGetValue au lieu de la méthode [] l'indexation pour éviter cela :
    MyObject value = null; if (!myDictionary.TryGetValue(key, out value)) { /* key doesn't exist */ }

Dictionary a une ContainsKey qui peut aider à résoudre les deux problèmes précédents.

Answer 2

De L'équivalent en C# du HashMap de Java

J'avais besoin d'un dictionnaire qui accepte une clé "null", mais il semble qu'il n'y en ait pas de natif, alors j'ai écrit le mien. C'est très simple, en fait. J'ai hérité de Dictionary, ajouté un champ privé pour contenir la valeur de la clé "null", puis écrasé l'indexeur. Cela se passe comme suit :

public class NullableDictionnary : Dictionary<string, string>
{
    string null_value;

    public StringDictionary this[string key]
    {
        get
        {
            if (key == null) 
            {
                return null_value;
            }
            return base[key];
        }
        set
        {
            if (key == null)
            {
                null_value = value;
            }
            else 
            {
                base[key] = value;
            }
        }
    }
}

J'espère que cela aidera quelqu'un à l'avenir.

\==========

Je l'ai modifié dans ce format

public class NullableDictionnary : Dictionary<string, object>

Answer 3

Laissez-moi vous aider à le comprendre avec un exemple de "l'algorithme du codaddict".

' Dictionnaire en C# " est Hashmap en Java' dans un univers parallèle.

Certaines mises en œuvre sont différentes. Voir l'exemple ci-dessous pour mieux comprendre.

Déclarer un HashMap Java :

Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();

Déclarer un dictionnaire C# :

Dictionary<int, int> Pairs = new Dictionary<int, int>();

Obtenir une valeur à partir d'un emplacement :

pairs.get(input[i]); // in Java
Pairs[input[i]];     // in C#

Définition d'une valeur à l'emplacement :

pairs.put(k - input[i], input[i]); // in Java
Pairs[k - input[i]] = input[i];    // in C#

Un exemple général peut être observé à partir de l'algorithme de Codaddict ci-dessous.

L'algorithme du codaddict en Java :

import java.util.HashMap;

public class ArrayPairSum {

    public static void printSumPairs(int[] input, int k)
    {
        Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();

        for (int i = 0; i < input.length; i++)
        {
            if (pairs.containsKey(input[i]))
                System.out.println(input[i] + ", " + pairs.get(input[i]));
            else
                pairs.put(k - input[i], input[i]);
        }

    }

    public static void main(String[] args)
    {
        int[] a = { 2, 45, 7, 3, 5, 1, 8, 9 };
        printSumPairs(a, 10);

    }
}

L'algorithme du Codaddict en C#

using System;
using System.Collections.Generic;

class Program
{
    static void checkPairs(int[] input, int k)
    {
        Dictionary<int, int> Pairs = new Dictionary<int, int>();

        for (int i = 0; i < input.Length; i++)
        {
            if (Pairs.ContainsKey(input[i]))
            {
                Console.WriteLine(input[i] + ", " + Pairs[input[i]]);
            }
            else
            {
                Pairs[k - input[i]] = input[i];
            }
        }
    }
    static void Main(string[] args)
    {
        int[] a = { 2, 45, 7, 3, 5, 1, 8, 9 };
        //method : codaddict's algorithm : O(n)
        checkPairs(a, 10);
        Console.Read();
    }
}

Answer 4

Utilisez le dictionnaire - il utilise le hashtable mais est sûr pour les types.

De même, votre code Java pour

int a = map.get(key);
//continue with your logic

sera mieux codé en C# de cette façon :

int a;
if(dict.TryGetValue(key, out a)){
//continue with your logic
}

De cette façon, vous pouvez délimiter le besoin de la variable "a" à l'intérieur d'un bloc et elle est toujours accessible à l'extérieur du bloc si vous en avez besoin plus tard.

Answer 5

Consultez la documentation sur MSDN pour l'option Table de hachage classe.

Représente une collection de paires clé-valeur qui sont organisées en fonction du code de hachage de la clé.

Gardez également à l'esprit que cette méthode n'est pas à l'abri des conflits.