blocks|key|280334|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|280335|设置这个列表的初始容量有什么好处？|blockquote|280336|280337|280338|它将在内部分配这个大小的内存，当它长大之后，它将重新分配内存，并将。如果我们提供适当的初始容量，我们可以在重新调整溢出时节省一些cpu周期。|280339|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|J|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|K|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|N|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|O|7|@]|8|@]|9|$]]]|I|$]]

<blockquote>
 What is the benefit of setting the initial capacity of this List?
</blockquote>

It will allocate memory of that size internally and when it grows over that it will reallocate memory and will . if we supply proper initial capacity we can have some cpu cycle saved while re adjusting overflows.

blocks|key|1573325|text|设置列表的容量只会指定它的大小。这样做的唯一好处是，当您添加超过默认列表大小的项时，它将不必扩展列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1573326|示例:将列表设置为25，默认为10？(不是100%25确定)如果添加24个元素，它根本不必增加列表。如果你把它作为默认设置，它就会长出来。|1573327|希望这能帮上忙|1573328|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Setting the capcity of the list will just specify how big it will be. the only up side to doing this will be the fact that when u add items that exceed the default size of a list, it wont have to extend the list. 

example: you set the list to 25, and the default is 10? (not 100% sure) if you add 24 elements it wont have to grow the list at all. if you left it as the default it will grow it.

hope this helps

blocks|key|1573339|text|在填充列表时，设置初始容量可以提高性能，如果您向列表中添加的项数不超过该数量，则还可以减少列表的内存占用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1573340|通过调用trimToSize()，可以减少已增长的列表的内存占用量，并且可能有一个大于存储项数量的后备数组。|offset|length|style|CODE|1573341|entityMap^0|0|4|C|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Setting the initial capacity can increase the performance when populating the List, and it can also reduce the memory footprint of the List if you never add more than that number of items to the list.

The memory footprint of a List that has grown, and might have a backing array that is larger than the number of items stored can be reduced by invoking <code>trimToSize()</code>

blocks|key|1594856|text|如果您知道您需要的正是这个数量，那么初始容量就会有所帮助。它将创建一个能够引用MAX_TWEETS项的容器。如果超过它，系统将创建一个包含两倍多项的新列表，然后复制原始列表(这在Java应用程序中非常常见)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1594857|entityMap^0|13|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

The initial capacity helps if you know that you will need exactly that amount. It will create a container that will be able to reference <code>MAX_TWEETS</code> items. If you do exceed it, the system will create a new list with twice as many items then copy over the original list (which is common enough in Java applications).

blocks|key|1594873|text|默认情况下，在Java+6中，列表的大小为10，也就是说，系统在基础数组中创建10个内存槽。如果尝试添加第11个元素，则只创建Array副本。提供一个大小可以提高性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1594874|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

By default, in Java 6, the size of a List is 10. That is, the system creates ten memory slots in the underlying Array. If you try adding the 11th element, only the Array copy is created. Providing a size improves performance.

blocks|key|280410|text|顾名思义，ArrayList是作为数组实现的(相对于链接列表)。通过指定初始大小，可以避免在添加元素时必须扩展数组。这是一个昂贵的操作，必须创建一个新的数组，然后复制现有的元素。所以，如果你提前知道最大值，你就不必这么做了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|280411|实际上，如果列表的大小为50，并且该数组只有一个实例，则数组将只展开几次，因此在这种情况下可能无关紧要。不过，如果以后更改变量，您的方法还是不错的。|280412|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

ArrayList, as the name suggests, is implemented as an array (as opposed to a linked list). By specifying the initial size, you can prevent having to grow the array when adding elements. This is an expensive operation, a new array must be created and then the existing elements copied. So, if you know the max values ahead of time, you should never have to do this.

In reality, if the size of your list is 50 and there is only one instance of this array, the array will only be expanded a few times, so in this case it might not matter. Still, your approach is good in case you change the variable later.

blocks|key|280429|text|ArrayList的默认容量设置为10+(参见JDK1.6源代码)。这意味着在创建时将分配大小为10的数组。如果要添加元素11，容量将增加到16，然后在达到21时再次增加。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|280430|如果您不期望超过50个元素，数组将最多调整3次大小。考虑到这么小的数目，这真的不重要。将其设置为50，如果它给了你一张保存数组副本的想法。|280431|实际上，这是正确的尺寸增长公式：|280432|int+newCapacity+=+(oldCapacity+*+3)/2+%2B+1;|code-block|syntax|javascript|280433|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Default capacity of ArrayList is set to 10 (see jdk 1.6 source). That means array of size 10 will be allocated on creation. If you will be adding element number 11 the capacity will increase to 16. Then increase again once you reach 21. 

If you don't expect more than 50 elements the array will resize at most 3 times. Given that small number, it really does not matter much. Set it to 50 if it gives you a piece of mind of saving on array copy.

Actually this is correct formula of size increase:

<pre><code>int newCapacity = (oldCapacity * 3)/2 + 1;
</code></pre>

blocks|key|280435|text|它将在创建时分配内存，并且在您检查之前不需要复制。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|280436|但是老实说，只要有50个对象，复制就不会花费太多精力了，所以我非常怀疑您会看到任何性能的提高。但是，指定大小并没有坏处，所以您最好还是这样做。|280437|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It will allocate the memory at creation and won't have to copy until you go over that.

But honestly, with only 50 objects, the copying won't take much effort anyway, so I highly doubt you'll see any performance gain at all. But, there's no downside to specifying the size, so you might as well do it.

I often use Lists in my Android applications. Right now I am creating a Twitter page which lists a maximum of 50 "tweets" of a user. 

I have a List defined like this:

<code>List&lt;Tweet&gt; tweets = new ArrayList&lt;Tweet&gt;(MAX_TWEETS);</code>

Where <code>Tweet</code> is a custom object type holding twitter update information(text, date, username, etc) and <code>MAX_TWEETS</code> is a constant integer value(50).

Questions:

What is the benefit of setting the initial capacity of this <code>List</code>, if any?

Should I bother setting a capacity when i know my list will be this small? When should i/should i not be setting a capacity?

Declaring the capacity of a List in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我经常在我的Android应用程序中使用列表。现在，我正在创建一个Twitter页面，其中列出了最多50个用户的“tweet”。我有一个定义如下的列表：List<Tweet> tweets = new ArrayList<Tweet>(MAX_TWEETS);其中，Tweet是保存twitter更新信息(文本、日期、用...

问用Java声明列表的容量
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用Java声明列表的容量EN