C# Java HashMap équivalent

Dictionnaire est probablement le plus proche. System.Collections.Generic.Dictionary met en œuvre la System.Les Collections.Génériques.IDictionary de l'interface (qui est similaire à Java Map interface).

Quelques différences notables que vous devriez être au courant:

• Ajout de/pour Obtenir des éléments de
  • De Java HashMap a la put et get méthodes de réglage/mise éléments
    • myMap.put(key, value)
    • MyObject value = myMap.get(key)
  • C#Dictionnaire utilise [] d'indexation pour le réglage/mise éléments
    • myDictionary[key] = value
    • MyObject value = myDictionary[key]
• null clés
  • De Java HashMap permet clés null
  • .NET Dictionary jette un ArgumentNullException si vous essayez d'ajouter une clé null
• L'ajout d'un double de la clé
  • De Java HashMap va remplacer la valeur existante par la nouvelle.
  • .NET Dictionary va remplacer la valeur existante par la nouvelle si vous utilisez [] d'indexation. Si vous utilisez le Add méthode, qu'il va plutôt jeter un ArgumentException.
• Tentez d'obtenir une inexistant clé
  • De Java HashMap retournera null.
  • .NET Dictionary va jeter un KeyNotFoundException. Vous pouvez utiliser le TryGetValue méthode au lieu de la [] d'indexation pour éviter cela:
    
    MyObject value = null;
if (!myDictionary.TryGetValue(key, out value)) { /* key doesn't exist */}

Dictionary's a une ContainsKey méthode qui peut vous aider à composer avec les deux précédents problèmes.

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

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

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

Déclarant Java HashMap:

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

Déclarant C# Dictionnaire:

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

L'obtention d'une valeur à partir d'un emplacement:

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

La définition de la valeur à l'emplacement:

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

Global d'un Exemple peut être observée à partir de ci-dessous Codaddict de l'algorithme.

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

    }
}

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

Utilisation du Dictionnaire - il utilise la table de hachage, mais est typesafe.

Aussi, 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 la portée de la nécessité de la variable "a" à l'intérieur d'un bloc et il est toujours accessible à l'extérieur du bloc si vous en avez besoin plus tard.

Je voulais juste donner mon grain de sel.

C'est selon @Powerlord 's réponse.

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