一、引用分类
强：运行垃圾回收机制后也不回收，程序出现内存溢出也不回收。
软：在垃圾回收机制运行时判断内存是否已满，如果内存已满则回收，内存充足则不回收。
弱：垃圾回收机制运行后不论内存是否充足都会立即回收。
虚：虚引用和没有引用一样，必须配合引用队列使用。
我们来看例子：
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<String,SoftReference> 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<String> queue = new ReferenceQueue<String>();//引用队列Reference<String> reStrong = new SoftReference<>(strong);Reference<String> reSoft = new SoftReference<>(soft);//reSoft对"soft"的软引用Reference<String> reWeak = new WeakReference<>(weak);//reWeak对"weak"的弱引用Reference<String> 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前：strong soft运行gc前：soft weak运行gc前：weak phantom运行gc前：null ----------------------- strong运行gc后：strong soft运行gc后：soft weak运行gc后：null phantom运行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<String,SoftReference> m = new HashMap<>();public static void main(String args[]){String weak = "weak";//weak对"weak"的强引用Reference<String> 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）错误，很适合做为缓存。
当一些只需要少量使用较大数据时，我们可以采用弱引用，防止其占用内存。
这些可以根据具体使用情况优化引用关系。
这里有一个别人举得使用软引用优化内存溢出的例子：
例子出自：https://blog.csdn.net/arui319/article/details
//首先定义一个HashMap，保存软引用对象。
private Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>(); public void addBitmapToCache(String path) {// 强引用的Bitmap对象Bitmap bitmap = BitmapFactory.decodeFile(path);//此方法被执行完，bitmap会被清理，此时只保留下了imageCache中对// 软引用的Bitmap对象 //BitmapFactory.decodeFile(path)的软引用，要是实在不放心就对bitmap置null. SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(bitmap);// 将软引用对象放到到Map中使其缓存imageCache.put(path, softBitmap);}public Bitmap getBitmapByPath(String path) {// 从Map中取软引用的value(Bitmap)对象SoftReference<Bitmap> 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 stubMap<String ,String> 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<Map.Entry<String,String>> s_m = m.entrySet();Iterator<Map.Entry<String,String>>ite = s_m.iterator();while(ite.hasNext()){Map.Entry<String, String> 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 stubMap<String,String> 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<Season,String> m = new EnumMap<>(Season.class);//构造方法指定枚举类m.put(Season.SPRING, "春困");m.put(Season.SUMMER, "夏乏");m.put(Season.AUTUMN, "秋无力");m.put(Season.WINTER, "冬日正好眠");Set<Entry<Season, String>> s_m = m.entrySet();Iterator<Entry<Season, String>>ite = s_m.iterator();while(ite.hasNext()){Entry<Season, String> en = ite.next();System.out.println(en.getValue());}} }enum Season{SPRING,SUMMER,AUTUMN,WINTER }
运行结果：
春困
夏乏
秋无力
冬日正好眠
