C # Java HashMap equivalente

De C# equivalente a Java HashMap

Necesitaba un Diccionario que aceptara una clave "null", pero parece que no hay una nativa, así que he escrito la mía. Es muy simple, en realidad. Heredé del Diccionario, agregué un campo privado para mantener el valor de la clave" null", luego sobrescribí el indexador. Dice así:

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

Espero que esto ayude a alguien en el futuro.

==========

Lo modifiqué a este formato

public class NullableDictionnary : Dictionary<string, object>

Déjame ayudarte a entenderlo con un ejemplo de "algoritmo de codaddict"

'Diccionario en C# es 'Hashmap en Java " en el universo paralelo.

Algunas implementaciones son diferentes. Vea el ejemplo a continuación para entender mejor.

Declarando Java HashMap:

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

Declarando el Diccionario C#:

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

Obtener un valor de una ubicación:

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

Establecer un valor en la ubicación:

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

An General Ejemplo se puede observar desde abajo algoritmo de Codaddict.

El algoritmo 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);

    }
}

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

Consulte la documentación de MSDN para la clase Hashtable.

Representa una colección de pares clave y valor que se organizan en función del código hash de la clave.

También, tenga en cuenta que esto no es seguro para el hilo.

Use Dictionary - usa hashtable pero es typesafe.

También, su código Java para

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

Se codificará mejor en C # de esta manera:

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

De esta manera, puede abarcar la necesidad de la variable "a" dentro de un bloque y todavía es accesible fuera del bloque si la necesita más tarde.

La respuesta es

Diccionario

Echa un vistazo a mi función, su simple add utiliza las funciones miembro más importantes dentro del Diccionario

Esta función devuelve false si la lista contiene elementos Duplicados

 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
    }

Solo quería dar mis dos centavos.
Esto es de acuerdo con la respuesta de @Powerlord.

Pone "null" en lugar de null cadenas.

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