做完题目后，很高兴的发给面试官了，第三天，面试官就说做的不好，pass了。想问问大家，问题出在哪儿呢？是不是数据不能完全加载到内存的算法有问题呢？

import com.alibaba.fastjson.JSON;
import com.alibaba.mos.api.ItemService;
import com.alibaba.mos.api.SkuReadService;
import com.alibaba.mos.dao.ItemDAO;
import com.alibaba.mos.data.ItemDO;
import com.alibaba.mos.data.SkuDO;
import com.alibaba.mos.util.SortedMapUtils;
import com.alibaba.mos.vo.SortedInventoryVO;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.Assert;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 注意： 假设sku数据很多, 无法将sku列表完全加载到内存中
 */
@SpringBootTest
@Slf4j
class Interview2Tests {

    @Autowired
    SkuReadService skuReadService;

    @Autowired
    ItemService<ItemDO> itemService;
    @Autowired
    ItemDAO itemDAO;

    /**
     * 试题1:
     * 注意: 假设sku数据很多, 无法将sku列表完全加载到内存中
     * <p>
     * 实现com.alibaba.mos.api.SkuReadService#loadSkus(com.alibaba.mos.api.SkuReadService.SkuHandler)
     * 从/resources/data/skus.txt读取数据并逐条打印数据，数据字段用'|'分隔
     */
    @Test
    void readDataFromExcelWithHandlerTest() {
        AtomicInteger count = new AtomicInteger();
        skuReadService.loadSkus(skuDO -> {
            log.info("读取SKU信息={}", JSON.toJSONString(skuDO));
            count.incrementAndGet();
            return skuDO;
        });
        Assert.isTrue(count.get() > 0, "未能读取商品列表");
    }

    /**
     * 试题2:
     * 注意: 假设sku数据很多, 无法将sku列表完全加载到内存中
     * <p>
     * 计算以下统计值:
     * 1、假设所有sku的价格都是精确到1元且一定小于1万元, 获取价格为中位数价格的任意一个skuId（比如价格为1、1、2、25、25、25、25，中位数价格是【2】）
     * 2、假设所有sku的价格都是精确到1元且一定小于1万元, 获取按价格排序后在中间的价格（比如价格为1、1、2、25、25、25、25，按照题目要求，是第4个价格【25】）
     * 3、每个渠道库存量为前五的skuId列表, 例如: miao:[1,2,3,4,5],tmall:[3,4,5,6,7],intime:[7,8,4,3,1]
     * 4、所有sku的总价值
     */
    @Test
    void statisticsDataTest() {
        //第1题：
        //小顶堆，存储较大的数
        Queue<BigDecimal> bigData = new PriorityQueue<>();
        //大顶堆，存储较小的数
        Queue<BigDecimal> smallData = new PriorityQueue<>((x, y) -> (y.compareTo(x)));

        skuReadService.loadSkus(skuDO -> {
            if (bigData.size() == smallData.size()) {
                //bigData中存储较大的数
                smallData.add(skuDO.getPrice());
                bigData.add(smallData.poll());
            } else {
                //向smallData存储较小数
                bigData.add(skuDO.getPrice());
                smallData.add(bigData.poll());
            }
            return skuDO;
        });

        BigDecimal medium = bigData.size() != smallData.size() ? bigData.peek() :
                (bigData.peek().add(smallData.peek())).divide(new BigDecimal("2"), 2, BigDecimal.ROUND_UP);
        log.info("价格的中位数为：" + medium);
        Assert.isTrue(medium.compareTo(new BigDecimal("0"))>0, "价格中位数计算错误");

        //第2题：大数据排序可能需要将数据分块，分别进行快速排序后再进行归并处理
        //此处简单处理，使用Collections.sort进行排序
        List<BigDecimal> priceList = new ArrayList<>();
        skuReadService.loadSkus(skuDO -> {
            priceList.add(skuDO.getPrice());
            return skuDO;
        });
        Collections.sort(priceList);
        log.info("价格排序后在中间的价格为：" + priceList.get(priceList.size() / 2));
        Assert.isTrue(priceList.size()>0, "价格排序后在中间的价格计算错误");


        //第3题：
        HashMap<String, TreeMap<SortedInventoryVO, BigDecimal>> groupResult = new HashMap<>();
        skuReadService.loadSkus(skuDO -> {
            //先进行分组和排序
            skuReadService.getTopSkusGroupByChannel(skuDO, groupResult);
            return skuDO;
        });

        //再获取topN数据,具体实现在utils中
        Map<String, List<String>> res = SortedMapUtils.getTopN(groupResult, 5);
        log.info("每个渠道库存量为前五的skuId列表为：" + res);
        Assert.isTrue(res.size()==3, "计算每个渠道库存量为前五的skuId列表失败");


        //第4题：
        final BigDecimal[] sum = {new BigDecimal("0")};
        skuReadService.loadSkus(skuDO -> {
            BigDecimal skuTotalInventory = skuReadService.getSkuTotalInventory(skuDO);
            sum[0] = sum[0].add(skuDO.getPrice().multiply(skuTotalInventory));

            return skuDO;
        });
        log.info("所有sku的总价值为：" + sum[0]);
        Assert.isTrue(sum[0].compareTo(new BigDecimal("669"))>0, "所有sku的总价值计算失败");
    }

    /**
     * 试题3:
     * <p>
     * 基于试题1, 在com.alibaba.mos.service.ItemServiceImpl中实现一个生产者消费者, 将sku列表聚合为商品并通过com.alibaba.mos.dao.ItemDAO保存到数据库中
     * 注意通过com.alibaba.mos.dao.ItemDAO进行数据操作无需考虑内存问题
     * <p>
     * 聚合规则为:
     * 对于sku type为原始商品(ORIGIN)的, 按货号(artNo)聚合成ITEM
     * 对于sku type为数字化商品(DIGITAL)的, 按spuId聚合成ITEM
     * 聚合结果需要包含: item的最大价格、最小价格、sku列表及总库存
     */
    @Test
    void aggregationSkusWithConsumerProviderTest() {
        itemService.aggregation();
        Map<String, ItemDO> artItemDb = itemDAO.getArtItemDb();
        Map<String, ItemDO> spuItemDb = itemDAO.getSpuItemDb();

        log.info("原始商品(ORIGIN)聚合后的结果为：{}", artItemDb);
        log.info("数字化商品(DIGITAL)聚合后的结果为：{}", spuItemDb);

    }
}

其余代码在gitee上

https://gitee.com/sighting33/interview/blob/master/src/test/java/com/alibaba/mos/interview/Interview2Tests.java