Java Stream API：重构代码以避免共享可变性

AtomicInteger counter = new AtomicInteger();
List<Cat> catList = new ArrayList<>(); // 共享的可变集合
List<Dog> dogList = new ArrayList<>(); // 共享的可变集合

List<Integer> numbers = Stream.iterate(1, e -> e + 1)
    .limit(5000)
    .collect(Collectors.toList());

// 将大列表分割成多个大小为500的子列表
Collection<List<Integer>> partitionedListOfNumbers = numbers.stream()
    .collect(Collectors.groupingBy(num -> counter.getAndIncrement() / 500))
    .values();

// 遍历分批列表，并修改外部集合
partitionedListOfNumbers.stream()
    .forEach(list -> {
        List<Cat> interimCatList = catRepo.fetchCats(list); // 从数据库获取Cat
        catList.addAll(interimCatList); // 修改外部catList
        List<Dog> interimDogList = dogRepo.fetchDogs(list); // 从数据库获取Dog
        dogList.addAll(interimDogList); // 修改外部dogList
    });

// 更简洁的数字列表生成方式
Collection<List<Integer>> partitionedListOfNumbers = IntStream.rangeClosed(1, 5000)
    .boxed() // 将IntStream转换为Stream<Integer>
    .collect(Collectors.groupingBy(num -> (num - 1) / 500)) // 修正分组逻辑，确保从0开始计数
    .values();

// 获取Cat列表：使用Stream API进行无副作用聚合
List<Cat> catList = partitionedListOfNumbers.stream()
    .map(list -> catRepo.fetchCats(list)) // 将每个小批次键列表映射为List<Cat>
    .flatMap(List::stream) // 将Stream<List<Cat>>扁平化为Stream<Cat>
    .collect(Collectors.toList()); // 收集所有Cat对象到新的List

// 获取Dog列表：同样使用Stream API进行无副作用聚合
List<Dog> dogList = partitionedListOfNumbers.stream()
    .map(list -> dogRepo.fetchDogs(list)) // 将每个小批次键列表映射为List<Dog>
    .flatMap(List::stream) // 将Stream<List<Dog>>扁平化为Stream<Dog>
    .collect(Collectors.toList()); // 收集所有Dog对象到新的List

import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

// 假设Cat和Dog类以及catRepo, dogRepo已定义

public class AnimalService {

    // 辅助方法，用于通用地从分批的键列表中获取实体
    private static <T> List<T> fetchEntities(
        Collection<List<Integer>> partitionedKeys,
        Function<List<Integer>, List<T>> fetchFunction) {

        return partitionedKeys.stream()
            .map(fetchFunction) // 应用传入的获取函数
            .flatMap(List::stream)
            .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        // 模拟数据仓库
        CatRepository catRepo = new CatRepository();
        DogRepository dogRepo = new DogRepository();

        // 生成并分区键列表
        Collection<List<Integer>> partitionedListOfNumbers = IntStream.rangeClosed(1, 5000)
            .boxed()
            .collect(Collectors.groupingBy(num -> (num - 1) / 500))
            .values();

        // 使用辅助方法获取Cat列表
        List<Cat> catList = fetchEntities(partitionedListOfNumbers, catRepo::fetchCats);
        System.out.println("Fetched " + catList.size() + " cats.");

        // 使用辅助方法获取Dog列表
        List<Dog> dogList = fetchEntities(partitionedListOfNumbers, dogRepo::fetchDogs);
        System.out.println("Fetched " + dogList.size() + " dogs.");
    }
}

// 模拟实体类和仓库接口
class Cat {}
class Dog {}

class CatRepository {
    public List<Cat> fetchCats(List<Integer> keys) {
        // 模拟数据库查询
        return keys.stream().map(k -> new Cat()).collect(Collectors.toList());
    }
}

class DogRepository {
    public List<Dog> fetchDogs(List<Integer> keys) {
        // 模拟数据库查询
        return keys.stream().map(k -> new Dog()).collect(Collectors.toList());
    }
}