blocks|key|2860330|text|将其设置为null不会有任何效果，因为通过arList对象仍然是可达。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2860331|也就是说，您的MyObect实例将至少与arList一样长。|2860332|编辑：根据您的评论，myObj听起来确实更长寿。在这种情况下，在循环结束后将其设置为null。|BOLD|2860333|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reachability_of_an_object^0|5|4|L|6|W|2|0|0|7|7|K|6|0|0|2|A|5|16|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|J]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Setting it to <code>null</code> will have no effect, since the object is still <a href="http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reachability_of_an_object" rel="nofollow noreferrer">reachable</a> via <code>arList</code>.

That is, your <code>MyObect</code> instances will live at least as long as <code>arList</code>.

EDIT: Based on your comment, it does sound like <code>myObj</code> is longer-lived. In that case, set it to <code>null</code> after the end of your loop.

blocks|key|1198485|text|您没有指定myObj的范围及其重要性。如果它是一个局部变量，那么它几乎肯定无关紧要。如果它是一个实例变量，那么这可能是一个长期存在和不必要的引用，在这种情况下，设置为null将是有用的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1198486|更新：给出了更新后的信息，即myObj是该方法的本地信息，在循环每次迭代结束时将其设置为null是零值。考虑一下这个例子：|BOLD|1198487|public+void+process(String+text)+{
++String[]+lines+=+text.split("\n");
++List<MyObject>+list+=+new+ArrayList<MyObject>();
++Object+myObj;
++for+(String+line+:+lines)+{
++++myObj+=+new+MyObject(line);
++++list.add(myObj);
++++//+1.+set+myObj+=+null+here
++}
++list+=+null;+//+2
++//+3.+do+some+other+stuff
}

public+class+MyObject+{
++private+final+String+line;

++public+MyObject(String+line)+{
++++this.line+=+line;
++}
}|code-block|syntax|javascript|1198488|在这个例子中，假设在第3步，它花费了很长的时间。说十分钟吧。在这10分钟内，myObj指向处理的最后一行。听起来不像是个问题？有可能是这样。在Java中，子字符串的工作方式是引用原始字符串。所以如果你这么做了：|1198489|String+s+=+...+//+100+megabytes
String+s2+=+s.substring(100,+101);|1198490|实际上，您将整个100+s2保存在内存中，因为s2引用了s。|1198491|因此，在我前面的函数中，myObj引用了一行引用整个文件的行。将步骤1更改为myObj+=+null;实际上会有所帮助，因为此引用将防止垃圾收集对象。|1198492|注意：步骤2在这里很重要，因为如果您不取消列表，那么所有引用都会存在。|1198493|你只需要考虑一下引用是如何工作的。当对对象的引用存在时，它不会被垃圾收集。这意味着清除长期存在的引用并尽可能严格地保持变量的作用域。解决上述问题的正确办法是：|1198494|for+(String+line+:+lines)+{
++Object+myObj+=+new+MyObject(line);
++...
}|1198495|然后，myObj在循环中被限定范围，所以当循环结束或另一个迭代开始时，它已经超出了范围，这要好得多。|1198496|entityMap^0|5|5|2B|4|0|0|3|E|5|18|4|0|0|12|5|0|0|0|C|5|12|D|0|0|3|0|0|0|3|5|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@$9|1B|A|1C|B|H]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|I|3|J|5|K|7|1H|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|K|7|1L|8|@]|D|@]|E|$L|M]]|$1|R|3|S|5|6|7|1M|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|1S|8|@$9|1T|A|1U|B|H]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1V|8|@]|D|@]|E|$]]|$1|Z|3|10|5|K|7|1W|8|@]|D|@]|E|$L|M]]|$1|11|3|12|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|20|8|@]|D|@]|E|$]]]|14|$]]

You don't specify the scope of <code>myObj</code> and its important. If its a local variable it almost certainly doesn't matter. If its an instance variable then that could be a long-lived and unnecessary reference in which case setting to <code>null</code> will be useful.

Update: given the updated information that <code>myObj</code> is local to the method, it will be of zero value to set it to <code>null</code> at the end of each iteration of the loop. Consider this example:

<pre><code>public void process(String text) {
 String[] lines = text.split("\n");
 List&lt;MyObject&gt; list = new ArrayList&lt;MyObject&gt;();
 Object myObj;
 for (String line : lines) {
 myObj = new MyObject(line);
 list.add(myObj);
 // 1. set myObj = null here
 }
 list = null; // 2
 // 3. do some other stuff
}

public class MyObject {
 private final String line;

 public MyObject(String line) {
 this.line = line;
 }
}
</code></pre>

Now in this example, let's say that at step 3, it took a long time. Say 10 minutes. During that 10 minutes <code>myObj</code> is pointing to the last line processed. Doesn't sound like a problem? Well it could be. The way substrings work in Java is that they reference the original string. So if you do:

<pre><code>String s = ... // 100 megabytes
String s2 = s.substring(100, 101);
</code></pre>

you're actually keeping the entire 100MB in memory because s2 references s.

So in the function I have above, <code>myObj</code> references a line which references the entire file. Changing step 1 to <code>myObj = null;</code> would actually help that because this reference is preventing the object being garbage collected.

Note: step 2 is important here because if you didn't nullify the list all the references would exist anyway.

You just need to think about how references work. An object won't be garbage collected while a reference to it exists. This means clearing long-lived references and keeping variables scoped as tightly as possible. The correct solution for the above is:

<pre><code>for (String line : lines) {
 Object myObj = new MyObject(line);
 ...
}
</code></pre>

and then <code>myObj</code> is scoped inside the loop so as soon as the loop ends or another iteration begins it has gone out of scope, which is much better.

blocks|key|1198072|text|我认为这是你误解的根源。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1198073|嗯..。但我不希望保留两个myObj副本，一个在arList中，一个在原始变量中。一旦我将myObj添加到arLsit中，如何冲洗它？|blockquote|1198074|你不能“保留两份myObj”。在您的示例中，循环创建的每个MyObject实例只有一个“副本”。顺序如下：|1198075|创建一个MyObject实例，将其引用分配给myObj。|ordered-list-item|offset|length|style|CODE|1198076|将对实例的引用添加到arList引用的arList。|1198077|将null分配给myObj中的引用。|1198078|请注意，将引用添加到列表并不会创建MyObject实例的副本。它仅仅意味着你在两个地方而不是一个地方有引用。当您分配null时，您将再次将引用放在一个位置上。|1198079|另外要注意的是，将null分配给某物永远不会导致垃圾收集器运行。它所做的就是(显式地)在下次运行垃圾收集器时从考虑中删除引用的潜在副本。|1198080|最后，如果我们假设范围如下，则C行将没有明显的效果.除非A行或B行触发垃圾回收。|1198081|{
++++MyObject+myObj;
++++ArrayList+arList+=+new+ArrayList();
++++while+(someCondition)+{+++++++//+A
+++++++++myObj+=+new+MyObect();+++//+B
+++++++++arList.add(myObj);+
+++++++++myObj+=+null;++++++++++++//+C
++++}
}|code-block|syntax|javascript|1198082|entityMap^0|0|0|0|M|5|0|A|6|J|6|0|1|4|8|5|0|1M|4|0|9|4|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|16|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|17|8|@$J|18|K|19|L|M]]|9|@]|A|$]]|$1|N|3|O|5|I|7|1A|8|@$J|1B|K|1C|L|M]|$J|1D|K|1E|L|M]]|9|@]|A|$]]|$1|P|3|Q|5|I|7|1F|8|@$J|1G|K|1H|L|M]|$J|1I|K|1J|L|M]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1K|8|@$J|1L|K|1M|L|M]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1N|8|@$J|1O|K|1P|L|M]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|X|3|Y|5|Z|7|1R|8|@]|9|@]|A|$10|11]]|$1|12|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|13|$]]

I think that this is the root of your misunderstanding.

<blockquote>
 hmm.. but I don't wish to keep 2 copies of myObj , one in arList and one in the original variable. How can I flush myObj once I add it to arLsit ?
</blockquote>

You do NOT "keep two copies of myObj". In your examples, there is only ever one "copy" of each MyObject instance created by the loop. The sequence is:

<ol>
<li>You create a MyObject instance, assigning its reference to <code>myObj</code>.</li>
<li>You add the reference to the instance to the ArrayList that <code>arList</code> refers to.</li>
<li>You assign <code>null</code> to the reference in <code>myObj</code>.</li>
</ol>

Note that adding the reference to the list does NOT create a copy of the MyObject instance. It simply means that that you have the reference in two places instead of
one. And when you assign the <code>null</code> you once again have the reference in just one place.

The other thing to note is that assigning <code>null</code> to something will never CAUSE the garbage collector to run. All it does is to (explicitly) remove a potential copy of a reference from consideration the next time the garbage collector is run.

Finally, if we assume that the scoping is as follows, then the line C will have no discernible effect ... unless either line A or line B triggers a garbage collection.

<pre><code>{
 MyObject myObj;
 ArrayList arList = new ArrayList();
 while (someCondition) { // A
 myObj = new MyObect(); // B
 arList.add(myObj); 
 myObj = null; // C
 }
}
</code></pre>

I wish to confirm which scenario will cause a Garbage Collection on the object myObj:

Scenario 1

<pre><code>ArrayList arList = new ArrayList();
while(someCondition)
{
 myObj = new MyObect(); // a custom object
 arList.add(myObj); 
}
</code></pre>

Scenario 2

<pre><code>ArrayList arList = new ArrayList();
while(someCondition)
{
 myObj = new MyObect(); // a custom object
 arList.add(myObj); 
 myObj=null;
}
</code></pre>

Does explicitly setting an object as null improves garbage collection behavior or will be it same when I reset the object using the new constructor ?

Which object will be garbage collected?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想确认哪个场景会导致对象myObj上的垃圾收集：场景1ArrayList arList = new ArrayList();while(someCondition){  myObj = new MyObect(); // a custom object  arList.add(myObj); }场景2ArrayLis...

问哪个对象将被垃圾收集？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哪个对象将被垃圾收集？EN