Équivalent HashMap Java C #

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

Dictionaryest probablement le plus proche. System.Collections.Generic.Dictionaryimplémente l' System.Collections.Generic.IDictionaryinterface (qui est similaire à l' Mapinterface de Java ).

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

• Ajouter / récupérer des éléments
  • HashMap de Java a les méthodes putet getpour définir / obtenir des éléments
    • myMap.put(key, value)
    • MyObject value = myMap.get(key)
  • Le dictionnaire de C # utilise l' []indexation pour définir / obtenir des éléments
    • myDictionary[key] = value
    • MyObject value = myDictionary[key]
• null clés
  • Java HashMapautorise les clés nulles
  • .NET Dictionarylance un ArgumentNullExceptionsi vous essayez d'ajouter une clé nulle
• Ajout d'une clé en double
  • Java's HashMapremplacera la valeur existante par la nouvelle.
  • Les .NET Dictionaryremplaceront la valeur existante par la nouvelle si vous utilisez l' []indexation. Si vous utilisez la Addméthode, elle lancera un an ArgumentException.
• Tentative d'obtention d'une clé inexistante
  • Java HashMapretournera null.
  • .NET Dictionaryva lancer un KeyNotFoundException. Vous pouvez utiliser la TryGetValueméthode au lieu de l' []indexation pour éviter cela:
    MyObject value = null; if (!myDictionary.TryGetValue(key, out value)) { /* key doesn't exist */ }

Dictionarya une ContainsKeyméthode qui peut aider à résoudre les deux problèmes précédents.

De l' équivalent C # à Java HashMap

J'avais besoin d'un dictionnaire qui acceptait une clé "nulle", mais il ne semble pas y en avoir de natif, j'ai donc é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. Ç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 à l'avenir.

==========

Je l'ai modifié dans ce format

public class NullableDictionnary : Dictionary<string, object>

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

' Dictionary in C #' est ' Hashmap in Java' dans l'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 à 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 global peut être observé sous l'algorithme de Codaddict.

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();
    }
}

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é.

N'oubliez pas non plus que ce n'est pas thread-safe.

Utiliser le dictionnaire - il utilise une table de hachage mais est sûr pour les types.

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 le besoin de la variable "a" à l'intérieur d'un bloc et elle est toujours accessible en dehors du bloc si vous en avez besoin plus tard.

la réponse est

dictionnaire

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

cette fonction renvoie 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
    }

Je voulais juste donner mes deux cents.
C'est selon la réponse de @Powerlord.

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

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");
}