blocks|key|235493|text|ArrayList的initial+capacity是10(参考文献)。也就是说，即使您的集合中只有一个条目，底层数组的大小也将为10。这些引用将默认为null，因此将第二个引用设置为null既不会影响arraylist的内部状态(就底层数组而言)，也不会影响其内存消耗。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|235494|如果您添加了第11项(设置为空)，ArrayList将扩展其容量，因此您将消耗更多内存，但这是因为ArrayList为您的String引用创建了额外的存储桶。|style|CODE|235495|来自上面链接的文档：|235496|235497|每个ArrayList实例都有一个容量。容量是用于存储列表中的元素的数组的大小。它始终至少与列表大小一样大。当元素添加到ArrayList中时，其容量会自动增长。除了添加元素具有恒定的摊销时间成本之外，没有指定增长策略的详细信息。|blockquote|235498|235499|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html#ArrayList%2528%2529^0|A|G|0|0|H|9|1P|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@$A|11|B|12|F|G]|$A|13|B|14|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

The <a href="http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html#ArrayList%28%29" rel="nofollow">initial capacity</a> of an ArrayList is ten (references). That is to say, the underlying array will be of size ten, even if you've only got one entry in your collection. Those references will default to null, and consequently setting the second reference to null will neither affect the internal state of the arraylist (in terms of the underlying array) nor its memory consumption.

If you'd added an eleventh item (set to null), the <code>ArrayList</code> would expand its capacity, and consequently you'd consume more memory, but rather because the ArrayList had created extra buckets for your <code>String</code> references.

From the doc linked above:

<blockquote>
 Each ArrayList instance has a capacity. The capacity is the size of
 the array used to store the elements in the list. It is always at
 least as large as the list size. As elements are added to an
 ArrayList, its capacity grows automatically. The details of the growth
 policy are not specified beyond the fact that adding an element has
 constant amortized time cost.
</blockquote>

blocks|key|1256441|text|在本例中是这样的，因为ArrayList默认分配了一个包含10个位置的数组(在openjdk中)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1256442|如果您使用LinkedList，那么答案将是否定的。|1256443|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|$]]

In this case yes, as ArrayList allocates an array of 10 positions by default (in openjdk).

If you used LinkedList instead, then the answer would be no.

blocks|key|4049277|text|也许，第一个列表有两个元素，第二个列表有一个元素，所以第一个列表更大。然而，大多数列表默认为10个元素，两个列表的大小可能相同，但如果第二次添加需要扩展列表，那么它将占用更多内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4049278|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|$]]

Maybe, the first list has two elements and the second list has one element so the first list is larger. However most lists default to 10 elements the two lists may be the same size but if the second add required the list to be expanded then it will take more memory.

blocks|key|235595|text|好吧，“这要看情况”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|235596|有了在Sun+JVM上运行的代码，再加上他们实现ArrayList的方式，答案是“是”，它们是平等的。|235597|这是因为在默认情况下，ArrayList从一个包含10个元素的数组开始。大多数实现都会做同样的事情。|235598|但是，如果您有一个包含10个元素的ArrayList，而另一个包含11个元素，那么无论这些元素是否为空，11个元素都会占用更多内存，因为用于跟踪这些元素的内部数组将会扩展。|235599|最后，如果您使用不同的列表实现，比如LinkedList，那么这两个列表将消耗不同数量的内存，因为LinkedList不预分配任何内容，而是使用节点包装器来包装其元素。|235600|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Well, "it depends".

With the code you have there, running on the Sun JVM, and the way that they've implemented ArrayList, the answer is "yes", they're equal.

This is because by default, an ArrayList starts off with an array of 10 elements. Odds are the most implementations do the same thing.

But if you had an ArrayList with 10 elements, and another with 11, whether the elements are null or not, the 11 element one would consume more RAM because the internal array used to track the elements would have expanded.

Finally, if you were using different List implementation, such as a LinkedList, then the two lists would consume different amounts of memory, as the LinkedList doesn't pre-allocate anything and uses a node wrapper for its elements.

blocks|key|235610|text|在这个特定的例子中，使用一个带有两个元素的ArrayList。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|235611|一个ArrayList的初始容量是10个元素，所以只要添加10个或更少的元素，ArrayList本身的大小就是相同的(大小在内存中，而不是size())。当您添加第11个元素时，ArrayList将不得不增加内部存储空间，从而占用更多内存。|235612|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|$]]

In this specific case, using an ArrayList with two elements they do.

The initial capacity for an ArrayList is 10 elements, so as long as you add 10 or fewer elements the size of the ArrayList itself is the same (size in memory, not size()). When you add the 11th element the the ArrayList will have to grow the internal storage and thus take more memory.

blocks|key|4049450|text|编辑:我改变主意了。正如许多人所说，是的，它们一开始会占用相同数量的内存，一旦你添加足够的null，达到初始容量，你就会增加你的内存大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4049451|我最初认为，因为您可以访问第一个列表中的null，这将导致更多的内存，但是在两种情况下都有NULL值，并且访问它们的能力不会影响内存分配。|4049452|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|$]]

Edit: Changed my mind. 
As many people are stating, yes they will take up the same amount of memory at first, once you add enough null's to the point where the initial capacity is reached you will increase your memory size. 

I originally thought that because you can access the null in the first list that it would lead to more memory, however the null values are there in both cases, and the ability to access them does not affect memory allocation.

blocks|key|4049377|text|不，两者不是相等的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4049378|list+[abc,null]|code-block|syntax|javascript|4049379|存储的另一个列表|4049380|list+[abc]|4049381|所以两者并不相等|4049382|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

No both are not Equals.

<pre><code>list [abc,null]
</code></pre>

Another list stored

<pre><code>list [abc]
</code></pre>

so both are not equal

I want to figure out sometihng.

is this:

<pre><code> List &lt;String&gt; list = new ArrayList&lt;String&gt;();
 list.add("abc");
 list.add(null);
</code></pre>

equals to this

<pre><code> List &lt;String&gt; list = new ArrayList&lt;String&gt;();
 list.add("abc");
</code></pre>

in memory usage?

thanks!

Is list with one String equals (in memory usage) to list with one String and one null object?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想弄清楚一些事情。是这样的吗： List <String> list = new ArrayList<String>(); list.add("abc"); list.add(null);等于这个 List <String> list = new ArrayList<String>(); list.add("abc");内存使用率？谢谢!

问list with one String是否等于(在内存使用中) list with one String and one null object？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问list with one String是否等于(在内存使用中) list with one String and one null object？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问list with one String是否等于(在内存使用中) list with one String and one null object？
EN