需求背景

    需要批量分配订单给人员，尽量保证分配到每个人的订单金额相近。可以按照金额平均分配，随机分配，指定数量分配。

    思路分析

    比如100个任务,每个任务ID和金额及号为(T100,100)…(T1,1)。第一轮分配先取最大的任务金额的分配给User1，即user1拥有T100，user2分配到T99，user3分配到T98。第二轮分配最小值，User1分配T1，User2分配T2，User3分配T3,第三轮分配最大值，即User1分配T97，User2分配T96，以此类推。

    代码实现

    JDK必须是1.8及以上，代码中使用了1.8的特性，不多废话上代码

    1. import java.io.*;
    2. import java.math.BigDecimal;
    3. import java.util.ArrayList;
    4. import java.util.Comparator;
    5. import java.util.List;
    6. import java.util.Map;
    7. import java.util.concurrent.ConcurrentHashMap;
    8. import java.util.stream.Collectors;
    10. /**
    11.  * @ClassName Allot
    12.  * @Desc TODO
    13.  * @Author chengp
    14.  * @Date 2019/1/11 9:55
    15.  * @Verion 1.0
    16.  */
    17. public class Allot {
    20.     /**
    21.      * 按金额分配
    22.      *
    23.      * @param users 人
    24.      * @param tasks 任务
    25.      * @return
    26.      */
    27.     public static Map<String, List<DemoTask>> allotOfAmount(List<DemoUser> users, List<DemoTask> tasks) {
    28.         //Collections.shuffle(users);//随机排序
    29.         Map<String, List<DemoTask>> allot = new ConcurrentHashMap<>(); //保存分配的信息
    30.         if (users != null && users.size() > 0 && tasks != null && tasks.size() > 0) {
    31.             List<DemoTask> copyTask = depCopy(tasks);//深拷贝,在处理过程中会删除已经分配的任务此处方便记录原始数据使用
    32.             for (int n = 0; n < copyTask.size() + n; n++) {
    33.                 if (n % 2 == 0) {
    34.                     copyTask = sortTask(copyTask, "desc");//正排
    35.                 } else {
    36.                     copyTask = sortTask(copyTask, "asc");//倒排
    37.                 }
    38.                 for (int j = 0; j < users.size(); j++) {
    39.                     if (copyTask.isEmpty()) break;
    40.                     if (allot.containsKey(users.get(j).getUserId().toString())) {
    41.                         List<DemoTask> list = allot.get(users.get(j).getUserId().toString());
    42.                         list.add(copyTask.get(0));//每次取排序后的第一条
    43.                         allot.put(users.get(j).getUserId().toString(), list);
    44.                     } else {
    45.                         List<DemoTask> list = new ArrayList<>();
    46.                         list.add(copyTask.get(0));
    47.                         allot.put(users.get(j).getUserId().toString(), list);
    48.                     }
    49.                     copyTask.remove(copyTask.get(0));//分配后删除
    51.                 }
    52.             }
    53.         }
    54.         return allot;
    55.     }
    57.     /**
    58.      * 平均分配&指定数量分配,多余的任务不予分配
    59.      *
    60.      * @param users 人
    61.      * @param tasks 任务
    62.      * @param count 每人指定分配数量
    63.      * @return
    64.      */
    65.     public static Map<String, List<DemoTask>> allotOfAverage(List<DemoUser> users,   List<DemoTask> tasks, Integer count) {
    66.         Collections.shuffle(users);//随机排序
    67.         Collections.shuffle(tasks);
    68.         Map<String, List<DemoTask>> allot = new ConcurrentHashMap<>(); //保存分配的信息
    69.         if (users != null && users.size() > 0 && tasks != null && tasks.size() > 0) {
    70.             for (int i = 0; i < tasks.size(); i++) {
    72.                 if (count != null && (i >= count * users.size())) {
    73.                     break;
    74.                 }
    75.                 int j = i % users.size();
    76.                 if (allot.containsKey(users.get(j).getUserId().toString())) {
    77.                     List<DemoTask> list = allot.get(users.get(j).getUserId().toString());
    78.                     list.add(tasks.get(i));
    79.                     allot.put(users.get(j).getUserId().toString(), list);
    80.                 } else {
    81.                     List<DemoTask> list = new ArrayList<>();
    82.                     list.add(tasks.get(i));
    83.                     allot.put(users.get(j).getUserId().toString(), list);
    84.                 }
    85.             }
    86.         }
    87.         return allot;
    88.     }
    89.     /**
    90.      * 深拷贝
    91.      *
    92.      * @param srcList
    93.      * @param <T>
    94.      * @return
    95.      */
    96.     public static <T> List<T> depCopy(List<T> srcList) {
    97.         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
    98.         try {
    99.             ObjectOutputStream out = new ObjectOutputStream(byteOut);
    100.             out.writeObject(srcList);
    102.             ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
    103.             ObjectInputStream inStream = new ObjectInputStream(byteIn);
    104.             List<T> destList = (List<T>) inStream.readObject();
    105.             return destList;
    106.         } catch (IOException e) {
    107.             e.printStackTrace();
    108.         } catch (ClassNotFoundException e) {
    109.             e.printStackTrace();
    110.         }
    111.         return null;
    112.     }
    115.     /**
    116.      * 排序
    117.      *
    118.      * @param taskList
    119.      * @param sort
    120.      * @return
    121.      */
    122.     private static List<DemoTask> sortTask(List<DemoTask> taskList, String sort) {
    123.         List<DemoTask> newList;
    124.         if ("asc".equalsIgnoreCase(sort)) {//正序
    125.             newList = taskList.stream().sorted(Comparator.comparing(DemoTask::getAmount))
    126.                     .collect(Collectors.toList());
    127.         } else if ("desc".equalsIgnoreCase(sort)) {//倒叙 reversed()即可
    128.             newList = taskList.stream().sorted(Comparator.comparing(DemoTask::getAmount).reversed())
    129.                     .collect(Collectors.toList());
    130.         } else {
    131.             newList = taskList;
    132.         }
    133.         return newList;
    134.     }
    137.     public static class  DemoUser{
    138.         private Integer userId;
    139.         private String userName;
    141.         public Integer getUserId() {
    142.             return userId;
    143.         }
    145.         public void setUserId(Integer userId) {
    146.             this.userId = userId;
    147.         }
    149.         public String getUserName() {
    150.             return userName;
    151.         }
    153.         public void setUserName(String userName) {
    154.             this.userName = userName;
    155.         }
    157.         @Override
    158.         public String toString() {
    159.             return "DemoUser{" +
    160.                     "userId=" + userId +
    161.                     ", userName='" + userName + '\'' +
    162.                     '}';
    163.         }
    164.     }
    167.     public static class DemoTask implements Serializable{
    169.         private Integer taskId;
    171.         private BigDecimal amount;
    173.         public Integer getTaskId() {
    174.             return taskId;
    175.         }
    177.         public void setTaskId(Integer taskId) {
    178.             this.taskId = taskId;
    179.         }
    181.         public BigDecimal getAmount() {
    182.             return amount;
    183.         }
    185.         public void setAmount(BigDecimal amount) {
    186.             this.amount = amount;
    187.         }
    189.         @Override
    190.         public String toString() {
    191.             return "DemoTask{" +
    192.                     "taskId=" + taskId +
    193.                     ", amount=" + amount +
    194.                     '}'+'\n';
    195.         }
    196.     }
    197.     public static void main(String[] args) {
    199.         List<DemoUser> userList = new ArrayList<>();
    200.         DemoUser entity = new DemoUser();
    201.         entity.setUserId(1);
    202.         userList.add(entity);
    203.         DemoUser entity2 = new DemoUser();
    204.         entity2.setUserId(2);
    205.         userList.add(entity2);
    206.         DemoUser entity3 = new DemoUser();
    207.         entity3.setUserId(3);
    208.         userList.add(entity3);
    210.         List<DemoTask> taskList = new ArrayList<>();
    211.         DemoTask apply1 = new DemoTask();
    212.         apply1.setTaskId(1);
    213.         apply1.setAmount(new BigDecimal(1000));
    214.         taskList.add(apply1);
    215.         DemoTask apply2 = new DemoTask();
    216.         apply2.setTaskId(2);
    217.         apply2.setAmount(new BigDecimal(1200));
    218.         taskList.add(apply2);
    219.         DemoTask apply3 = new DemoTask();
    220.         apply3.setTaskId(3);
    221.         apply3.setAmount(new BigDecimal(800));
    222.         taskList.add(apply3);
    223.         DemoTask apply4 = new DemoTask();
    224.         apply4.setTaskId(5);
    225.         apply4.setAmount(new BigDecimal(600));
    226.         taskList.add(apply4);
    227.         DemoTask apply5 = new DemoTask();
    228.         apply5.setTaskId(5);
    229.         apply5.setAmount(new BigDecimal(1600));
    230.         taskList.add(apply5);
    231.         DemoTask apply6 = new DemoTask();
    232.         apply6.setTaskId(6);
    233.         apply6.setAmount(new BigDecimal(2100));
    234.         taskList.add(apply6);
    235.         DemoTask apply7 = new DemoTask();
    236.         apply7.setTaskId(7);
    237.         apply7.setAmount(new BigDecimal(1210));
    238.         taskList.add(apply7);
    240.         DemoTask apply8 = new DemoTask();
    241.         apply8.setTaskId(8);
    242.         apply8.setAmount(new BigDecimal(1120));
    243.         taskList.add(apply8);
    245.         DemoTask apply9 = new DemoTask();
    246.         apply9.setTaskId(9);
    247.         apply9.setAmount(new BigDecimal(1310));
    248.         taskList.add(apply9);
    250.         DemoTask apply10 = new DemoTask();
    251.         apply10.setTaskId(10);
    252.         apply10.setAmount(new BigDecimal(1050));
    253.         taskList.add(apply10);
    255.         DemoTask apply11 = new DemoTask();
    256.         apply11.setTaskId(11);
    257.         apply11.setAmount(new BigDecimal(1500));
    258.         taskList.add(apply11);
    259.         List<DemoTask> copyTask = depCopy(taskList);
    261.         Map<String, List<DemoTask>> map = allotOfAmount(userList,copyTask);
    263.         System.out.println(map);
    264.     }
    265. }