web-dev-qa-db-fra.com

C # Java équivalent HashMap

Venant d’un monde Java vers un monde C #, existe-t-il un équivalent de HashMap? Sinon, que recommanderiez-vous?

c#javahashmap
297
John

Dictionary est probablement le plus proche. _System.Collections.Generic.Dictionary_ implémente l'interface System.Collections.Generic.IDictionary (similaire à l'interface Map de Java).

Quelques différences notables que vous devriez connaître:

  • Ajouter/récupérer des objets
    • HashMap de Java a les méthodes put et get pour définir/obtenir des éléments
      • myMap.put(key, value)
      • MyObject value = myMap.get(key)
    • Le dictionnaire de C # utilise _[]_ indexation pour définir/obtenir des éléments
      • _myDictionary[key] = value_
      • _MyObject value = myDictionary[key]_
  • null clés
    • HashMap de Java autorise les clés nulles
    • Dictionary de .NET lève un ArgumentNullException si vous essayez d'ajouter une clé null
  • Ajouter une clé en double
    • HashMap de Java remplacera la valeur existante par la nouvelle.
    • Dictionary de .NET remplacera la valeur existante par la nouvelle si vous utilisez l'indexation _[]_. Si vous utilisez la méthode Add, il lancera plutôt un ArgumentException.
  • Tentative d’obtenir une clé inexistante
    • HashMap de Java retournera null.
    • Dictionary de .NET lancera un KeyNotFoundException. Vous pouvez utiliser la méthode TryGetValue au lieu de l'indexation _[]_ pour éviter ceci:
      MyObject value = null; if (!myDictionary.TryGetValue(key, out value)) { /* key doesn't exist */ }

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

441
Powerlord

De équivalent de C # à Java HashMap

J'avais besoin d'un dictionnaire qui acceptait une clé "nulle", mais il ne semble pas exister de clé native, j'ai donc écrit la mienne. 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. Ça va comme ça :

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 dans le futur.

==========

Je l'ai modifié à ce format

public class NullableDictionnary : Dictionary<string, object>
37
KeithC

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

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

Certaines implémentations sont différentes. Voir l'exemple ci-dessous pour mieux comprendre.

Déclaration de Java HashMap:

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

Déclaration du dictionnaire C #:

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

Obtenir une valeur d'un lieu:

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

Définir une valeur à l'emplacement:

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

Un exemple global peut être observé de dessous l'algorithme de Codaddict.

l'algorithme de 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);

    }
}

algorithme de 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();
    }
}
13
Ajay Yadiki

Consultez la documentation sur MSDN pour la classe Hashtable .

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

Aussi, gardez à l'esprit que ce n'est pas thread-safe.

5
Ray

Use Dictionary - il utilise hashtable mais est protégé par typesafe.

De plus, 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éfinir la nécessité de la variable "a" dans un bloc et elle est toujours accessible en dehors du bloc si vous en avez besoin ultérieurement.

2
Shree Harsha

la réponse est

Dictionnaire

jetez un oeil à ma fonction, son simple ajout utilise les fonctions les plus importantes dans le dictionnaire

cette fonction retourne false si la liste contient des éléments en double

 public static bool HasDuplicates<T>(IList<T> items)
    {
        Dictionary<T, bool> mp = new Dictionary<T, bool>();
        for (int i = 0; i < items.Count; i++)
        {
            if (mp.ContainsKey(items[i]))
            {
                return true; // has duplicates
            }
            mp.Add(items[i], true);
        }
        return false; // no duplicates
    }
0
Basheer AL-MOMANI

Je voulais juste donner mes deux cents.
Cela correspond à la réponse de @Powerlord.

Met "null" au lieu de null chaînes.

private static Dictionary<string, string> map = new Dictionary<string, string>();

public static void put(string key, string value)
{
    if (value == null) value = "null";
    map[key] = value;
}

public static string get(string key, string defaultValue)
{
    try
    {
        return map[key];
    }
    catch (KeyNotFoundException e)
    {
        return defaultValue;
    }
}

public static string get(string key)
{
    return get(key, "null");
}
0
ossobuko