C # Java HashMap-Entsprechung

Von C # entspricht Java HashMap

Ich brauchte ein Wörterbuch, das einen "Null" -Schlüssel akzeptierte, aber es scheint keinen einheimischen zu geben, also habe ich meinen eigenen geschrieben. Eigentlich ist es sehr einfach. Ich habe von Dictionary geerbt, ein privates Feld für den Wert des Schlüssels "null" hinzugefügt und dann den Indexer überschrieben. Es geht so :

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

Hoffe das hilft jemandem in der Zukunft.

==========

Ich habe es in dieses Format geändert

public class NullableDictionnary : Dictionary<string, object>

Lassen Sie mich Ihnen helfen, es mit einem Beispiel des "Codaddict's Algorithmus" zu verstehen.

' Dictionary in C #' ist ' Hashmap in Java 'im Paralleluniversum.

Einige Implementierungen sind unterschiedlich. Sehen Sie sich das folgende Beispiel an, um es besser zu verstehen.

Deklarieren von Java HashMap:

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

C # -Deklarationswörterbuch:

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

Abrufen eines Werts von einem Standort:

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

Festlegen eines Werts am Standort:

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

Ein Gesamtbeispiel kann aus dem folgenden Codaddict-Algorithmus entnommen werden.

Codaddict's Algorithmus in 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's Algorithmus in 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();
    }
}

Lesen Sie die Dokumentation zu MSDN für die Klasse Hashtable .

Stellt eine Sammlung von Schlüssel-Wert-Paaren dar, die basierend auf dem Hashcode des Schlüssels organisiert sind.

Beachten Sie auch, dass dies nicht threadsicher ist.

Use Dictionary - verwendet Hashtable, ist aber typsicher.

Auch Ihr Java Code für

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

wird am besten in C # folgendermaßen codiert:

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

Auf diese Weise können Sie die Notwendigkeit der Variablen "a" innerhalb eines Blocks einschränken. Sie ist auch außerhalb des Blocks verfügbar, wenn Sie sie später benötigen.

die Antwort ist

Wörterbuch

werfen Sie einen Blick auf meine Funktion, deren einfaches Hinzufügen die wichtigsten Elementfunktionen im Dictionary verwendet

diese Funktion gibt false zurück, wenn die Liste doppelte Elemente enthält

 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
    }

Ich wollte nur meine zwei Cent geben.
Dies entspricht der Antwort von @Powerlord.

Setzt "null" anstelle von null Zeichenfolgen.

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