From C# equivalent to Java HashMap
I needed a Dictionary which accepted a "null" key, but there seems to be no native one, so I have written my own. It's very simple, actually. I inherited from Dictionary, added a private field to hold the value for the "null" key, then overwritten the indexer. It goes like this :
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;
}
}
}
}
Hope this helps someone in the future.
==========
I modified it to this format
public class NullableDictionnary : Dictionary<string, object>
Let me help you understand it with an example of "codaddict's algorithm"
'Dictionary in C#' is 'Hashmap in Java' in parallel universe.
Some implementations are different. See the example below to understand better.
Declaring Java HashMap:
Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
Declaring C# Dictionary:
Dictionary<int, int> Pairs = new Dictionary<int, int>();
Getting a value from a location:
pairs.get(input[i]); // in Java
Pairs[input[i]]; // in C#
Setting a value at location:
pairs.put(k - input[i], input[i]); // in Java
Pairs[k - input[i]] = input[i]; // in C#
An Overall Example can be observed from below Codaddict's algorithm.
codaddict's algorithm 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 algorithm 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();
}
}
the answer is
Dictionary
take look at my function, its simple add uses most important member functions inside Dictionary
this function return false if the list contain Duplicates items
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 Dictionary - it uses hashtable but is typesafe.
Also, your Java code for
int a = map.get(key);
//continue with your logic
will be best coded in C# this way:
int a;
if(dict.TryGetValue(key, out a)){
//continue with your logic
}
This way, you can scope the need of variable "a" inside a block and it is still accessible outside the block if you need it later.
I just wanted to give my two cents.
This is according to @Powerlord 's answer.
Puts "null" instead of null strings.
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");
}
Check out the documentation on MSDN for the Hashtable class.
Represents a collection of key-and-value pairs that are organized based on the hash code of the key.
Also, keep in mind that this is not thread-safe.
Source: Stackoverflow.com