新手必看 Java 集合内存管理实用技巧详解

ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    list.add(i);
}

- **LinkedList**：由节点组成，每个节点包含元素和指向前驱、后继节点的引用。内存空间不连续，适合频繁插入、删除操作。相比ArrayList，节点对象因包含额外引用，内存占用更多。例如：

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("element1");
linkedList.add("element2");

- **HashMap**：由数组和链表（或红黑树）组成。通过哈希算法计算元素存储位置，数组存储哈希桶，冲突时用链表（或红黑树）解决。每个键值对是一个Entry对象，包含键、值、哈希值和指向下一个Entry的引用。当哈希表负载因子（默认0.75）达到阈值，会扩容，重建哈希表，开销大。例如：

HashMap<String, Integer> map = new HashMap<>();
map.put("key1", 1);
map.put("key2", 2);

class BigObject {
    private byte[] data = new byte[1024 * 1024]; // 1MB数据
}
ArrayList<BigObject> bigObjectList = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    bigObjectList.add(new BigObject());
}

ArrayList<String> list = new ArrayList<>(50);

- **及时清理无用元素**：不再使用元素时，从集合移除。如处理完一批任务后，清空任务列表：

ArrayList<Runnable> taskList = new ArrayList<>();
// 添加任务
taskList.add(() -> System.out.println("Task 1"));
taskList.add(() -> System.out.println("Task 2"));
// 执行任务
for (Runnable task : taskList) {
    task.run();
}
// 清理任务列表
taskList.clear();

ArrayList<Integer> sourceList = new ArrayList<>();
sourceList.add(1);
sourceList.add(2);
ArrayList<Integer> targetList = new ArrayList<>();
targetList.addAll(sourceList);

- **批量操作优于单元素操作**：添加或删除多个元素，用批量操作方法。如向HashSet添加多个元素：

HashSet<String> set = new HashSet<>();
List<String> newElements = Arrays.asList("element1", "element2", "element3");
set.addAll(newElements);

public class MemoryLeakExample {
    private static List<Object> staticList = new ArrayList<>();
    public static void addObjectToStaticList(Object obj) {
        staticList.add(obj);
    }
}
// 在其他地方调用
Object largeObject = new byte[1024 * 1024]; // 1MB对象
MemoryLeakExample.addObjectToStaticList(largeObject);
// largeObject不再使用，但因静态集合引用无法被回收

- **集合未正确清理**：使用完集合未移除元素，元素持续占用内存。如缓存集合，缓存数据过期未清理：

class Cache {
    private List<Data> cacheList = new ArrayList<>();
    public void addToCache(Data data) {
        cacheList.add(data);
    }
    // 未实现清理过期数据方法
}

class Cache {
    private List<CacheData> cacheList = new ArrayList<>();
    public void addToCache(CacheData data) {
        cacheList.add(data);
    }
    public void cleanExpiredCache() {
        long currentTime = System.currentTimeMillis();
        cacheList.removeIf(cacheData -> cacheData.getExpireTime() < currentTime);
    }
}
class CacheData {
    private Object data;
    private long expireTime;
    public CacheData(Object data, long expireTime) {
        this.data = data;
        this.expireTime = expireTime;
    }
    public long getExpireTime() {
        return expireTime;
    }
}

- **使用弱引用集合**：需临时存储对象，对象不再被其他地方引用时可被回收，用弱引用集合，如WeakHashMap。如缓存临时数据：

WeakHashMap<String, Object> weakCache = new WeakHashMap<>();
Object tempObject = new Object();
weakCache.put("tempKey", tempObject);
// 若tempObject在其他地方不再被引用，可能被垃圾回收，即使WeakHashMap中还有引用

class Student {
    private String name;
    private int age;
    private double[] scores; // 多门课程成绩
    public Student(String name, int age, double[] scores) {
        this.name = name;
        this.age = age;
        this.scores = scores;
    }
}
ArrayList<Student> studentList = new ArrayList<>();
// 模拟添加大量学生
for (int i = 0; i < 10000; i++) {
    double[] scores = new double[10];
    for (int j = 0; j < 10; j++) {
        scores[j] = Math.random() * 100;
    }
    studentList.add(new Student("Student" + i, (int) (Math.random() * 20 + 18), scores));
}

- **问题**：未指定ArrayList初始容量，添加大量学生时频繁扩容，内存频繁分配和复制；学生对象包含成绩数组，占用大量内存，且未对不再使用的学生对象处理，可能内存泄漏。优化方案及效果：指定ArrayList初始容量：预计添加10000个学生，创建ArrayList时指定容量：

ArrayList<Student> studentList = new ArrayList<>(10000);

- **及时清理无用学生对象**：如学生毕业从系统移除，添加移除方法：

public void removeGraduatedStudent(ArrayList<Student> list, String name) {
    list.removeIf(student -> student.getName().equals(name));
}

- **效果**：减少ArrayList扩容次数，降低内存分配和复制开销；及时清理无用学生对象，避免内存泄漏，内存占用降低，系统性能提升。