Java Collections and Garbage Collector

by

The actual Sun-implementation for Java copies from time to time all referenced/living objects. The space from which was copied can then be used again for memory allocation.

That said your examples damages actually performance. listRubriques.clear() is unneeded (except you hold somethere else a reference to it), because everything referenced by listRubrique is garbage the moment listRubriques is no longer referenced. listRubriques = null may also unneeded if the variable listRubriques go out of scope afterwards (possibly because it’s a local variable and the method ends here).

Not only the call to clear is unneeded, as clear accesses the memory of the object that is afterwards no longer in use, the object is accessed and modern processors will put it into their cache. So a dead object is explicitly going to the processor-cache – some possibly more useful data will be overwritten for that operation.

This article is a good reference to get more informations about the Java Garbage collector.

EDIT: To react on the edit in the question: The Garbage collector (the implementation used by Sun at least) is starting from some root references and copies all objects it can reach from this references and that are referenced by the copied objects. So your circular referenced objects are garbage, as no ‘outer’ reference is pointing to them and the memory will be reclaimed in the garbage collection.

More Related Contents:

  1. Does Java JIT compiler sacrifice performance to favor Collections?
  2. How can I read a large text file line by line using Java?
  3. Efficiency of Java “Double Brace Initialization”?
  4. Java 8: performance of Streams vs Collections
  5. Does setting Java objects to null do anything anymore?
  6. Map.clear() vs new Map : Which one will be better? [duplicate]
  7. Performance considerations for keySet() and entrySet() of Map
  8. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  9. Which loop has better performance? Why?
  10. Garbage collection behaviour for String.intern()
  11. Empty an ArrayList or just create a new one and let the old one be garbage collected? [duplicate]
  12. Most efficient Java primitive collections library [closed]
  13. Know of any Java garbage collection log analysis tools? [closed]
  14. What is the fastest Java collection with the basic functionality of a Queue?
  15. What is the Metadata GC Threshold and how do I tune it?
  16. ArrayList vs. Vectors in Java if thread safety isn’t a concern
  17. Java very large heap sizes [closed]
  18. What GC parameters is a JVM running with?
  19. Measuring time spent on GC
  20. Why is creating a Thread said to be expensive?
  21. How to count the number of occurrences of an element in a List
  22. How can I convert int[] to Integer[] in Java?
  23. Why can Java Collections not directly store Primitives types?
  24. Immutable vs Unmodifiable collection [duplicate]
  25. Collections.synchronizedList and synchronized
  26. Why does TreeSet throw a ClassCastException?
  27. What is the quantitative overhead of making a JNI call?
  28. Comparing two hashmaps for equal values and same key sets?
  29. How to reduce java concurrent mode failure and excessive gc
  30. Hashmap implementation to count the occurrences of each character

Leave a Comment