如果给定了一组静态对象（静态的，一旦加载就很少加载，就意味着它永远不会变化），需要在其中进行重复并发查找以达到最佳性能，更好的情况是，HashMap还是使用某些自定义比较器进行二进制搜索的数组？
答案是对象还是结构类型的函数？哈希和/或相等函数性能？哈希唯一性？清单大小？ Hashset尺寸/布景尺寸？
我正在查看的布景大小可以在500k到10m之间，以防信息有用。
当我在寻找C＃答案时，我认为真正的数学答案不在于语言，因此我不包含该标签。但是，如果有C＃特定的事情要注意，则需要该信息。
Answers:
好吧，我会尽量简短。
C＃简短答案：
测试两种不同的方法。
.NET为您提供了通过一行代码来更改方法的工具。否则，请使用System.Collections.Generic.Dictionary，并确保将其初始化为大容量作为初始容量，否则，由于GC必须执行收集旧存储桶阵列的工作，因此您将在余下的时间里插入项目。
更长的答案：
哈希表具有ALMOST恒定的查找时间，并且在现实世界中访问哈希表中的项目并不仅仅需要计算哈希。
要获得某项，您的哈希表将执行以下操作：
查找时间取决于散列函数的“良好”程度（输出的稀疏程度）和快速程度，所使用的存储桶数以及键比较器的速度如何，这并不总是最佳的解决方案。
更好更深入的解释：http : //en.wikipedia.org/wiki/Hash_table
对于非常小的馆藏，差异将可忽略不计。如果您要进行大量查找，则在范围的低端（500k项），您会开始发现差异。二进制搜索将为O（log n），而哈希查找将为O（1），分期偿还。这与真正的常数并不相同，但是您仍然必须拥有一个非常糟糕的哈希函数才能获得比二进制搜索更差的性能。
（当我说“可怕的哈希”时，我的意思是：
hashCode()
{
return 0;
}
是的，它本身速度很快，但是会导致您的哈希映射成为链接列表。）
ialiashkevich使用数组和Dictionary编写了一些C＃代码，以比较这两种方法，但是它使用Long值作为键。我想测试在查找过程中实际执行哈希函数的内容，因此我修改了该代码。我将其更改为使用String值，并且将填充和查找部分重构为它们自己的方法，因此更容易在事件探查器中查看。作为比较，我还留了使用Long值的代码。最后，我摆脱了自定义二进制搜索功能，并在Array类中使用了该功能。
这是代码：
class Program
{
private const long capacity = 10_000_000;
private static void Main(string[] args)
{
testLongValues();
Console.WriteLine();
testStringValues();
Console.ReadLine();
}
private static void testStringValues()
{
Dictionary<String, String> dict = new Dictionary<String, String>();
String[] arr = new String[capacity];
Stopwatch stopwatch = new Stopwatch();
Console.WriteLine("" + capacity + " String values...");
stopwatch.Start();
populateStringArray(arr);
stopwatch.Stop();
Console.WriteLine("Populate String Array: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
populateStringDictionary(dict, arr);
stopwatch.Stop();
Console.WriteLine("Populate String Dictionary: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
Array.Sort(arr);
stopwatch.Stop();
Console.WriteLine("Sort String Array: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
searchStringDictionary(dict, arr);
stopwatch.Stop();
Console.WriteLine("Search String Dictionary: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
searchStringArray(arr);
stopwatch.Stop();
Console.WriteLine("Search String Array: " + stopwatch.ElapsedMilliseconds);
}
/* Populate an array with random values. */
private static void populateStringArray(String[] arr)
{
for (long i = 0; i < capacity; i++)
{
arr[i] = generateRandomString(20) + i; // concatenate i to guarantee uniqueness
}
}
/* Populate a dictionary with values from an array. */
private static void populateStringDictionary(Dictionary<String, String> dict, String[] arr)
{
for (long i = 0; i < capacity; i++)
{
dict.Add(arr[i], arr[i]);
}
}
/* Search a Dictionary for each value in an array. */
private static void searchStringDictionary(Dictionary<String, String> dict, String[] arr)
{
for (long i = 0; i < capacity; i++)
{
String value = dict[arr[i]];
}
}
/* Do a binary search for each value in an array. */
private static void searchStringArray(String[] arr)
{
for (long i = 0; i < capacity; i++)
{
int index = Array.BinarySearch(arr, arr[i]);
}
}
private static void testLongValues()
{
Dictionary<long, long> dict = new Dictionary<long, long>(Int16.MaxValue);
long[] arr = new long[capacity];
Stopwatch stopwatch = new Stopwatch();
Console.WriteLine("" + capacity + " Long values...");
stopwatch.Start();
populateLongDictionary(dict);
stopwatch.Stop();
Console.WriteLine("Populate Long Dictionary: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
populateLongArray(arr);
stopwatch.Stop();
Console.WriteLine("Populate Long Array: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
searchLongDictionary(dict);
stopwatch.Stop();
Console.WriteLine("Search Long Dictionary: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
searchLongArray(arr);
stopwatch.Stop();
Console.WriteLine("Search Long Array: " + stopwatch.ElapsedMilliseconds);
}
/* Populate an array with long values. */
private static void populateLongArray(long[] arr)
{
for (long i = 0; i < capacity; i++)
{
arr[i] = i;
}
}
/* Populate a dictionary with long key/value pairs. */
private static void populateLongDictionary(Dictionary<long, long> dict)
{
for (long i = 0; i < capacity; i++)
{
dict.Add(i, i);
}
}
/* Search a Dictionary for each value in a range. */
private static void searchLongDictionary(Dictionary<long, long> dict)
{
for (long i = 0; i < capacity; i++)
{
long value = dict[i];
}
}
/* Do a binary search for each value in an array. */
private static void searchLongArray(long[] arr)
{
for (long i = 0; i < capacity; i++)
{
int index = Array.BinarySearch(arr, arr[i]);
}
}
/**
* Generate a random string of a given length.
* Implementation from https://stackoverflow.com/a/1344258/1288
*/
private static String generateRandomString(int length)
{
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
var stringChars = new char[length];
var random = new Random();
for (int i = 0; i < stringChars.Length; i++)
{
stringChars[i] = chars[random.Next(chars.Length)];
}
return new String(stringChars);
}
}
以下是几种不同大小的集合的结果。（时间以毫秒为单位。）
500000长值...
填充长字典：26
填充长数组：2
搜索长字典：9
搜索长数组：80500000字符串值...
填充字符串数组：1237
填充字符串字典：46
排序字符串数组：1755
搜索字符串字典：27
搜索字符串数组：15691000000长值...
填充长字典：58
填充长数组：5
搜索长字典：23
搜索长数组：1361000000字符串值...
填充字符串数组：2070
填充字符串字典：121
排序字符串数组：3579
搜索字符串字典：58
搜索字符串数组：32673000000长值...
填充长字典：207
填充长数组：14
搜索长字典：75
搜索长数组：4353000000字符串值...
填充字符串数组：5553
填充字符串字典：449
排序字符串数组：11695
搜索字符串字典：194
搜索字符串数组：1059410000000长值...
填充长字典：521
填充长数组：47
搜索长字典：202
搜索长数组：118110000000字符串值...
填充字符串数组：18119
填充字符串字典：1088
排序字符串数组：28174
搜索字符串字典：747
搜索字符串数组：26503
为了进行比较，以下是该程序的最后一次运行的探查器输出（1000万个记录和查找）。我重点介绍了相关功能。他们与上述秒表计时指标非常吻合。
您可以看到字典查找比二进制搜索快得多，并且（如预期的那样）集合越大，差异就越明显。因此，如果您具有合理的散列功能（相当快且几乎没有冲突），则散列查找应胜过二进制搜索此范围内的集合。
Bobby，Bill和Corbin的答案是错误的。对于固定/有界n，O（1）不比O（log n）慢：
log（n）是常数，因此它取决于常数时间。
对于慢速哈希函数，有没有听说过md5？
默认的字符串哈希算法可能会触及所有字符，并且很容易比长字符串键的平均比较慢100倍。去过也做过。
您可能可以（部分）使用基数。如果您可以分成256个大致相同大小的块，那么您正在寻找2k到40k的二进制搜索。这可能会提供更好的性能。
[编辑]太多的人投票反对他们不了解的内容。
用于二进制搜索的字符串比较排序集具有一个非常有趣的属性：它们越接近目标，速度就越慢。首先，他们将打破第一个角色，最后只有最后一个角色。假设他们的时间固定是不正确的。
这个问题的唯一合理答案是：这取决于。它取决于数据的大小，数据的形状，哈希实现，二进制搜索实现以及数据的存放位置（即使问题中未提及）。其他几个答案也可以这么说，所以我可以删除它。但是，最好将我从反馈中学到的知识分享给我的原始答案。
给定这些注释，您可能会假设使用哈希表的人员处于混乱状态。哈希表鲁re和危险吗？这些人疯了吗？
原来他们不是。正如二叉树擅长某些事情（顺序数据遍历，存储效率）一样，哈希表也有自己的亮点。特别是，它们可以很好地减少获取数据所需的读取次数。散列算法可以生成一个位置，然后直接在内存或磁盘中跳转到该位置，而二进制搜索则在每次比较期间读取数据以确定下一步要读取什么。每次读取都有可能导致高速缓存未命中，它比CPU指令慢一个数量级（或更多）。
这并不是说哈希表比二进制搜索更好。他们不是。也不建议所有哈希和二进制搜索实现都相同。他们不是。如果我有观点，就是这样：两种方法都存在是有原因的。由您决定哪个最适合您的需求。
原始答案：
哈希算法为O（1），而二进制搜索为O（log n）。因此，当n接近无穷大时，散列性能相对于二进制搜索有所提高。您的里程取决于n，哈希实现和二进制搜索实现。
关于O（1）的有趣讨论。释义：
O（1）并不是瞬时的。这意味着性能不会随着n大小的增长而改变。您可以设计一种哈希算法，这种算法是如此之慢，没人会使用它，而它仍然是O（1）。我相当确定.NET / C＃不会遭受成本过高的哈希处理；但是）
尽管二进制搜索具有更好的最坏情况特征，但哈希通常更快。哈希访问通常是一种获取哈希值以确定记录将位于哪个“存储桶”的计算，因此性能通常取决于记录的分布均匀程度以及用于搜索存储桶的方法。不好的哈希函数（会留下几个带有大量记录的存储桶）以及对存储桶进行线性搜索会导致搜索缓慢。（第三，如果您正在读取磁盘而不是内存，则散列存储区可能是连续的，而二叉树几乎可以保证非本地访问。）
如果通常需要快速，请使用哈希。如果您确实想要保证有限的性能，则可以使用二叉树。
没有人惊讶地提到Cuckoo散列，它提供有保证的O（1），并且与完美散列不同，它能够使用它分配的所有内存，因为完美散列最终可以保证有O（1），但浪费了它的大部分分配。警告？插入时间可能非常慢，尤其是随着元素数量的增加，因为所有优化都在插入阶段执行。
我相信此版本的某些版本会在路由器硬件中用于ip查找。
查看链接文字
与数组相比，字典/哈希表正在使用更多的内存，并且需要花费更多的时间来填充。但是通过字典而不是数组内的二进制搜索可以更快地完成搜索。
这是一千万个Int64的数字要搜索和填充的项目。加上示例代码，您可以自己运行。
词典记忆： 462,836
阵列记忆体： 88,376
填充字典：402
填充数组： 23
搜索词典： 176
搜索数组： 680
using System;
using System.Collections.Generic;
using System.Diagnostics;
namespace BinaryVsDictionary
{
internal class Program
{
private const long Capacity = 10000000;
private static readonly Dictionary<long, long> Dict = new Dictionary<long, long>(Int16.MaxValue);
private static readonly long[] Arr = new long[Capacity];
private static void Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (long i = 0; i < Capacity; i++)
{
Dict.Add(i, i);
}
stopwatch.Stop();
Console.WriteLine("Populate Dictionary: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
for (long i = 0; i < Capacity; i++)
{
Arr[i] = i;
}
stopwatch.Stop();
Console.WriteLine("Populate Array: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
for (long i = 0; i < Capacity; i++)
{
long value = Dict[i];
// Console.WriteLine(value + " : " + RandomNumbers[i]);
}
stopwatch.Stop();
Console.WriteLine("Search Dictionary: " + stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
for (long i = 0; i < Capacity; i++)
{
long value = BinarySearch(Arr, 0, Capacity, i);
// Console.WriteLine(value + " : " + RandomNumbers[i]);
}
stopwatch.Stop();
Console.WriteLine("Search Array: " + stopwatch.ElapsedMilliseconds);
Console.ReadLine();
}
private static long BinarySearch(long[] arr, long low, long hi, long value)
{
while (low <= hi)
{
long median = low + ((hi - low) >> 1);
if (arr[median] == value)
{
return median;
}
if (arr[median] < value)
{
low = median + 1;
}
else
{
hi = median - 1;
}
}
return ~low;
}
}
}
我强烈怀疑在大小约为1M的问题集中，散列会更快。
只为数字：
二进制搜索将需要〜20个比较（2 ^ 20 == 1M）
哈希查找将需要对搜索关键字进行1次哈希计算，之后可能需要进行少量比较以解决可能的冲突
编辑：数字：
for (int i = 0; i < 1000 * 1000; i++) {
c.GetHashCode();
}
for (int i = 0; i < 1000 * 1000; i++) {
for (int j = 0; j < 20; j++)
c.CompareTo(d);
}
次：c =“ abcde”，d =“ rwerij”哈希码：0.0012秒。比较：2.4秒。
免责声明：实际上，将散列查找与二进制查找进行基准测试可能比不完全相关的测试更好。我什至不确定GetHashCode是否在后台被记忆
这取决于您如何处理哈希表的重复项（如果有的话）。如果您确实希望允许散列键重复（没有完美的散列函数），则对于主键查找，它仍然为O（1），但是在后面搜索“正确”值可能会很昂贵。从理论上讲，答案通常是散列更快。YMMV取决于您放入的数据...
当然，对于如此大的数据集，哈希是最快的。
由于数据很少更改，因此可以进一步提高速度的一种方法是以编程方式生成临时代码，以将其作为巨型switch语句（如果编译器可以处理）进行第一层搜索，然后分支进行搜索产生的水桶。
这更多是对比尔的回答的评论，因为即使他的回答有错，他的回答也是如此多。所以我不得不发布这个。
我看到很多讨论，涉及哈希表中查找的最坏情况的复杂性是什么，什么才算是摊销分析，什么不是。请检查下面的链接
与Bill所说的相反，最坏的情况是O（n）而不是O（1）。因此，他的O（1）复杂度不会摊销，因为该分析只能用于最坏的情况（他自己的Wikipedia链接也是如此）