java 中都有哪些引用类型？

import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;

public class ImageCache {
    private Map<String, SoftReference<byte[]>> cache = new HashMap<>();

    public byte[] getImage(String imageUrl) {
        SoftReference<byte[]> softRef = cache.get(imageUrl);
        if (softRef != null && softRef.get() != null) {
            System.out.println("从缓存中获取图片: " + imageUrl);
            return softRef.get();
        }

        // 缓存中没有或者已经被回收，重新加载
        System.out.println("加载图片到缓存: " + imageUrl);
        byte[] imageData = loadImageFromDiskOrNetwork(imageUrl); // 模拟加载
        cache.put(imageUrl, new SoftReference<>(imageData));
        return imageData;
    }

    private byte[] loadImageFromDiskOrNetwork(String url) {
        // 模拟加载图片数据
        return new byte[1024 * 1024]; // 1MB
    }

    public static void main(String[] args) {
        ImageCache imageCache = new ImageCache();
        imageCache.getImage("http://example.com/img1.jpg");
        imageCache.getImage("http://example.com/img2.jpg");

        // 模拟内存紧张，触发GC
        System.out.println("尝试触发GC...");
        System.gc(); // 提示GC，不保证立即执行

        // 再次获取，如果内存紧张，可能需要重新加载
        imageCache.getImage("http://example.com/img1.jpg");
    }
}

import java.lang.ref.WeakReference;
import java.util.WeakHashMap;
import java.util.Map;

public class WeakRefExample {
    public static void main(String[] args) throws InterruptedException {
        // 示例1: WeakHashMap
        Map<MyKey, String> weakMap = new WeakHashMap<>();
        MyKey key1 = new MyKey("KeyA");
        MyKey key2 = new MyKey("KeyB");

        weakMap.put(key1, "ValueA");
        weakMap.put(key2, "ValueB");

        System.out.println("WeakHashMap 初始大小: " + weakMap.size()); // 2

        key1 = null; // 解除强引用
        System.out.println("KeyA 的强引用解除。");

        System.gc(); // 提示GC
        Thread.sleep(100); // 给GC一点时间

        System.out.println("GC 后 WeakHashMap 大小: " + weakMap.size()); // 可能为1，KeyA被回收

        // 示例2: 监听器模式
        MyObject obj = new MyObject("监听对象");
        MyListener listener = new MyListener(obj); // 监听器持有对象的弱引用

        // 模拟其他地方不再持有MyObject的强引用
        obj = null;

        System.gc();
        Thread.sleep(100);

        // 理论上，MyObject应该被回收，listener内部的弱引用会失效
        listener.checkObject(); // 应该输出 "监听的对象已被回收"
    }

    static class MyKey {
        String name;
        public MyKey(String name) { this.name = name; }
        @Override public String toString() { return "MyKey{" + name + "}"; }
        @Override public int hashCode() { return name.hashCode(); }
        @Override public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            MyKey myKey = (MyKey) obj;
            return name.equals(myKey.name);
        }
        @Override protected void finalize() throws Throwable {
            System.out.println(name + " 被回收了。");
        }
    }

    static class MyObject {
        String name;
        public MyObject(String name) { this.name = name; }
        @Override protected void finalize() throws Throwable {
            System.out.println(name + " 被回收了。");
        }
    }

    static class MyListener {
        private WeakReference<MyObject> targetRef;

        public MyListener(MyObject target) {
            this.targetRef = new WeakReference<>(target);
        }

        public void checkObject() {
            MyObject target = targetRef.get();
            if (target != null) {
                System.out.println("监听器还在监听: " + target.name);
            } else {
                System.out.println("监听的对象已被回收。");
            }
        }
    }
}

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.nio.ByteBuffer;

public class PhantomRefCleanup {
    public static void main(String[] args) throws InterruptedException {
        ReferenceQueue<ByteBuffer> queue = new ReferenceQueue<>();
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024 * 1024); // 分配1MB直接内存

        // 创建一个虚引用，并关联到引用队列
        PhantomReference<ByteBuffer> phantomRef = new PhantomReference<>(directBuffer, queue);

        System.out.println("直接内存分配完成。");

        // 解除对直接内存的强引用，使其成为可回收对象
        directBuffer = null;
        System.out.println("解除 directBuffer 的强引用。");

        // 启动一个线程来监控引用队列
        Thread cleanerThread = new Thread(() -> {
            try {
                System.out.println("清理线程启动，等待虚引用进入队列...");
                // 当虚引用指向的对象被回收时，虚引用自身会被加入到队列中
                PhantomReference<ByteBuffer> collectedRef = (PhantomReference<ByteBuffer>) queue.remove();
                System.out.println("虚引用进入队列，对象已被回收！可以执行资源清理操作了。");
                // 在这里执行释放 directBuffer 对应的本地内存的操作
                // 例如：sun.misc.Cleaner.clean(directBuffer); (实际操作更复杂，这里仅为示意)
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        cleanerThread.setDaemon(true); // 设置为守护线程，主程序退出时它也退出
        cleanerThread.start();

        System.out.println("尝试触发GC...");
        System.gc(); // 提示GC

        // 等待清理线程完成
        Thread.sleep(500);
        System.out.println("主线程结束。");
    }
}