利用笛卡尔积算法实现商品属性、广告画像属性拆分

生活啊，生活！你有多少苦难，又有多少甘甜！天空不会永远阴暗，当乌云退尽的时候，蓝天上灿烂的阳光就会照亮大地。青草照样会鲜绿无比，花朵仍然会蓬勃开放。——路遥《平凡的世界》

1. 笛卡尔积集

定义： 设A和B是两个集合，存在一个集合，它的元素是用A中元素为第一元素，B中元素为第二元素构成的有序二元数组。称他为集合A和B的笛卡尔积集，记为A×B。即：

A×B={(x,y)|x∈A∧y∈B}

例如： 集合A中有1和2两个元素，为：A={1,2}；集合B中有a,b,c 三个元素，为B={a,b,c}；那么笛卡尔积运算的结果数量则为6个。

A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}

2. 应用场景

• 笛卡尔积运算在程序中最常见的应用场景当属商品SKU规格生成了。一个产品通常会有多个属性，不同的产品属性则会生成不同的商品规格。比如说上某宝买件衣服，通常会有颜色、大小等属性，通过组合排列颜色、大小生成具体的商品信息。当然，这种单个产品下运算简单的循环也可以实现。但像某宝这种产品种类多的电商平台，产品属性的自由灵活多样，通过不断的写循环去实现会导致代码可读性、可用性不高等问题，通过笛卡尔积算法则可以以少量的代码来动态生成商品规格。

• 动态变量拆分等场景应用。比如在广告领域，通过拆分性别、年龄、地区、创意来生成多条具体的广告信息。

3. 代码实现

实现商品规格拆分和变量拆分

定义变量拆分对象

/**
 * 笛卡尔算法基类对象
 * @author HZI.HUI
 * @since 2020/12/23
 */
@Data
@Accessors(chain = true)
public class Descartes {

    private String key;

    private String value;

}

为提高代码的复用能力，这里直接抽取成一个类名为DescartesUtil 的工具类。工具类中的方法出、入参定义为泛型。

   /**
     * 笛卡尔积运算入口
     *
     * @param originalList 待运算数据集合
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> descartes(List<List<T>> originalList) {
        List<List<T>> res = new ArrayList<>();
        if (originalList == null || originalList.size() == 0) {
            return res;
        }
        recursive(originalList, 0, res, new ArrayList<>());
        return res;
    }

    /**
     * 递归回溯运算
     *
     * @param originalList 待运算数据集合
     * @param index 当前待运算数据集合下标
     * @param res 已运算结果集
     * @param curList 当前运算集合
     * @param <T>
     */
    private static <T> void recursive(List<List<T>> originalList, int index, List<List<T>> res, List<T> curList) {
        if (curList.size() == originalList.size()) {
            res.add(new ArrayList<>(curList));
        } else {
            for (int j = 0; j < originalList.get(index).size(); j++) {
                curList.add(originalList.get(index).get(j));
                recursive(originalList, index + 1, res, curList);
                curList.remove(curList.size() - 1);
            }
        }
    }
    
     /**
     * 构建笛卡尔数据对象集合
     * @param key 数据类型key
     * @param list 数据集合
     * @return
     */
    public static List<Descartes> buildDescartesList(String key,List<Object> list){
        List<Descartes> descartesList = new ArrayList<>();
        for (Object t : list) {
            descartesList.add(new Descartes().setKey(key).setValue(t.toString()));
        }
        return descartesList;
    }


    /**
     * 获取笛卡尔运算的值
     * @param key
     * @return
     */
    public static <T extends Descartes> String getDescartesValue(String key, List<T> list){
        if(StrUtil.isBlank(key)){
            return null;
        }
        for (T t : list) {
            if (StrUtil.equals(key,t.getKey())) {
                return t.getValue();
            }
        }
        return null;
    }
    
    

4.生成商品规格

测试

/**
     * 使用案例
     * @param args
     */
    public static void main(String[] args) {
        List<String> colorList = new ArrayList(Arrays.asList("白色","蓝色","粉色"));
        List<String> sizeList = new ArrayList(Arrays.asList("M","S","L","XL"));
        List<List<String>> originalList = new ArrayList<>(Arrays.asList(colorList,sizeList));
        List<List<String>> resultList = descartes(originalList);
        System.out.println("笛卡尔乘积运算: 共 " + resultList.size() + " 个结果");
        for (List<String> list : resultList) {
            for (String s : list) {
                System.out.print(s+" ");
            }
            System.out.println();
        }

运算结果

5.变量拆分使用

测试

/**
     * 使用案例
     * @param args
     */
    public static void main(String[] args) {

        List<Descartes> sexList = buildDescartesList("sex", Arrays.asList("男","女"));
        List<Descartes> regionList = buildDescartesList("region", Arrays.asList("110000","440000"));
        List<Descartes> ageList = buildDescartesList("age", Arrays.asList("1","2","3"));
        List<List<Descartes>> originalList = new ArrayList<>(Arrays.asList(sexList,regionList,ageList));

        // 开始运算
        List<List<Descartes>> res = descartes(originalList);
        System.out.println("笛卡尔乘积运算: 共 " + res.size() + " 个结果");
        for (List<Descartes> list : res) {
            // 性别
            ItemConditionObject lineItemConditionObject = new LineItemConditionObject();
            lineItemConditionObject.setGender(getDescartesValue("sex",list));
            // 地理位置
            LineItemConditionObject.GeoLocation geoLocation = new LineItemConditionObject.GeoLocation();
            geoLocation.setRegions(Collections.singletonList(Long.parseLong(Objects.requireNonNull(getDescartesValue("region", list)))));
            lineItemConditionObject.setGeoLocation(geoLocation);
            // 年龄
            LineItemConditionObject.BaseStruct baseStruct = TargetingTagsAgeTypeEnum.getAge(Integer.valueOf(Objects.requireNonNull(getDescartesValue("age", list))));
            lineItemConditionObject.setAge(baseStruct);
            System.out.println(JsonUtil.toStr(tencentadLineItemConditionObject));
        }
    }

运算结果