1 背景:
    上游系统给本系统一批订单,数量x条(),本系统将订单平均分配给下游系统的员工中

2 方案
    先算出每个员工分出的订单总数,放到数组中,然后将员工id放入map的key中
    相应的订单数放进map的value中
    在分配的时候,根据map中的员工id和相应的总数去做分配
3 分配方法
    OrderCount : 订单总数
    staffCount : 员工总数
    A: 商 = OrderCount / staffCount , 余数 = OrderCount % staffCount
    B: 商 == 0  订单总数<员工总数 每个员工分配1个
    C: 商 > 0 && 余数 == 0 平均分配
    D: 商 > 0 && 余数 > 0  不平均分配
  这三种情况都要照顾到 

 



package com.sitech.huxiao.batch.ElectricCanalAgentBatch;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.sitech.huxiao.domin.DistributionRuleEntity;

import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;

/**
 * @oauth: qiangSW
 * @date: 2020/3/5 21:12
 * @description: com.sitech.huxiao.batch.ElectricCanalAgentBatch
 * @doc:
 */
public class Demo {

    /**
     * 平均分配
     *
     * @param orderCount 订单总数
     * @param staffCount 员工总数
     * @return int[] 每个员工分配的总数
     */
    public int[] distribution(List<Object> orderCount, int staffCount) {
        Map<String, Integer> map = Maps.newHashMap();
        List<DistributionRuleEntity> list = Lists.newArrayList();
        if (CollectionUtils.isEmpty(orderCount) || staffCount == 0) {
            return null;
        }
        int agentMean = orderCount.size() / staffCount;
        int agentRemainder = orderCount.size() % staffCount;
        /*计算每个员工应该分配的总数*/
        int[] agentCount = null;
        if (agentMean == 0) {
            agentCount = meanEqual0(staffCount);
        } else if (agentMean > 0 && agentRemainder == 0) {
            agentCount = meanGreater0(staffCount, agentMean);
        } else if (agentMean > 0 && agentRemainder > 0) {
            agentCount = meanAndRemainderGreater0(staffCount, agentMean, agentRemainder);
        }

        return agentCount;
    }

    /**
     * 平均数 == 0
     *
     * @param number
     * @return
     */
    public int[] meanEqual0(int number) {
        int[] array = new int[number];
        for (int i = 0; i < number; i++) {
            array[i] = 1;
        }
        return array;
    }

    /**
     * 平均数 > 0 余数 == 0
     *
     * @param arraySize
     * @param mean
     * @return
     */
    public int[] meanGreater0(int arraySize, int mean) {
        int[] array = new int[arraySize];
        for (int i = 0; i < arraySize; i++) {
            array[i] = mean;
        }
        return array;
    }

    /**
     * 平均数 > 0 余数 >0
     *
     * @param arraySize
     * @param mean
     * @param remainder
     * @return
     */
    public int[] meanAndRemainderGreater0(int arraySize, int mean, int remainder) {
        int[] array = new int[arraySize];
        for (int i = 0; i < arraySize; i++) {
            if (remainder != 0 && i == remainder) {
                array[i] = mean + 1;
            } else {
                array[i] = mean;
            }
        }
        return array;
    }
}


 

 

 

最近公司有业务需求：要求实现批量分配操作，详情如下：

选择多个客户
选择多个员工
给每个员工分配客户
要求分配的客户数量尽量平均
选择的员工数大于选择的客户数时，一个员工分配一个客户，不够的就不分配
选择的员工数等于客户数时，一个员工对应一个客户
分配的客户最好是随机的。
为了实现上述需求，需要设计一个随机平均分配算法
一开始我的设计思路比较简单，遍历员工集合和客户集合，依次分配单个客户给每个员工，直到分完为止，但是这种实现效率很低，也达不到随机的效果。
转变思路，先分析、设计数据存储结构，入参为两个List<String>集合，返回数据类型为：
一、 Map<String, List<String>>，每个员工作为key，value为分配的客户列表;
二、List<Map<String, List<String>>>，员工作为key，value为分配给他的客户，每个员工-客户列表都对应一个Map<String, List<String>>集合，这样所有的员工-客户列表组合成一个List<Map<String, List<String>>>集合
最终我采用了第二种数据结构，下面是实现代码：
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* @author gxl
* @version 1.0
* @description 平均分配算法
* @date 2019-09-11 08:53
*/
public class AverageDataUtil {

   /**
    * 定义存储待分配数据集合
    */
   private static List<String> list = Lists.newArrayList();

   /**
    * 定义存储分组数据的结构，Map去除泛型，适配多种数据类型格式，使用时需注意
    */
   private static List<Map> los = Lists.newArrayList();

   /**
    * 供外部调用的平均分配方法
    *
    * @param visitorIds 客户列表
    * @param sellerIds  员工列表
    * @return List<Map>
    */
   public static List<Map> averageData(List<String> visitorIds, List<String> sellerIds) {
       initCollections(visitorIds, sellerIds);
       if (visitorIds.size() >= sellerIds.size()) {
           groupByData(los.size());
           return getMaps();
       } else {
           groupByData(list.size());
           return getMaps();
       }
   }

   /**
    * 返回数据，清空静态缓存
    *
    * @return List<Map>
    */
   @NotNull
   private static List<Map> getMaps() {
       List<Map> listMap = Lists.newArrayList();
       listMap.addAll(los);
       //清空静态数据
       los = Lists.newArrayList();
       list = Lists.newArrayList();
       return listMap;
   }

   /**
    * 分配数据
    *
    * @param size       分组大小
    */
   private static void groupByData(int size) {
       List<String> augmented = list;

       List<List<String>> lists = chunk2(augmented, size);

       for (int i = 0; i < size; i++) {
           Map map = los.get(i);
           Iterator iterator = map.keySet().iterator();
           if (iterator.hasNext()) {
               String next = (String) iterator.next();
               map.put(next, lists.get(i));
           }
       }
   }

   /**
    * 初始化集合数据
    *
    * @param visitorIds 待分配数据
    * @param sellerIds  分配目标
    */
   private static void initCollections(List<String> visitorIds, List<String> sellerIds) {
       //每次调用前清空数据
       if (list.size() > 0) {
           list = Lists.newArrayList();
       }
       if (los.size() > 0) {
           los = Lists.newArrayList();
       }
       list.addAll(visitorIds);
       List<Map<String, List<String>>> list1 = new ArrayList<>();
       for (String sellerId : sellerIds) {
           Map<String, List<String>> map = new HashMap<>(16);
           List<String> list = new ArrayList<>();
           map.put(sellerId, list);
           list1.add(map);
       }
       los.addAll(list1);
   }

   /**
    * 分组数据-核心算法，勿动
    *
    * @param list  需分配数据
    * @param group 分组大小
    * @param <T>   分组数据泛型
    * @return 分组结果
    */
   private static <T> List<List<T>> chunk2(List<T> list, int group) {
       if (CollectionUtils.isEmpty(list)) {
           return Lists.newArrayList();
       }
       List<List<T>> result = Lists.newArrayList();
       Map<Integer, Set<T>> temp = Maps.newHashMap();
       for (int i = 0; i < list.size(); i++) {
           if (temp.containsKey(i % group)) {
               Set<T> ts = temp.get(i % group);
               ts.add(list.get(i));
               temp.put(i % group, ts);
           } else {
               Set<T> ts = Sets.newHashSet();
               ts.add(list.get(i));
               temp.put(i % group, ts);
           }
       }
       for (Set<T> ts : temp.values()) {
           result.add(Lists.newArrayList(ts));
       }
       return result;
   }
   
   public static void main(String[] args) {
       List<String> visitorIds = new ArrayList<>();
       visitorIds.add("aa");
       visitorIds.add("bb");
       visitorIds.add("cc");
       visitorIds.add("dd");
       visitorIds.add("ee");
       visitorIds.add("ff");
       visitorIds.add("gg");
       visitorIds.add("hh");
       visitorIds.add("ii");
       visitorIds.add("jj");
       visitorIds.add("kk");
       List<String> sellerIds = new ArrayList<>();
       sellerIds.add("11");
       sellerIds.add("22");
       sellerIds.add("33");
       sellerIds.add("44");
       sellerIds.add("55");
       sellerIds.add("66");
       sellerIds.add("77");
       sellerIds.add("88");
       sellerIds.add("99");
       sellerIds.add("1010");
       sellerIds.add("1111");
       List<Map> maps = averageData(visitorIds, sellerIds);
       System.out.println(maps);
   }

}


这个代码可能还存在部分问题，可以继续优化改进，有什么建议的话，可以在评论区回复，毕竟我也只是个码农，对算法什么的不是很了解 - -


 

#平均分配list数据到4个list中

def ave_test():

    #list1 = [[1,2]]

    #list1 = [[1,2],[3,4]]

    #list1 = [[1,2],[3,4],[5,6]]

    #list1 = [[1,2],[3,4],[5,6],[7,8]]

    list1 = [[1,2],[3,4],[5,6],[7,8],[56,1],[57,1],[36,1]]

    print("len:")

    print(len(list1))

    li1=[]

    li2=[]

    li3=[]

    li4=[]

    len1=len(list1)

    x = 0

    x1=0

    m=0

    y1=0

    if len1==1:

        li1 = list1

    if len1 == 2:

        for i in range(len(list1)):

            if i == 0:

                li1.append(list1[i])

            else:

                li2.append(list1[i])

    if len1 == 3:

        for i in range(len(list1)):

            if i == 0:

                li1.append(list1[i])

            elif i == 1:

                li2.append(list1[i])

            else:

                li3.append(list1[i])

    if len1>3:

        l2 = len1//2;

        m = l2

        print("m")

        print(m)

        if m>0:

            x1=m//2

            print("x1:")

            print(x1)

            if (len1-m)>1:

                t= (len1-m)//2

                y1=m+t

                print("y1")

                print(y1)

        for i in range(len(list1)):

            if i<x1:

                li1.append(list1[i])

            elif i>=x and i<m:

                li2.append(list1[i])

            elif i>=m and i<y1:

                li3.append(list1[i])

            else:

                li4.append(list1[i])

    if li1:

       print("li1")

       print(li1)

    if li2:

       print("li2")

       print(li2)

    if li3:

       print("li3")

       print(li3)

    if li4:

       print("li4")

       print(li4)

#end ave

'''

运行结果：

li1

[[1, 2]]

li2

[[3, 4], [5, 6]]

li3

[[7, 8], [56, 1]]

li4

[[57, 1], [36, 1]]

'''

文章目录
需求
算法
示例
多次实验结果

需求
1万个设备的IMEI固定且尽量平均的分配到四个组。
算法
算法来自文章【数据结构与算法】一致性Hash算法及Java实践
public static int FnvHash(String key) {
        final int p = 16777619;
        long hash = (int) 2166136261L;
        for (int i = 0, n = key.length(); i < n; i++) {
            hash = (hash ^ key.charAt(i)) * p;
        }
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        return ((int) hash & 0x7FFFFFFF) ;
}

示例
	@Test
    public void contextLoads() {
    	//imei前缀
        String base = "86582003";
        //a,b,c,d,分别记录四组分到的imei个数
        int a = 0;
        int b = 0;
        int c = 0;
        int d = 0;
        for (int i = 0; i < 10000; i++) {
        	//模拟15位的imei码
            String str = base + (int) (Math.random() * 9) * 10 + "" + (int) ((Math.random() * 9 + 1) * 100000);
            //模4 将FnvHash算法得到的固定结果分成四组
            int hash = FnvHash(str)%4;
            switch (hash){
                case 0:a++;break;
                case 1:b++;break;
                case 2:c++;break;
                case 3:d++;break;
            }
        }
        System.out.println("a：" + a);
        System.out.println("b：" + b);
        System.out.println("c：" + c);
        System.out.println("d：" + d);
        System.out.println("a+b+c+d：" + (a + b + c + d));
    }

多次实验结果
还比较满意，每次都比较均匀
a：2475
b：2526
c：2497
d：2502
a+b+c+d：10000

a：2494
b：2514
c：2485
d：2507
a+b+c+d：10000

a：2482
b：2486
c：2499
d：2533
a+b+c+d：10000