列表可用时，是否有理由使用数组？[关闭]

List<T>在C＃中，似乎可以完成数组可以做的所有事情，并且还可以完成更多工作，并且在内存和性能上也与数组一样高效。

那么，为什么我要使用数组呢？

我显然不是在问API或其他外部约束（即Main函数）需要我使用数组的情况……我只是在问关于在自己的代码中创建新数据结构的问题。

同样的原因，我上班时不开车。我不会使用某些我不会使用的功能。

首先，数组是原始构造，因此数组肯定比List <>更快，更高效，因此您的参数不正确。Array随处可见，并且使用不同的语言和平台的开发人员也知道。

我使用数组而不是List <>的最重要原因是暗示数据是固定长度的。如果我不会从该数据集中添加或删除任何项目，那么我想确保类型能够反映出来。

另一件事是，假设您正在实现一个新的数据结构，并且已经阅读了一些有关它的论文。现在，在实现特定算法时，您不能总是依赖于其他人对通用类型的实现。它从.NET变为Mono，甚至在框架的不同版本之间也有变化。

而且有时移植使用数组而不是依赖于框架的类型的代码更容易。

当然，您需要数组来管理可变结构的集合，如果没有这些结构，我们将如何处理。

struct EvilMutableStruct { public double X; } // don't do this

EvilMutableStruct[] myArray = new EvilMutableStruct[1];
myArray[0] = new EvilMutableStruct()
myArray[0].X = 1; // works, this modifies the original struct

List<EvilMutableStruct> myList = new List<EvilMutableStruct>();
myList.Add(new EvilMutableStruct());
myList[0].X = 1; // does not work, the List will return a *copy* of the struct

（请注意，在某些情况下，需要一个可变结构的数组，但是通常，数组中可变结构与其他集合的这种不同行为是应避免的错误来源）

更严重的是，如果要通过reference传递元素，则需要一个数组。即

Interlocked.Increment(ref myArray[i]);  // works
Interlocked.Increment(ref myList[i]);   // does not work, you can't pass a property by reference

这对于无锁线程安全代码很有用。

如果您想快速有效地使用默认值初始化固定大小的集合，则需要一个数组。

double[] myArray = new double[1000]; // contains 1000 '0' values
                                     // without further initialisation

List<double> myList = new List<double>(1000) // internally contains 1000 '0' values, 
                                             // since List uses an array as backing storage, 
                                             // but you cannot access those
for (int i =0; i<1000; i++) myList.Add(0);   // slow and inelegant

（请注意，有可能实现List的构造函数执行相同的操作，只是c＃不提供此功能）

如果您想有效地复制集合的一部分，则需要一个数组

Array.Copy(array1, index1, array2, index2, length) // can't get any faster than this

double[,] array2d = new double[10,100];
double[] arraySerialized = new double[10*100];
Array.Copy(array2d, 0, arraySerialized, 0, arraySerialized.Length);
// even works for different dimensions

（同样，这也可以为List实现，但是此功能在c＃中不存在）

那么，为什么我要使用数组呢？

很少，你将有你在那里的情景知道你需要的元素的固定数量。从设计角度来看，应避免这种情况。如果您需要3件事，那么业务性质意味着您在下一个版本中经常需要4件事。

尽管如此，当这种罕见情况实际发生时，使用数组强制执行固定大小不变式仍然很有用。它向其他程序员发出信号，它的大小是固定的，并有助于防止在有人添加或删除元素的情况下误用-破坏代码其他地方的期望。

您的问题实际上已经得到回答。

并且似乎在内存和性能上也与数组一样高效。

不是。从我链接的问题：

List/foreach:  3054ms (589725196)
Array/foreach: 1860ms (589725196)

在某些重要情况下，阵列的速度快两倍。我敢肯定，内存使用情况也很重要。

由于您的问题的主要前提就这样被打败了，我假设这可以回答您的问题。除此之外，有时Win32 API，GPU的着色器或某些其他非DotNet库会强制将数组强加给您。

即使在DotNet中，某些方法也会占用和/或返回数组（例如String.Split）。这意味着要么你现在必须吃调用的成本ToList和ToArray所有的时间，或者您必须遵守和使用数组，可能是通过传播这对可怜的下游用户持续循环的代码。

有关此主题的更多有关堆栈溢出的问题和解答：

• 数组与List<T>：何时使用哪个？
• 为什么我们使用数组而不是其他数据结构？
• 使用array还是哪个更好List<>？

除了其他答案中列出的原因外，数组文字需要更少的字符来声明：

var array = new [] { "A", "B", "C" };
var list = new List<string>() { "A", "B", "C" };

List在以下情况下，使用数组而不是代码会使代码更短一些，并且可读性更高：（1）您需要传递任何IEnumerable<T>文字，或者（2）其他功能List无关紧要，并且您需要使用类似列表的形式文字。

我偶尔在单元测试中这样做。

严格来说，这是从面向对象的角度来看的。

尽管我想不出只传递数组的原因，但我肯定可以看到类内部数组表示可能是最佳选择的情况。

尽管还有其他选项具有类似的特性，但似乎没有一个数组像数组那样直观地处理处理排列，嵌套循环，矩阵表示，位图和数据交织算法。

有很多科学领域广泛依赖矩阵数学。（例如图像处理，数据纠错，数字信号处理，大量应用数学问题）。这些领域中的大多数算法都是根据使用多维数组/矩阵编写的。因此，按照定义的算法来实施算法比让它们变得更“软件”友好而不是以丢失直接与算法所基于的论文的联系为代价的做法更为自然。

就像我说的那样，在这些情况下，您可能可以摆脱使用列表的麻烦，但是在已经很复杂的算法之上又增加了另一层复杂性。

实际上，这也适用于具有列表的其他语言（例如Java或Visual Basic）。在某些情况下，您需要使用数组，因为方法会返回数组而不是List。

在实际的程序中，我不认为会经常使用数组，但是有时您会知道数据将是固定大小的，并且您喜欢使用数组所带来的小性能提升。就像进行返回列表的方法或需要多维数据结构一样，微优化将是一个正当的理由。

好吧，我在自己写的游戏中发现了数组的用途。我用它来创建具有固定数量插槽的库存系统。这有几个好处：

1. 通过查看并查看哪些插槽为空，我确切地知道了游戏对象有多少个未清库存插槽。
2. 我确切地知道每个项目所在的索引。
3. 它仍然是“类型化”数组（Item []库存），因此我可以添加/删除“ Item”类型的对象。

我认为，如果需要“增加”库存的大小，可以通过将旧项目转移到新阵列中来实现，但是由于库存是由屏幕空间固定的，因此无需动态地增加它的大小。 /更小，它很适合我使用的目的。

如果要遍历列表的所有元素，则不需要，不需要数组，使用“下一个”或任意“选择而不替换”会很好。

但是，如果您的算法需要随机访问集合中的元素，那么是的，数组是必需的。

这有点类似于“必须去吗？”。用合理的现代语言根本不需要。但是，如果您剥离了某些抽象，那么到那时，您便可以使用所有这些东西，也就是说，实现这些抽象的唯一方法是使用“不必要的”功能。（当然，这种比喻不是完美的，我不认为有人会说数组是不好的编程习惯；它们很容易理解和思考）。

旧版兼容性。

所有形式的个人经历：

旧版程序员-我的同事在各处使用数组，已经使用了30多年，祝您好运，因为您提出了新想法。

旧版代码-foo（array bar []）确保可以使用列表/向量/集合toarray函数，但如果不使用其中的任何其他功能，则使用数组开始就更容易，而且通常在不进行类型切换的情况下更具可读性。

旧版上司-我的上司在多年前进入管理领域之前是一位优秀的程序员，但她仍然认为自己是最新的，“正在使用数组”可以结束会议，并解释说收集每个人都需要花费午餐。

1）没有列表的多维版本。如果您的数据具有多个维度，则使用列表的效率将非常低。

2）当您处理大量的小型数据类型（例如，一张地图，其中您所拥有的只是地形类型的一个字节）时，由于缓存的原因，性能可能会存在很大差异。阵列版本每次读取内存会加载几项，列表版本只会加载一项。此外，阵列版本在缓存中保存的单元格是列表版本的几倍。如果重复处理数据，如果阵列版本适合缓存，而列表版本则不能，那么这将有很大的不同。

对于极端情况，请考虑Minecraft。（是的，它不是用C＃编写的。有相同的原因。）

某个类型T的100个元素的数组封装了类型T的100个独立变量。如果T恰好是具有可变类型Q的公共字段和类型R的值的值类型，则该数组的每个元素将封装独立变量因此，整个数组将封装100个Q型独立变量和100个R型独立变量。这些变量中的任何一个都可以单独访问而不会影响其他变量。 除数组外，其他任何收集类型都不允许将结构的字段用作自变量。

如果T恰好是具有Q和R类型的公共可变字段的类类型，则数组的每个元素在Universe中的任何地方都拥有对的实例的唯一引用T，并且如果该数组的任何元素都不会修改以标识存在外部引用的对象，则该数组将有效封装100个Q类型的独立变量和100个R类型的独立变量。其他集合类型可以模仿此类数组的行为，但前提是唯一的目的数组的封装是封装100个Q类型的变量和100个R类型的变量，将每对变量封装在其自己的类对象中是这样做的昂贵方法。进一步，使用可变类类型的数组或集合可能导致数组元素标识的变量可能不独立。

如果一个类型应该表现得像某种对象，那么它应该是一个类类型或一个私有域结构，除了替换之外，它不提供任何变异手段。但是，如果一个类型应该表现得像一堆相关的，但是独立的变量用胶带粘在一起，那么应该使用这样一种类型，是一组变量用胶带粘在一起-曝光场结构。这种类型的数组使用起来非常高效，并且具有非常清晰的语义。任何其他类型的使用都将导致语义混乱，性能不佳或两者兼而有之。

一个重要的不同是内存分配。例如，遍历一个链表可能会导致大量的高速缓存未命中并降低性能，而数组代表一个连续的内存块，其中包含某些特定数据类型的多个实例，并且遍历它的顺序更可能会击中CPU。缓存。

当然，对象引用数组可能不会从高速缓存命中中获得太多好处，因为取消引用仍然可以将您带到内存中的任何位置。

然后是列表实现，例如ArrayList，它们使用数组实现列表。它们是有用的原语。

您可以在何时选择Array和何时选择这里使用一些指导List。

• Array从方法返回时使用。
• 使用List当你正在构建的返回值（在方法内部）变量。然后.ToArray()从方法返回时使用。

通常，Array当您不希望消费者向集合中添加项目时，请使用。使用List时，你想让你的消费者将项目添加到集合中。

Array用于处理“静态”集合，而List用于处理“动态”集合。