in - C#Java HashMap equivalente




hashtable dictionary (7)

Viniendo de un mundo Java a uno C # uno, ¿hay un equivalente de HashMap? Si no, ¿qué recomendarías?


Answers

Dictionary es probablemente el más cercano. System.Collections.Generic.Dictionary implementa la interfaz System.Collections.Generic.IDictionary (que es similar a la interfaz de Map de Java).

Algunas diferencias notables que debe tener en cuenta:

  • Agregar / Obtener artículos
    • HashMap de Java tiene los métodos de put y get para configurar / obtener elementos
      • myMap.put(key, value)
      • MyObject value = myMap.get(key)
    • El Diccionario de C # usa la indexación [] para configurar / obtener elementos
      • myDictionary[key] = value
      • MyObject value = myDictionary[key]
  • claves null
    • HashMap de Java permite claves nulas
    • El Dictionary de .NET lanza una ArgumentNullException si intenta agregar una clave nula
  • Añadiendo una clave duplicada
    • El HashMap de Java reemplazará el valor existente con el nuevo.
    • El Dictionary de .NET reemplazará el valor existente con el nuevo si usa la indexación [] . Si usa el método Add , en su lugar, lanzará una ArgumentException .
  • Intentando obtener una clave inexistente
    • HashMap de Java devolverá nulo.
    • El Dictionary de .NET lanzará una KeyNotFoundException . Puede usar el método TryGetValue lugar de la indexación [] para evitar esto:
      MyObject value = null; if (!myDictionary.TryGetValue(key, out value)) { /* key doesn't exist */ }

Dictionary tiene un método ContainsKey que puede ayudar a tratar los dos problemas anteriores.


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

' Diccionario en C #' es ' Hashmap en Java' en un 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>();

Declarar el Diccionario C #:

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

Obtención de un valor desde 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#

Se puede observar un ejemplo general desde abajo del 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();
    }
}

la respuesta es

Diccionario

Eche un vistazo a mi función, su simple adición usa 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
    }

Use el diccionario: usa la tabla hash, pero es de tipo seguro.

Además, su código Java para

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

será mejor codificado en C # de esta manera:

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

De esta manera, puede cubrir la necesidad de la variable "a" dentro de un bloque y aún estará accesible fuera del bloque si lo necesita más adelante.


Desde C # equivalente a Java HashMap

Necesitaba un diccionario que aceptara una clave "nula", pero parece que no hay una nativa, así que escribí la mía. Es muy simple, en realidad. Heredé del Diccionario, agregué un campo privado para guardar el valor de la clave "nula" y 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>

Echa un vistazo a la documentación en MSDN para la clase Hashtable .

Representa una colección de pares de clave y valor que se organizan según el código hash de la clave.

Además, tenga en cuenta que esto no es seguro para subprocesos.








c# java hashmap