在单线程环境下，同一个 Service 中多个方法需要复用某个 List

在单线程环境下，同一个 Service 中多个方法需要复用某个 List，核心优化目标是减少重复创建/初始化开销 、提升代码复用性，同时保证数据一致性。以下是具体优化策略，按场景分类说明：

一、场景1：List 为固定数据（初始化后不修改）

若 List 存储的是固定配置、枚举值等静态数据，可通过静态初始化 或依赖注入复用，避免每次方法调用时重复创建。

优化方案：

静态成员变量

将 List 声明为 Service 的静态成员，在类加载时初始化，全局复用：

java 复制代码

@Service
public class YourService {
    // 静态初始化固定List（仅加载一次）
    private static final List<String> FIXED_LIST = Arrays.asList("A", "B", "C");
    
    public void method1() {
        // 直接复用 FIXED_LIST
        FIXED_LIST.forEach(item -> { /* 业务逻辑 */ });
    }
    
    public void method2() {
        // 复用同一个List实例
        String first = FIXED_LIST.get(0);
    }
}

Spring 配置注入

若 List 数据来自配置文件（如 application.yml），通过 @Value 或 @ConfigurationProperties 注入，避免硬编码：

yaml 复制代码

# application.yml
app:
  fixed-list: ["A", "B", "C"]

java 复制代码

@Service
public class YourService {
    @Value("${app.fixed-list}")
    private List<String> fixedList; // Spring 初始化时注入，复用实例
    
    public void method1() { /* 使用 fixedList */ }
    public void method2() { /* 使用 fixedList */ }
}

二、场景2：List 为方法间传递的动态数据

若 List 是方法执行过程中生成的动态数据（如查询结果、临时计算数据），需在多个方法间传递，可通过成员变量 或上下文对象复用。

优化方案：

Service 成员变量（单例安全）

单线程环境下，Service 作为 Spring 单例 Bean，可通过实例成员变量存储临时 List（无需线程安全处理）：

java 复制代码

@Service
public class YourService {
    // 实例成员变量，单线程下方法间共享
    private List<Data> tempDataList;
    
    public void initData() {
        // 初始化List（仅调用一次，或每次业务流程开始时重置）
        this.tempDataList = queryDataFromDB(); // 动态查询数据
    }
    
    public void process1() {
        // 复用 tempDataList
        tempDataList.forEach(data -> processItem(data));
    }
    
    public void process2() {
        // 复用 tempDataList
        Data filtered = tempDataList.stream().filter(...).findFirst().orElse(null);
    }
    
    // 业务流程结束后清理（可选）
    public void clear() {
        this.tempDataList = null;
    }
}

注意：需保证业务流程的顺序性（先调用 initData，再调用 process1/process2），避免空指针。

上下文对象封装

若 List 需与其他数据（如用户信息、请求参数）绑定，可封装为上下文对象，通过方法参数或成员变量传递：

java 复制代码

// 上下文类
@Data
public class ServiceContext {
    private List<Data> dataList;
    // 其他上下文数据...
}

@Service
public class YourService {
    public void process(ServiceContext context) {
        method1(context);
        method2(context);
    }
    
    private void method1(ServiceContext context) {
        List<Data> list = context.getDataList(); // 复用List
    }
    
    private void method2(ServiceContext context) {
        List<Data> list = context.getDataList(); // 复用List
    }
}

三、场景3：List 为频繁修改的临时集合

若 List 需要频繁增删改，但多个方法需操作同一集合，可通过方法参数传递 或Builder 模式优化。

优化方案：

方法参数传递

将 List 作为方法参数传入，避免重复创建：

java 复制代码

@Service
public class YourService {
    public void processData() {
        List<Data> dataList = new ArrayList<>();
        fillData(dataList); // 填充数据
        filterData(dataList); // 过滤数据
        saveData(dataList); // 保存数据
    }
    
    private void fillData(List<Data> list) {
        list.add(new Data(...)); // 直接操作传入的List
    }
    
    private void filterData(List<Data> list) {
        list.removeIf(data -> ...); // 复用同一List
    }
}

链式调用（Builder 模式）
若需对 List 进行多步处理，可封装为链式方法，提升可读性：

java 复制代码

@Service
public class YourService {
    public List<Data> buildAndProcessList() {
        return new ArrayList<Data>()
                .stream()
                .peek(this::fillData)
                .peek(this::filterData)
                .collect(Collectors.toList());
    }
    
    private void fillData(Data data) { /* 填充逻辑 */ }
    private void filterData(Data data) { /* 过滤逻辑 */ }
}

四、通用优化原则

减少重复初始化 ：避免在每个方法中 new ArrayList<>()，尽量复用同一实例。
明确作用域：根据数据生命周期选择存储位置（静态变量/成员变量/方法参数）。
避免内存泄漏 ：若 List 存储大对象，业务结束后及时置空（如 tempDataList = null），帮助 GC 回收。
线程安全（单线程无需考虑） ：单线程环境下无需加锁，直接复用即可；若未来扩展为多线程，需切换为 ThreadLocal 或并发集合（如 CopyOnWriteArrayList）。

总结

单线程环境下的 List 复用核心是减少冗余创建 和明确数据共享方式：

固定数据用静态变量/配置注入；
动态临时数据用实例成员变量/上下文对象；
方法内传递用参数传递/链式调用。

根据具体业务场景选择合适的策略，既能提升性能，又能增强代码可读性和可维护性。