Update README.md

Author: learning-zone

README.md

@@ -2378,101 +2378,70 @@ Parallel garbage collector is also called as throughput collector. It is the def
 
 ## Q. What is difference between WeakReference and SoftReference in Java?
 
-In Java there are four types of references differentiated on the way by which they are garbage collected.
+**1. Weak References:**
 
-* Strong References
-* Weak References
-* Soft References
-* Phantom References
+Weak Reference Objects are not the default type/class of Reference Object and they should be explicitly specified while using them.
 
-**Strong References**: This is the default type/class of Reference Object. Any object which has an active strong reference are not eligible for garbage collection. The object is garbage collected only when the variable which was strongly referenced points to null.
 ```java
-MyClass obj = new MyClass();
-```  
+/**
+ * Weak Reference
+ */
+import java.lang.ref.WeakReference;
 
-**Weak References**: Weak Reference Objects are not the default type/class of Reference Object and they should be explicitly specified while using them.
-```java
-//Java Code to illustrate Weak reference 
-import java.lang.ref.WeakReference; 
-class MainClass 
-{ 
-    public void message() { 
-        System.out.println("Weak References Example"); 
-    } 
-} 
-  
-public class Example 
-{ 
-    public static void main(String[] args) { 
-        // Strong Reference 
-        MainClass g = new MainClass();    
-        g.message(); 
-          
-        // Creating Weak Reference to MainClass-type object to which 'g'  
-        // is also pointing. 
-        WeakReference<MainClass> weakref = new WeakReference<MainClass>(g); 
-        g = null;  
-        g = weakref.get();  
-        g.message(); 
-    } 
-} 
-```
+class MainClass {
+    public void message() {
+        System.out.println("Weak References Example");
+    }
+}
 
-**Soft References**: In Soft reference, even if the object is free for garbage collection then also its not garbage collected, until JVM is in need of memory badly.The objects gets cleared from the memory when JVM runs out of memory.To create such references java.lang.ref.SoftReference class is used.
-```java
-//Java Code to illustrate Weak reference 
-import java.lang.ref.SoftReference; 
-class MainClass 
-{ 
-    public void message() { 
-        System.out.println("Weak References Example"); 
-    } 
-} 
-  
-public class Example 
-{ 
-    public static void main(String[] args) { 
-        // Strong Reference 
-        MainClass g = new MainClass();    
-        g.message(); 
-          
-        // Creating Weak Reference to MainClass-type object to which 'g'  
-        // is also pointing. 
-        SoftReference<MainClass> softref = new SoftReference<MainClass>(g); 
-        g = null;  
-        g = softref.get();  
-        g.message(); 
-    } 
-} 
+public class Example {
+    public static void main(String[] args) {
+        // Strong Reference
+        MainClass g = new MainClass();
+        g.message();
+
+        // Creating Weak Reference to MainClass-type object to which 'g'
+        // is also pointing.
+        WeakReference<MainClass> weakref = new WeakReference<MainClass>(g);
+        g = null;
+        g = weakref.get();
+        g.message();
+    }
+}
 ```
-**Phantom References**: The objects which are being referenced by phantom references are eligible for garbage collection. But, before removing them from the memory, JVM puts them in a queue called ‘reference queue’ . They are put in a reference queue after calling finalize() method on them.To create such references java.lang.ref.PhantomReference class is used.
+
+**2. Soft References:**
+
+In Soft reference, even if the object is free for garbage collection then also its not garbage collected, until JVM is in need of memory badly.The objects gets cleared from the memory when JVM runs out of memory.To create such references java.lang.ref.SoftReference class is used.
+
 ```java
-//Java Code to illustrate Weak reference 
-import java.lang.ref.*; 
-class MainClass 
-{ 
-    public void message() { 
-        System.out.println("Phantom References Example"); 
-    } 
-} 
-  
-public class Example 
-{ 
-    public static void main(String[] args) { 
-        // Strong Reference 
-        MainClass g = new MainClass();    
-        g.message(); 
-          
-        // Creating Phantom Reference to MainClass-type object to which 'g'  
-        // is also pointing. 
-        PhantomReference<MainClass> phantomRef = null; 
-        phantomRef = new PhantomReference<MainClass>(g,refQueue); 
-        g = null; 
-        g = phantomRef.get();  
-        g.message(); 
-    } 
-} 
+/**
+ * Soft Reference
+ */
+import java.lang.ref.SoftReference;
+
+class MainClass {
+    public void message() {
+        System.out.println("Weak References Example");
+    }
+}
+
+public class Example {
+    public static void main(String[] args) {
+        // Strong Reference
+        MainClass g = new MainClass();
+        g.message();
+
+        // Creating Weak Reference to MainClass-type object to which 'g'
+        // is also pointing.
+        SoftReference<MainClass> softref = new SoftReference<MainClass>(g);
+        g = null;
+        g = softref.get();
+        g.message();
+    }
+}
 ```
+
 <div align="right">
     <b><a href="#related-interview-questions">↥ back to top</a></b>
 </div>