import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

public class ReferenceExample {
    public static void main(String[] args) {
        // 創(chuàng)建強(qiáng)引用對(duì)象
        Object strongReference = new Object();

        // 創(chuàng)建軟引用
        SoftReference<Object> softReference = new SoftReference<>(new Object());

        // 創(chuàng)建弱引用
        WeakReference<Object> weakReference = new WeakReference<>(new Object());

        // 強(qiáng)制垃圾回收
        System.gc();

        // 打印各種引用類(lèi)型的對(duì)象，查看它們是否被回收
        System.out.println("強(qiáng)引用: " + strongReference);
        System.out.println("軟引用: " + softReference.get());
        System.out.println("弱引用: " + weakReference.get());
    }
}

import java.util.ArrayList;
import java.util.LinkedList;

public class DataStructureOptimization {
    public static void main(String[] args) {
        // 創(chuàng)建ArrayList和LinkedList，對(duì)比它們的內(nèi)存使用
        ArrayList<Integer> arrayList = new ArrayList<>();
        LinkedList<Integer> linkedList = new LinkedList<>();

        // 向兩種列表中添加元素
        for (int i = 0; i < 10000; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        // 觀察并分析內(nèi)存的使用情況
    }
}

public class ObjectCreationOptimization {
    public static void main(String[] args) {
        String baseString = "Hello World";
        for (int i = 0; i < 10000; i++) {
            // 避免在循環(huán)中重復(fù)創(chuàng)建相同的字符串對(duì)象
            processString(baseString);
        }
    }

    private static void processString(String s) {
        // 處理字符串
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ResourceRelease {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
            // 創(chuàng)建帶資源的try塊，自動(dòng)管理資源
            String line;
            while ((line = br.readLine()) != null) {
                // 逐行讀取文件內(nèi)容
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int cacheSize;

    public LRUCache(int cacheSize) {
        super(16, 0.75f, true);  // 啟用訪問(wèn)順序
        this.cacheSize = cacheSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 當(dāng)緩存項(xiàng)數(shù)量超過(guò)限制時(shí)，移除最老的緩存項(xiàng)
        return size() > cacheSize;
    }

    public static void main(String[] args) {
        // 創(chuàng)建LRU緩存
        LRUCache<Integer, String> cache = new LRUCache<>(3);
        cache.put(1, "A");
        cache.put(2, "B");
        cache.put(3, "C");
        cache.put(4, "D");  // 添加新項(xiàng)，移除最老的項(xiàng)
    }
}

public class AvoidLargeObjects {
    public static void main(String[] args) {
        // 創(chuàng)建一個(gè)大型數(shù)組
        int[] largeArray = new int[1000000];
        for (int i = 0; i < largeArray.length; i++) {
            largeArray[i] = i;
        }
        // 分析內(nèi)存使用情況
    }
}

// 代碼示例不適用，但建議定期使用內(nèi)存分析工具進(jìn)行檢查。

public class LoopOptimization {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 10000; i++) {
            // 簡(jiǎn)化循環(huán)邏輯，減少內(nèi)存消耗
            sum += i;
        }
    }
}

public class PrimitiveVsWrapper {
    public static void main(String[] args) {
        // 使用原生類(lèi)型
        int primitiveInt = 100;
        
        // 使用包裝類(lèi)型
        Integer wrapperInteger = Integer.valueOf(100);

        // 比較兩者在內(nèi)存使用上的差異
    }
}

public class GlobalVariables {
    private static Object globalObject = new Object();  // 靜態(tài)全局對(duì)象

    public static void main(String[] args) {
        // 使用全局變量
    }
}