blocks|key|367902|text|它不在我们手中..你可以从你那端把它作废..|type|unstyled|depth|inlineStyleRanges|entityRanges|data|367903|Object+a+=+new+Object();
a+=+null;+//+after+that,+if+there+is+no+live+thread+which+is+accessing+members,it+will+be+deleted+by+garbage+collector|code-block|syntax|javascript|367904|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It is not in our hand.. You can just nullify it from your end..

<pre><code>Object a = new Object();
a = null; // after that, if there is no live thread which is accessing members,it will be deleted by garbage collector
</code></pre>

blocks|key|3323725|text|您可以尝试Finalize()或System.runFinalization()，但坦率地说，如果仍然有指向对象的引用，那么我认为GC将忽略您的请求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3323726|entityMap^0|5|A|G|O|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

You could try <code>Finalize()</code> or <code>System.runFinalization()</code> but frankly, if there are references still pointing to the object, then I think the GC will ignore your request.

blocks|key|367946|text|这在Java中是不可能的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|367947|如果有引用对象强引用，则不能强制JVM对该对象进行GC。它根本不能保证程序会工作。|367948|如果所有其他引用的代码都在您的控件中，请考虑将它们更改为使用WeakReference或SoftReference|offset|length|style|CODE|367949|entityMap^0|0|0|U|D|18|D|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|@$F|O|G|P|H|I]|$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

It is not possible in Java.

If you have strong reference referring your object, you cannot force JVM to GC that object. It simply cannot guarantee the program will work.

If codes of all other references are in your control, consider changing them to use <code>WeakReference</code> or <code>SoftReference</code>

blocks|key|2281372|text|有些事情不在我们手中，最好留给JRE来处理。我们所能做的就是确保我们在使用它们之后显式地使它们成为null。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2281373|{
++//+Some+block
++HugeObject+obj+=+HugeObject.getInstance();
++//+Use+it+
++obj+=+null;
}
//+end+of+block|code-block|syntax|javascript|2281374|entityMap^0|1D|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

There are some things that are not in our hands and its better to leave it to the JRE to handle it. All we can do that we make sure that the we make them <code>null</code> explicitly after using them.

<pre><code>{
 // Some block
 HugeObject obj = HugeObject.getInstance();
 // Use it 
 obj = null;
}
// end of block
</code></pre>

blocks|key|2277672|text|Java内存处理就是为了防止这种情况而构建的。只要存在对一个对象的引用，这个对象就会一直存在。据我所知，没有(官方的)方法来了解对象的其他引用(应该也没有这个必要)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2277673|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|$]]

Java memory handling is just built to prevent that. An object is guaranteed to live as long as a reference to this object exists. As far as I know there is no (official) way to get to know the other references to an object (and there should be no need for that).

blocks|key|3323901|text|在Java中，GC(垃圾收集器)处理堆清理。如果一个对象没有活动的引用，那么它将被自动清除。因此，您需要确保没有对该对象的活动引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3323902|让它成为null是其中一种方法。但是，如果有其他对象指向相同的引用，则不能保证清除。这就是为什么编写好的代码需要在使用后关闭所有资源，包括将其设为null。|offset|length|style|CODE|3323903|如果堆资源不足，可以尝试增加堆大小或调用System.gc()，但再次手动调用gc并不能保证实际执行gc。它依赖于许多依赖于JVM的参数。|3323904|entityMap^0|0|4|4|0|K|B|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

In Java GC(Garbage collector) handles heap cleanup. If an Object has no live references to it then it will automatically be cleaned up. So you need to make sure there are no live references to the Object.

Making it <code>null</code> is one of the way. But it will not guarantee it's cleanup if there is some other Object pointing to the same reference. That is why writing good code involves closing all the resources after use which includes making it to null.

If you are running low on heap you can try increasing heap size or calling <code>System.gc()</code> but again calling gc manually does not guarantee gc will actually be performed. it depends on lot of parameters which are JVM dependent.

blocks|key|367999|text|这些是对对象的哪种引用？这些引用是由您创建的，并且在运行时您不会跟踪这些引用。如果是这种情况，您可以将对对象的引用包装在软/弱引用中，然后显式运行GC请求。否则，在运行时，如果任何活动线程有权访问该对象。GC不应删除该对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|368000|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|$]]

What kind of references are these to the object? Are these references created by you and at runtime you don't keep track of of those references. If this is the case, you can wrap your references to the object in soft/ weak reference and then explicitly run the GC request. Otherwise, on runtime, if any live thread has access to the object. GC shall not delete that object.

blocks|key|3323953|text|不知道你的用例是很难回答的，但是如果你想要从一个位置移除它，那么你可以将对它的所有其他引用存储为一个WeakReference。Java通常在引用对象时使用强引用，只有在没有更多强引用时，GC才会清除某些内容。但是，如果您使用WeakRefrences，并且您的强引用超出了范围，那么即使您的数据仍然需要，也不能保证它会保留。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3323954|不过，我可能会弄错，因为我已经一两年没有用过这个类了。|3323955|在WeakReferences上：http://docs.oracle.com/javase/7/docs/api/java/lang/ref/WeakReference.html|offset|length|3323956|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/7/docs/api/java/lang/ref/WeakReference.html^0|0|0|H|21|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

It is hard to answer no knowing your use case, but if there is one location that you want to be able to remove it from then you can store every other reference to it as a WeakReference. Java normally uses strong refrences when referencing objects and the GC will only clear something when it has no more strong references. However, if you use WeakRefrences and your strong refrence ever goes out of scope there is no guarantee that your data will remain even if it is still needed.

I could be mistaken about this though, as I haven't used this class in a year or two.

On WeakReferences:
<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/ref/WeakReference.html" rel="nofollow">http://docs.oracle.com/javase/7/docs/api/java/lang/ref/WeakReference.html</a>

blocks|key|368026|text|您可以将对象声明为WeakReference并将其添加到ReferenceQueue中。这样，当您的对象不再被进一步引用时，它将承担GC的责任。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|368027|++++/**
++++++++Initialize+the+reference+queue+,+even+if+you+don't+do+it+,+no+problem+.+Default+reference+queue+will+be+taken.
++++++++**/
++++++++ReferenceQueue<?+super+Object>+testReferenceQueue+=+new+ReferenceQueue<Object>();

+++++++Map<String,String>+demoHashMap+=+new+HashMap<String,String>();

+++++++demoHashMap.put("SomeValue","testValue");
+++++++//+Declare+the+object+as+weak+object+and+put+it+in+reference+queue+
+++++++WeakReference<?>+weakObject+=+new+WeakReference<Object>(demoHashMap,testReferenceQueue+);

++++demoHashMap.clear();++
++++demoHashMap+=+null;+//+This+object+is+not+referenced+from+anywhere

+++++if(weakObject!=null){
+++++System.out.println("Object+is+not+GCd+yet");
++++++}else{
+++++++System.out.println("It+is+already+garbage+collected");
++++++}|code-block|syntax|javascript|368028|entityMap^0|9|D|S|E|1U|2|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

You can declare your objects as <code>WeakReference</code> and add them in <code>ReferenceQueue</code>. In this way , whenever your object will not be further referenced , it will be liable for <code>GC</code>.

<pre><code> /**
 Initialize the reference queue , even if you don't do it , no problem . Default reference queue will be taken.
 **/
 ReferenceQueue&lt;? super Object&gt; testReferenceQueue = new ReferenceQueue&lt;Object&gt;();

 Map&lt;String,String&gt; demoHashMap = new HashMap&lt;String,String&gt;();

 demoHashMap.put("SomeValue","testValue");
 // Declare the object as weak object and put it in reference queue 
 WeakReference&lt;?&gt; weakObject = new WeakReference&lt;Object&gt;(demoHashMap,testReferenceQueue );

 demoHashMap.clear(); 
 demoHashMap = null; // This object is not referenced from anywhere

 if(weakObject!=null){
 System.out.println("Object is not GCd yet");
 }else{
 System.out.println("It is already garbage collected");
 }
</code></pre>

You have one big object in java. it has got 4 or five references. you don't know all those references. At time on deletion you know only one reference and you want to delete that object completely. How to achieve that? and also if you want to know other references then to what is the best way to do that.

How to delete a java object from Heap?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在java中你有一个大对象。它有4到5个参考文献。你并不了解所有的参考资料。在删除时，您只知道一个引用，并且您希望完全删除该对象。如何做到这一点呢？另外，如果你想知道其他的参考资料，那么最好的方法是什么。

问如何从堆中删除java对象？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从堆中删除java对象？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从堆中删除java对象？
EN