Java中静态方法创建对象实例的内存占用与生命周期解析

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

public class Service {

    public void doSomething() {
        System.out.println("--- 开始执行 doSomething ---");
        for (int i = 0; i < 5; i++) { // 循环次数减少，方便观察
            // 每次循环都会创建一个新的 RandomSumBuilder 实例
            int sum = RandomSumBuilder.add().build();
            System.out.println("Random sum : " + sum);
            // 在此行之后，RandomSumBuilder 实例和其内部的 ArrayList 实例
            // 如果没有被其他地方引用，将立即成为垃圾回收的候选者。
        }
        System.out.println("--- doSomething 执行结束 ---");
        // 此时，循环中创建的所有 RandomSumBuilder 实例都已不再可达。
    }

    public static void main(String[] args) {
        Service service = new Service();
        service.doSomething();
        // 显式触发GC，观察效果（实际应用中不推荐）
        System.gc();
        try {
            Thread.sleep(1000); // 稍作等待，给GC一些时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("主方法执行结束。");
    }
}

class RandomSumBuilder {
    private List<Integer> aList = new ArrayList<>();

    public RandomSumBuilder() {
        // System.out.println("RandomSumBuilder 实例被创建: " + this.hashCode());
    }

    public static RandomSumBuilder add() {
        RandomSumBuilder randomSumBuilder = new RandomSumBuilder();
        randomSumBuilder.aList.add(new Random().nextInt(11)); // 添加一个随机数
        return randomSumBuilder;
    }

    // 可以添加更多方法以支持链式调用，使其更像一个真正的Builder
    public RandomSumBuilder addNumber(int number) {
        this.aList.add(number);
        return this; // 返回自身以支持链式调用
    }

    public int build() {
        int sum = aList.stream()
                .reduce(Integer::sum)
                .orElse(0);
        // System.out.println("RandomSumBuilder 实例被构建并返回结果: " + this.hashCode() + ", sum: " + sum);
        return sum;
    }

    @Override
    protected void finalize() throws Throwable {
        // System.out.println("RandomSumBuilder 实例被垃圾回收: " + this.hashCode());
        super.finalize();
    }
}

public class ComplexObject {
    private final String partA;
    private final int partB;
    private final boolean partC;

    private ComplexObject(Builder builder) {
        this.partA = builder.partA;
        this.partB = builder.partB;
        this.partC = builder.partC;
    }

    public static class Builder {
        private String partA;
        private int partB;
        private boolean partC;

        public Builder() {}

        public Builder withPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder withPartB(int partB) {
            this.partB = partB;
            return this;
        }

        public Builder withPartC(boolean partC) {
            this.partC = partC;
            return this;
        }

        public ComplexObject build() {
            return new ComplexObject(this);
        }
    }

    // Getters
    public String getPartA() { return partA; }
    public int getPartB() { return partB; }
    public boolean isPartC() { return partC; }

    @Override
    public String toString() {
        return "ComplexObject{" +
               "partA='" + partA + '\'' +
               ", partB=" + partB +
               ", partC=" + partC +
               '}';
    }
}

ComplexObject obj = new ComplexObject.Builder()
                        .withPartA("ValueA")
                        .withPartB(123)
                        .withPartC(true)
                        .build();
System.out.println(obj);