一、引用分类

强：运行垃圾回收机制后也不回收，程序出现内存溢出也不回收。

软：在垃圾回收机制运行时判断内存是否已满，如果内存已满则回收，内存充足则不回收。

弱：垃圾回收机制运行后不论内存是否充足都会立即回收。

虚：虚引用和没有引用一样，必须配合引用队列使用。

 

我们来看例子：

import java.lang.ref.PhantomReference;import java.lang.ref.Reference;import java.lang.ref.ReferenceQueue;import java.lang.ref.SoftReference;import java.lang.ref.WeakReference;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import java.util.Set;public class Test{    final Map
     
       m = new HashMap<>();    public static void main(String args[]){        //创建一个新的弱引用，引用给定的对象        String strong = new String("strong");//strong对"strong"的强引用        String soft = new String("soft");//soft对"soft"的强引用        String weak = new String("weak");//weak对"weak"的强引用        String phantom = new String("phantom");//phantom对"phantom"的强引用        ReferenceQueue
      
        queue = new ReferenceQueue
       
        ();//引用队列        Reference
        
          reStrong = new SoftReference<>(strong);        Reference
         
           reSoft = new SoftReference<>(soft);//reSoft对"soft"的软引用        Reference
          
            reWeak = new WeakReference<>(weak);//reWeak对"weak"的弱引用 Reference
           
             rePhantom = new PhantomReference<>(phantom,queue);//rePhantom指向"phantom"的虚引用 soft = null;//断开soft对"soft"的强引用 weak = null;//断开weak对"weak"的强引用 phantom = null;//断开phantom对"phantom"的虚引用 //断开强引用后，就只剩下reSoft对"soft"的软引用，reWeak对"weak"的弱引用，rePhantom对"phantom"的虚引用 System.out.println("strong运行gc前："+strong);//强引用对象 System.out.println("soft运行gc前："+reSoft.get());//获取当前软引用的对象 System.out.println("weak运行gc前："+reWeak.get());//获取当前弱引用的对象 System.out.println("phantom运行gc前："+rePhantom.get());//获取当前虚引用的对象 System.gc();//运行垃圾回收 System.out.println("-----------------------"); System.out.println("strong运行gc后："+strong);//强引用对象 System.out.println("soft运行gc后："+reSoft.get());//获取当前软引用的对象 System.out.println("weak运行gc后："+reWeak.get());//获取当前弱引用的对象 System.out.println("phantom运行gc后："+rePhantom.get());//获取当前虚引用的对象 }}
           
          
         
        
       
      
     

 

运行结果： strong运行gc前：strongsoft运行gc前：softweak运行gc前：weakphantom运行gc前：null-----------------------strong运行gc后：strongsoft运行gc后：softweak运行gc后：nullphantom运行gc后：null

我们看上述结果：

强引用在运行垃圾回收后也不会被回收，软引用在运行垃圾回收后，如果内存足够则不回收，如果内存不足则回收。

弱引用在运行垃圾回收后，不论内存是否充足都会对其回收。虚引用就可没有引用一样，无论何时都会被回收。

 

一般像Date time = new Date();这种都是强引用，也是我们平常使用最多的，只要强引用存在，gc运行后不会对其回收。

我们先看上列代码中的软引用所引用，一开始soft对象对“soft”是一个强引用，然后reSoft对“soft”是一个软引用，

之后soft对象指向null，即断开了对“soft”的强引用，此时只剩下reSoft对“soft”的软引用。

再来分析弱引用，一开始weak对“weak”的强引用，然后是reWeak对“weak”的一个弱引用，

之后weak对象指向nul，即断开了对“weak”的强引用，此时只剩下reWeak对“weak”的弱引用。

最后后还有一个虚引用phantom。

 

下面画个图来看下：

 

还有一点需要说明：

我们先来看下列代码：

import java.lang.ref.PhantomReference;import java.lang.ref.Reference;import java.lang.ref.ReferenceQueue;import java.lang.ref.SoftReference;import java.lang.ref.WeakReference;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import java.util.Set;public class Test{    final Map
     
       m = new HashMap<>();    public static void main(String args[]){        String weak = "weak";//weak对"weak"的强引用        Reference
      
        reWeak = new WeakReference<>(weak);//reWeak对"weak"的弱引用        weak = null;//断开weak对"weak"的强引用        System.out.println("weak运行gc前："+reWeak.get());//获取当前弱引用的对象        System.gc();//运行垃圾回收        System.out.println("-----------------------");        System.out.println("weak运行gc后："+reWeak.get());//获取当前弱引用的对象    }}
      
     

运行结果：weak运行gc前：weak-----------------------weak运行gc后：weak

看到这个可能会有疑问，不是只有一个弱引用执行"weak"吗，运行gc后应该会被回收呀？

大家注意new String("weak")和“weak”是不一样的，前者新建一个对象时是放在堆中，而后者是一个字符串常量是放在静态区的。

而静态区的对象是不会被清理的，所以即使只有弱引用指向“weak”，但由于“weak”不会被清理，所以弱引用依然指向"weak"。

 

对于需要经常使用的内容我们可以采用软引用，这样在需要使用时既不会被回收，也不会出现内存溢出（OOM）错误，很适合做为缓存。

当一些只需要少量使用较大数据时，我们可以采用弱引用，防止其占用内存。

这些可以根据具体使用情况优化引用关系。

这里有一个别人举得使用软引用优化内存溢出的例子：

例子出自：

//首先定义一个HashMap，保存软引用对象。 private Map
     
      > imageCache = new HashMap
      
       >();public void addBitmapToCache(String path) {         // 强引用的Bitmap对象        Bitmap bitmap = BitmapFactory.decodeFile(path);//此方法被执行完，bitmap会被清理，此时只保留下了imageCache中对        // 软引用的Bitmap对象　　　　　　　　　　　　　　　　 //BitmapFactory.decodeFile(path)的软引用，要是实在不放心就对bitmap置null.　　　　　　　　　　　　        SoftReference
       
         softBitmap = new SoftReference
        
         (bitmap);        // 将软引用对象放到到Map中使其缓存        imageCache.put(path, softBitmap);    }  public Bitmap getBitmapByPath(String path) {         // 从Map中取软引用的value(Bitmap)对象        SoftReference
         
           softBitmap = imageCache.get(path);        // 判断当前软引用对象是否被清理        if (softBitmap == null) {            return null;        }        // 如果被清理返回null，反之返回改对象        Bitmap bitmap = softBitmap.get();        return bitmap;     }
         
        
       
      
     

 

二.WeakHashMap

理解了上列内容，就很容易理解WeakHashMap了。

WeakHashMap的键是弱引用，回收键后删除key-value对象。

import java.util.Iterator;import java.util.Map;import java.util.Set;import java.util.WeakHashMap;public class TestWeakHashMap {    public static void main(String[] args) {        // TODO Auto-generated method stub        Map
     
       m = new WeakHashMap<>();        m.put(new String("1"), "一");        m.put(new String("2"), new String("二"));        m.put("3", new String("三"));        m.put(new String("4"), new String("四"));        System.gc();        Set
      
       
        > s_m = m.entrySet();        Iterator
        
         
          >ite = s_m.iterator();        while(ite.hasNext()){            Map.Entry
          
            en = ite.next(); System.out.println("ket:" + en.getKey() + "\t" + "value:" + en.getValue()); } }}
          
         
        
       
      
     

运行结果：ket:3    value:三

运行gc后弱引用的键都被回收了，但“3”在静态区不会被回收，所以弱引用仍然可以指向“三”。

 

三、IdentityHashMap

IdentityHashMap是比较键的地址去重，如果键的地址相同就代表同一个对象，如果键的地址不同就表示不同对象。

 而HashMap是使用hashCode和equals去重。

import java.util.IdentityHashMap;import java.util.Map;public class TestIdentityHashMap {    public static void main(String[] args) {        // TODO Auto-generated method stub        Map
     
       m = new IdentityHashMap<>();        m.put("1", "1");//保留        m.put("1", "1");//覆盖前一个的value "1"        m.put(new String("1"), "1");//保留        m.put(new String("1"), "1");//保留        System.out.println(m.size());    }}
     

运行结果：3

第一个“1”是字符串常量，存放在静态区是共享的，第一个和第二个“1”都是指向同一个存放在静态区的常量“1”。所以第二个放置时地址相同会替换旧值。

new String("1"),是在堆中开辟一块存放“1”的地址，无论该值是否存在，只要new了就会开辟一个新的空间。

我们来看一个图：

 

四.EnumMap

键（key）必须为枚举的值，构造方法中必须为指定枚举类。

import java.util.EnumMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import java.util.Set;public class TestEnumMap {    public static void main(String args[]){        Map
     
       m = new EnumMap<>(Season.class);//构造方法指定枚举类        m.put(Season.SPRING, "春困");        m.put(Season.SUMMER, "夏乏");        m.put(Season.AUTUMN, "秋无力");        m.put(Season.WINTER, "冬日正好眠");        Set
      
       
        > s_m = m.entrySet();        Iterator
        
         
          >ite = s_m.iterator();        while(ite.hasNext()){            Entry
          
            en = ite.next(); System.out.println(en.getValue()); } }}enum Season{ SPRING,SUMMER,AUTUMN,WINTER}
          
         
        
       
      
     

运行结果：春困夏乏秋无力冬日正好眠