List <T>调整大小时,添加了多少额外容量？
List<T>调整大小时，添加了多少额外容量取决于具体的实现方式。在Java中，ArrayList是List接口的一个常见实现类。
在ArrayList中，当调用add()方法添加元素时，如果当前容量不足以容纳新元素，ArrayList会根据扩容策略进行自动扩容。具体扩容策略如下：
- 首先，ArrayList会计算出新的容量大小。通常情况下，新容量大小为当前容量的1.5倍（即增加50%），但如果当前容量小于64，则新容量大小为当前容量的2倍。
- 然后，ArrayList会创建一个新的数组，并将原数组中的元素复制到新数组中。
- 最后，ArrayList会将新元素添加到新数组中。
因此，当调整ArrayList的大小时，会添加额外的容量，具体额外容量的大小取决于当前容量和扩容策略。
需要注意的是，ArrayList的扩容操作是一个相对耗时的操作，因为需要创建新数组并复制元素。因此，在预知需要存储大量元素的情况下，可以通过构造函数指定初始容量，以减少扩容操作的频率，提高性能。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器（CVM）：提供可扩展的计算容量，满足不同规模业务的需求。详情请参考：https://cloud.tencent.com/product/cvm
- 腾讯云弹性伸缩（AS）：自动调整云服务器数量，根据业务负载的变化进行弹性伸缩。详情请参考：https://cloud.tencent.com/product/as
- 腾讯云对象存储（COS）：提供安全、稳定、低成本的云端存储服务，适用于各种场景的数据存储和处理需求。详情请参考：https://cloud.tencent.com/product/cos
相关·内容
2回答
初始化类对象
、、、
我对Java很陌生。如果我问一件简单的事情，我很抱歉。我编写了下面的代码，但它似乎没有正确初始化。因为当我打印list1的大小时，它会显示大小= 0!！然而，它应该是4！
public static class MyClass{
public List <Integer> list1
// Class Constructor
public MyClass(int n){
list1 = new ArrayList <Integer> (n);
Syste
浏览 3提问于2013-10-21得票数 1
回答已采纳
如下所示，我可以得到t (0 )中有多少个元素，但我不知道t倾覆的真实大小。在c++中，capacity()可以返回100。
// in Java
ArrayList<Integer> t = new ArrayList<Integer>(100);
System.out.println(t.size()); // 0
// in C++
vector<int> t;
t.reserve(100);
std::cout << t.size() << std::endl; // 0
std::cout << t.cap
浏览 0提问于2015-12-03得票数 1
6回答
我有一个list (List<T> list)，我希望使用一个映射(HashMap<Integer, T> map)根据其ids对其对象进行索引。我总是在list.size()构造函数中使用作为初始容量，如下所示。这是在这种情况下使用的最佳初始容量吗？
注意事项：我永远不会在地图上添加更多的项目。
List<T> list = myList;
Map<Integer, T> map = new HashMap<Integer, T>(list.size());
for(T item : list) {
map.put(item
浏览 5提问于2013-04-05得票数 31
回答已采纳
1回答
我有一个正在处理大型数据集的进程，它处理Parallel.ForEach中的记录，然后将结果存储在ConcurrentQueue<List<string>>中。因此，处理一个记录，记录中的每个字段都生成一个字符串，然后将该字符串添加到List中。在记录的末尾，List即为Enqueued，并对保存所有已处理记录的ConcurrentQueue进行进一步处理。
经过几个小时的处理，我注意到我的CPU使用量已经从一个新的浪潮上升到了相当高的水平，处理一组记录的时间开始增长。
这里我的假设是，List被填满，然后复制到一个新的更大的List中。随着CPU容量的增加，初始化周期
浏览 0提问于2017-08-10得票数 0
回答已采纳
4回答
我今天看到了一个奇怪的情况：
我有一个通用列表，我希望用它的索引器将条目添加到列表中，如下所示：
List<string> myList = new List<string>(10);
myList[0] = "bla bla bla...";
当我尝试这个的时候，我得到了ArgumentOutOfRangeException
然后我查看了List<T>索引器集方法，如下所示：
[TargetedPatchingOptOut("Performance critical to inline across NGen image
浏览 2提问于2013-12-30得票数 8
回答已采纳
目前，我的大多数表上运行了许多触发器。我正在使用Insert、Update和Delete触发器。他们登录到另一张桌子上。然而，由于这一点，使用该软件的处理时间增加了。对于较小的变化几乎没有注意到，但是对于大的变化，它可以从10-15分钟持续到1小时。
我想改变我的触发器，停止安装新的日志记录，比如在1分钟内安装250条日志记录(大容量操作)，删除新创建的日志，并创建1条大容量记录和使用的查询。问题是当启动的时候我似乎无法让扳机停止。
我已为此创造了所需的条件：
CREATE TRIGGER AUDIT_LOGGING_INSERT_ACTUALISERINGSCOEFFICIENT ON AC
浏览 1提问于2019-09-11得票数 1
回答已采纳
1回答
此脚本用于在最接近“目标”的网格中查找下一个节点。代码只工作一次，然后通知我“范围异常之外的参数。参数名:索引”。我相信错误出现在"tempNode = currentPathm_index;“上。但是在我的头撞在键盘上几个小时之后，我就不确定了。currentPath中至少有1项，不管其中有多少项，它都会抛出错误。
统一并没有具体告诉我错误在哪里，只是它是一个列表错误。有什么想法？
我知道它来自于代码的这一部分，但是我已经包含了整个代码，如下所示。
else
{
pathFound = false;
if (currentPath.Capacity > 0 &
浏览 3提问于2015-11-01得票数 0
请参阅我的代码如何在db中添加多个数据。
List<Employee> oEmp = new List<Employee>
{
new Employee{Name="New employee2", Salary=5000},
new Employee{Name="New employee3", Salary=6000},
new Employee{Name="New employee4", Salary=7000}
};
using (var ctx = new TestEFContext())
浏览 2提问于2017-07-03得票数 0
回答已采纳
3回答
将克隆添加到列表中很慢。
、、、、
我试图加快一个循环，即克隆2_500_000对象。克隆本身是以800 ms作为整个循环，但当我将它们添加到列表中时，则需要3秒。
List<T> list = new List<T>();
Stopwatch sw = new Stopwatch();
sw.Start();
foreach(T entity in listSource)
{
T entityCloned = GetEntityClone(entity); // Taking 800ms totally
if (entityCloned != null)
list.
浏览 1提问于2018-09-26得票数 2
回答已采纳
我试图在0到20000之间用10000个随机整数来填充一个列表。下面是我如何做到这一点的代码：
List<int> rand_num = new List<int>();
Random rand = new Random();
int i =0;
//int counter = 0;
while (i < 10000)
{
rand_num.Add(rand.Next(0, 20000));
i++;
}
浏览 3提问于2014-09-06得票数 0
回答已采纳
为什么List<T>的容量增加了2倍？
private void EnsureCapacity(int min)
{
if (this._items.Length < min)
{
int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2);
if (num < min)
{
num = min;
}
this.Capacity = num;
}
}
为什么Diction
浏览 65提问于2013-01-30得票数 20
回答已采纳
2回答
考虑最新更新的动态集的装箱部件
、、、、
有一大组物体。Set是动态的:对象可以随时添加或删除。让我们调用对象总数N。
每个对象都有两个属性:上次更新的质量(M)和时间(T)。
每隔X分钟，就应该选择一小批处理，以便将它们的T更新到当前时间。一批中所有对象的总M值是有限的:不超过L。
我想在这里解决三项任务：
找出下一批对象拾取算法；
引入对象类:简单、优先级(至少适合每批n批)和频繁(适用于每一批)；
预测系统容量耗尽(添加下一个服务器的时间=增加L)。
什么样的模型最能描述这样的系统？
整个过程是关于一个在时间间隔内处理“对象”的服务。每个物体应该“测量”每N个小时。N可以在一个范围内变化。X是固定的。
对象由
浏览 3提问于2014-10-17得票数 2
回答已采纳
2回答
插入一行列表的大容量插入效率
、、、、
我正在尝试使用大容量插入，并将其替换为我的项目中当前常用的插入。一些插入请求(BillType.Booklet)是一个一行的列表，另一些是多行的列表。
public async Task CreateBill(List<BillReceiverDto> Receivers, BillType BillType)
{
var bulkList =new List<BillReceiverDto>();
if (BillType == BillType.Booklet)
{
浏览 7提问于2020-11-18得票数 1
回答已采纳
嗨，今天我偶然发现了一件与List<T>(Int32)有关的事情。我认为在以下例子中，这种行为也是一样的：
1.
var myList = new List<string>(5);
myList[1] = string.Empty;
2.
var myArray= new string[5];
myArray[1] = string.Empty;
第一个示例失败，我得到一个'System.ArgumentOutOfRangeException‘。第二个例子效果很好。
所以我尝试了列表中的.Count，它表示为0，当我将.Length放在数组中时，它表示为5。
在
浏览 2提问于2016-04-06得票数 4
回答已采纳
当列表因为没有多余的容量而调整大小时，会增加多少容量？只有1个？或者它增加了容量(使总容量翻倍)？
浏览 0提问于2010-11-12得票数 3
回答已采纳
我有字符串列表
std::list<std::string> list = { "--version", "--setcolor", "--setint" };
list.push_back("--command1");
list.push_back("--command2");
list.push_back("--command3");
基本的命令列表，这些命令最终希望将它们转换为字符串。
最后，这个列表可以包含多达100个命令。
在c++17中最快的方法是什么？
更新
它也可以是数组
浏览 3提问于2021-02-03得票数 0
回答已采纳
我需要从Azure存储表中检索50.000个实体，结果应该放在List中。检索实体不需要太多时间，但将它们从Iterable中放入List需要相对较长的时间，大约为10秒。我怎么能在更短的时间内做到这一点？
下面的代码检索条目并将它们放入ArrayList中
Iterable<T> items = table.execute(tableQuery);
ArrayList<T> result = new ArrayList<T>();
if (items != null) {
for (T item : items) {
result
浏览 5提问于2017-03-01得票数 0
4回答
我想知道什么时候实例化了类的ArrayList。如果我通过给它一个初始大小来声明它像#2，而不是#1，它会更快吗？或者，如果我知道要添加多少列，那么应该只给构造函数一个初始大小吗？
List<Column> columns = new ArrayList<Column>();
List<Column> columns = new ArrayList<Column>(10);
浏览 4提问于2013-07-29得票数 1
回答已采纳
2回答
STL中的优化期望
、、、
我很好奇编译器会做多少优化，所以...
// assume we have this declared somewhere
std::vector<int> vec;
// my question is, when fully optimized will this...
for (int i(0); i<100; ++i)
vec.push_back(i);
// evaluate to this? psuedo code...
const size_t size = size();
const size_t newsize = size + 100;
if (
浏览 1提问于2012-12-03得票数 0
回答已采纳
1回答
我想要创建一个哈希表，这是一个特定的大小，每次。我希望它是存储在"list“中的块数(使用子字符串())的10倍。
for (int k = 0; k < foo.length() - blockSize + 1; k++) {
list = foo.substring(k, k + blockSize);
System.out.println(list);
}
我在网上查过了，找不到任何解决办法。我能得到一些澄清吗？
谢谢
浏览 1提问于2014-03-16得票数 1
4回答
集合类型的初始容量，如字典、列表
、、、、
.Net中的某些集合类型有一个可选的"Initial Capacity“构造函数参数。例如：
Dictionary<string, string> something = new Dictionary<string,string>(20);
List<string> anything = new List<string>(50);
我似乎找不到MSDN上这些对象的默认初始容量是多少。
如果我知道我只能在字典中存储12个左右的条目，那么将初始容量设置为20左右不是很有意义吗？
我的推理是，假设容量像StringBuilder一样增长，每次
浏览 1提问于2010-05-04得票数 46
回答已采纳
1回答
我正在尝试创建一个邻接列表。问题是我的实现花费了大量的内存...
我读取了一个单词文件，将它们添加到我的图形中，并添加了图形的邻居
static public void createEdges(){
for(String string : words){ //words is the list of all the ~4 000 words that have been read
ArrayList<String> wordlist = new ArrayList<String>();
// ...................
浏览 31提问于2018-10-26得票数 0
我有一个大文件的格式：
x a
y c
x d
z a
z s
y k
我希望输出将被排序并以形式显示。
x a,d
y c,k
z a,s,k
对于这种类型的任务，哈希是最好的：
简单的TreeMap解决方案是这样的：
Map<String, StringBuilder> agg = Maps.newTreeMap();
while ((line = r.readLine()) != null) {
String[] arr = line.split("\t");
String key = arr[0];
浏览 5提问于2014-05-14得票数 3
回答已采纳
我有许多类都实现了相同的接口。例如：
Public Class IncidentAsset
Implements IModelWithIdentity
Private _assetId As Int16
Private _otherAsset As String
Private _asset As Asset
Public Property AssetId() As Int16
Get
Return _assetId
End Get
Set(ByVal value As Int
浏览 2提问于2012-01-27得票数 0
5回答
这是我关于堆叠溢出的第一个问题。我在很大程度上为我在下面的代码行中体验到的东西寻找了一个理由：
unsigned long long _mem1= getUsedVirtualMemory();
vector.erase(vector.begin() + _idx);
contained= false; // don't stop the loop
_idx--; // the removed object has redefined the idx to be consider.
_mem1 = getUsedVirtualMemory() - _mem1;
if (_mem1 &
浏览 0提问于2014-12-10得票数 2
有很多这样的问题，但似乎没有任何帮助。我正在尝试将相当大的csv.gz文件转换到parquet中，并不断收到各种错误，例如
'Command failed with exit code 1'
或
An error occurred while calling o392.pyWriteDynamicFrame. Job aborted due to stage failure: Task 0 in stage 0.0 failed 4 times, most recent failure: Lost task 0.3 in stage 0.0 (TID 3, ip-172-31-
浏览 0提问于2018-10-03得票数 1
当创建像4,7,9,19 (小，中，大)这样的集群大小时，那么根据集群大小的优缺点，哪个大小是最合适的，小，中，还是更大？
浏览 20提问于2020-06-08得票数 0
我一直在追踪一个大的C++代码库中的一个过时的问题。由于某些原因，我无法理解下面的Val差夫行为。有人能在这里亮点光吗？
守则是：
% cat foo.cxx
#include <cstring>
#include <string>
#include <vector>
int main() {
std::vector<char> v;
#ifdef RESIZE9
v.resize(9);
#endif
v.resize(10);
std::string s(10, 'x');
std::strcpy(&a
浏览 1提问于2021-05-10得票数 2
回答已采纳
这是我的工作代码。是否需要清除或释放func()中的wstring、wstring流和向量？如果是这样的话，是怎么做的？我看到了一个.clear()函数，用于向量、wstring和wstream。
这个示例程序是用来显示代码的。我使用wstring流、wstring和向量，其中我有一个分隔字符串，我需要提取列表中的每一项并对其进行操作。
任何关于优化这个代码和/或做家务的建议也是非常感谢的。
#include <windows.h>
#include <strsafe.h>
#include <vector>
#include <sstream>
浏览 8提问于2022-01-20得票数 2
回答已采纳
5回答
今天，我在我正在构建的内容管理系统中添加了一个新特性。根据上传图像的位置，PHP将调整图像大小以适应指定位置。它运行得很好，但是当我试图上传一个更大的图像时，就像在一个3MB的映像中一样，我得到了一个致命的错误：
Fatal error: Allowed memory size of 134217728 bytes exhausted
(tried to allocate 42520 bytes) in...
我想128‘t的内存是相当多的，考虑到我没有运行那么多.至少我不这么认为。它试图为调整大小的进程再分配42520字节，但失败了。
我的问题是，我应该(A)增加限制还是(B)重新评估为什
浏览 2提问于2010-10-07得票数 2
回答已采纳
3回答
列表迭代器与向量迭代器
、、、、
我有两个关于迭代器的问题。
我认为，一旦您为STL容器(如向量或列表)定义了迭代器，如果将元素添加到容器中，则这些迭代器将无法访问它们。但是，下面的代码定义了一个由五个元素组成的列表，然后在每个循环迭代中添加另一个元素，并导致一个无限循环：
#包括使用命名空间std；int main() { list ls；for(int i= 0；i< 5；i++) { ls.push_back(i)；} int idx = 0；for(列表：：iterator iter = ls.begin()；iter != ls.end()；iter++) { cout << " idx
浏览 4提问于2013-12-24得票数 4
回答已采纳
2回答
动态数组调整函数问题
、、、
注意:我知道只使用STL向量会更容易，但是对于我所在的编程类，我们需要编写自己的动态数组模板类，因为我们的教授显然喜欢让我们重新发明轮子。
无论如何，我为我的动态数组模板类做了一个调整大小的函数，如下所示。请注意，私有成员变量是T* arr、无符号使用和无符号上限。
template <class T>
void darray<T>::resize(unsigned size)
{
if (size > cap)
{
T* temp_arr = new T[size];
for (int count = 0; co
浏览 2提问于2014-04-22得票数 2
回答已采纳
如果我们有以下变量声明：
List<int> list = new List(5);
为什么要这样做：
list.insert(2, 3);
失败，并显示以下错误：
Index must be within the bounds of the List.
提供初始大小的意义是什么？
浏览 0提问于2012-01-05得票数 7
回答已采纳
1回答
我不能创建一个3大小的ArrayList。任何帮助我解决这个问题的点击都会很感激。打印语句的输出为“容量3”和数组大小为0。
这就是我在Junit测试中使用的
BoundedDeque<整数> arr =新的Deque<整数>(3)；
public class Deque<E> implements BoundedDeque<E>
{
protected int capacity, size, back, front;
ArrayList<E> arraylist;
public Deque(int capac
浏览 1提问于2014-04-29得票数 0
回答已采纳
哪个更快，原因是：
IEnumerable<T> clxnOfTs = GetSeriouslyHugeCollection();
var list = new List<T>(clxnOfTs.Count);
foreach (T t in clxnOfTs) list.Add(t);
或
IEnumerable<T> clxnOfTs = GetSeriouslyHugeCollection();
var linkedList = new LinkedList<T>();
foreach (T t in clxnOfTs) linkedLis
浏览 2提问于2011-02-25得票数 2
回答已采纳
1回答
我在团结中创造了一个游戏。我得到了一个错误：
System.ThrowHelper.ThrowArgumentOutOfRangeException (System.ExceptionArgument argument, System.ExceptionResource resource)
这是我的简短代码：
public class OnlineGame : MonoBehaviour
{
private List<GameObject> domino = new List<GameObject>(7);
public void Start()
浏览 4提问于2022-01-07得票数 -1
回答已采纳
3回答
我已经有了一个List<T>，它可能包含或不包含重复的。我将根据使用它们的一些计算结果构建一个Set<String>，因为在某些情况下，两个不同的T可以生成相同的String。
List<T>中的一些元素具有不受欢迎的属性，因此我需要过滤掉它们。我是这样过滤的：
List<T> myList = myCoolListGetter();
Iterator<T> it = myList.iterator();
T curr;
while (it.hasNext()) {
curr = it.next();
if (curr
浏览 3提问于2014-04-04得票数 0
回答已采纳
1回答
我正在使用javascript aws。我有一个大的文件，我即将处理，我想确保在我开始处理之前，我的豆茎中通常很少的实例被增加。
如何触发缩放事件，以确保至少有8个实例，并在开始下一个步骤之前等待完成？
我会接受任何在javascript中都有异常api的非javascript示例(我可以翻译它)。
浏览 0提问于2018-02-05得票数 0
回答已采纳
1回答
我正在编写一个DynamicArray类，并被resize()函数困住了。当我移除行delete[] temp时，它就像预期的那样工作。但当我不这样做的时候，似乎只复制了最后两个元素。我是不是漏掉了什么？？
#include <iostream>
#include <initializer_list>
template <typename T, int N>
class DynamicArray
{
private:
T *m_array;
size_t m_capacity = N * sizeof(T); // Capacity o
浏览 2提问于2020-07-18得票数 1
回答已采纳
所以我应该在课堂上写一些叫做ArrayList的函数。我只是不知道从哪里开始，也不知道如何管理动态数组。受保护的类成员是：
protected:
int *m_list; ///< Pointer to dynamic array.
std::size_t m_capacity; ///< Physical size of dynamic array.
std::size_t m_size; ///< Number of array elements in use.
/// @brief Appends the given element @p value
浏览 4提问于2019-10-11得票数 0
回答已采纳
我有以下几点：
public static class LocalFileModelList
{
public static List<LocalFileModel> ModelList = new List<LocalFileModel>();
}
public class LocalFileModel
{
public string Name { get; set; }
public string Extension { get; set; }
}
然后是从目录中读取所有文件
浏览 3提问于2015-05-25得票数 0
回答已采纳
我正在尝试确定什么时候使用List<T>.Add()比使用Array.Resize()方法更有效。
Array.Resize的文档说它会复制整个数组，并将其放入一个新对象中。旧对象将不得不被丢弃。这个旧对象驻留在哪里？堆栈还是堆？
我不知道List.Add()是如何工作的。
有人知道List.Add方法与静态Array.Resize方法的比较吗？
我感兴趣的是内存使用情况(和清理)，以及300个值类型与20,000个值类型之间的优劣。
无论如何，我计划在一种嵌入式风格的.NET上运行这段代码。
浏览 0提问于2011-01-18得票数 10
回答已采纳
3回答
哪一个更贵，贵多少：
List<cards> cardList = getMyList(small);//returns a list of 100 elements
cardList.add(card);
Vs.
List<cards> cardList = getMyList(big);//returns a list of 100,000 elements
cardList.add(card);
我想我真正的问题是，把一个大的列表放到内存中是不是很昂贵？或者list足够聪明，可以只得到它需要的大小？添加时较小，搜索时较大。
浏览 1提问于2010-03-11得票数 1
回答已采纳
3回答
我正在尝试定义‘行’或1D向量的值，然后将该行push_back到2D向量中。我已经尝试了几种不同的方法，它们不会抛出错误，但似乎也不起作用。代码如下：
#include <vector>
#include <iostream>
using std::vector;
#define HEIGHT 5
#define WIDTH 3
// 2D VECTOR ARRAY EXAMPLE
int main() {
vector<vector<double> > array2D;
vector<double> currentRow;
浏览 4提问于2012-03-02得票数 3
回答已采纳
如果std::vector的大小和容量可以是任意的，那么将其大小更改为0并将容量更改为至少N(给定的数字)的最佳实践是什么？
我的直接想法是：
void f(vector<int> &t, int N)
{
t.clear();
t.reserve(N);
}
但我注意到
重新分配不能保证发生，向量容量也不能保证改变(当调用时)。
所以我想知道当原产容量大于给定的N时，如何避免重新分配？
浏览 1提问于2018-07-05得票数 6
回答已采纳
我有以下代码来分析不同N的std::vector性能与std::list。
void vectorPerf(size_t n)
{
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
std::vector<size_t> cache;
for (size_t i = 0; i < n; i++) {
cache.push_back(i);
}
std::chrono::high_resolutio
浏览 0提问于2017-12-26得票数 2
我对std::span的理解是，它本质上包含指向容器的指针、大小和一些有用的成员函数。
template<typename T>
class SimpleSpan {
T* ptr;
size_t length;
// some member functions
}
我可以取一个向量的跨度，如在中所看到的。
如果我将条目添加到向量的末尾，则可能需要调整向量的大小。当调整矢量的大小时，会发生以下步骤(顺序不重要)。
在堆上分配了一个新的数组，具有更多的空间。
向量中的条目被移动到新的数组中.
，vector到vector数组的成员ptr更改为新数组的开始。。
浏览 7提问于2021-10-20得票数 3
2回答
如果您正在处理一个大列表(比如1GB的大小)，并且需要调整它的大小，以便为其他项目腾出空间。是否可以在调整大小时对该列表进行读/写，或者在操作完成之前是否会停止调用？
浏览 2提问于2009-09-25得票数 0
回答已采纳
它看起来不像(示例程序)，但是我能确定吗？
// does resizing an STL vector erase/invalidate it's previous contents?
#include <stdio.h>
#include <vector>
using namespace std ;
void print( vector<int>& t )
{
for( int i = 0 ; i < t.size() ; i++ )
printf( "%d ", t[i] ) ;
puts(
浏览 0提问于2012-03-07得票数 11
回答已采纳
5回答
现在，我有了一个在数组上动态分配内存的算法：
如果数组已满，则创建一个两倍大小的新数组，并复制项。
如果数组已满四分之一，则创建一个大小为一半的新数组，并复制项。
这对于动态内存分配来说是相当快的算法，尽管将元素复制到新分配的数组是额外的过度。
什么是更快，List<T>或这样的基于数组的算法？您推荐使用什么？
List<T>是否使用简单数组作为内部数据结构？
浏览 2提问于2013-02-16得票数 6
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
