贷后催收专用分案算法

已于 2023-11-23 22:08:57 修改
阅读量731 收藏 3
点赞数 1
文章标签： 算法 java 数据结构
于 2023-07-11 09:50:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54117624/article/details/131653256
版权

最优分案算法:

在开发中,有这么一种业务场景,就是需要根据一定的比例,按照数量与金额都按照这个比例进行分配,要求数量与金额都能达到最优的情况。如果只按照数量或者金额分配是比较好计算的,但是两者都需要兼顾到,这是一种比较复杂的算法,我现在将我的算法demo贴出来,供同学们一起学习一下。

可以直接将代码拷贝到本地,main方法直接运行

package cn.com.smart.eq.test;

import java.awt.*;

public class CaseAssignTool {
    public CaseAssignTool() {
    }

    public static void main(String[] args) {
        CaseFrame frame = new CaseFrame();
        frame.setTitle("手工分案-V2.8");
        frame.setDefaultCloseOperation(3);
        frame.setLocationRelativeTo((Component)null);
        frame.setVisible(true);
        frame.setResizable(false);
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package cn.com.smart.eq.test;

import com.zpp.dto.AssignDto;
import com.zpp.dto.CaseDto;
import java.awt.Font;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.filechooser.FileNameExtensionFilter;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;

class CaseFrame extends JFrame {
    private static final long serialVersionUID = -4289784953416095500L;
    private Font font = new Font("微软雅黑", 0, 18);
    private int hd = 30;
    private JTextField fileText;
    private JTextField percentText;
    private JButton assign;
    private JButton select;
    private JButton clean;
    private JScrollPane scroll;
    private JTextArea area;
    private JRadioButton autoOpen;
    private JComboBox<Integer> minBox;
    String filePath = "/Users/candy/Desktop/aa.xlsx";
    String percent = "1,2,3,4";
    Integer[] arr = new Integer[]{200, 300, 400, 500, 1000};

    public CaseFrame() {
        this.setSize(645, 430);
        this.getContentPane().setLayout((LayoutManager)null);
        int yy = 10;
        this.add(this.setLabel(yy, 20, 110, "分案文件"), (Object)null);
        this.add(this.setFileText(yy, 105, 410, this.filePath), (Object)null);
        this.add(this.setSelectButton(yy, 530, 90, "选择", new SelectListener((SelectListener)null)), (Object)null);
        yy = 45;
        this.add(this.setLabel(yy, 20, 110, "对象占比"), (Object)null);
        this.add(this.setPercentText(yy, 105, 180, this.percent), (Object)null);
        this.add(this.setMinBox(yy, 295, 75, this.arr), (Object)null);
        this.add(this.setCleanButton(yy, 380, 71, "清空", new CleanListener((CleanListener)null)), (Object)null);
        this.add(this.setOpenRadio(yy, 455, 71, "打开", false), (Object)null);
        this.add(this.setAssignButton(yy, 530, 90, "分配", new AssignListener((AssignListener)null)), (Object)null);
        this.add(this.setArea(20, 80, 600, 300, true), (Object)null);
        this.add(this.setScroll(20, 80, 600, 300, this.area), (Object)null);
    }

    private JLabel setLabel(int y, int x, int w, String text) {
        JLabel label = new JLabel(text);
        label.setBounds(x, y, w, this.hd);
        label.setFont(this.font);
        return label;
    }

    private JTextField setFileText(int y, int x, int w, String text) {
        if (this.fileText == null) {
            this.fileText = new JTextField(text);
        }

        this.fileText.setBounds(x, y, w, this.hd);
        this.fileText.setFont(this.font);
        return this.fileText;
    }

    private JTextField setPercentText(int y, int x, int w, String text) {
        if (this.percentText == null) {
            this.percentText = new JTextField(text);
        }

        this.percentText.setBounds(x, y, w, this.hd);
        this.percentText.setFont(this.font);
        return this.percentText;
    }

    private JComboBox<Integer> setMinBox(int y, int x, int w, Integer[] arr) {
        if (this.minBox == null) {
            this.minBox = new JComboBox();
        }

        this.minBox.setBounds(x, y, w, this.hd);
        this.minBox.setFont(this.font);
        Integer[] var8 = arr;
        int var7 = arr.length;

        for(int var6 = 0; var6 < var7; ++var6) {
            Integer item = var8[var6];
            this.minBox.addItem(item);
        }

        return this.minBox;
    }

    private JRadioButton setOpenRadio(int y, int x, int w, String text, boolean select) {
        if (this.autoOpen == null) {
            this.autoOpen = new JRadioButton(text);
        }

        this.autoOpen.setBounds(x, y, w, this.hd);
        this.autoOpen.setFont(this.font);
        this.autoOpen.setSelected(select);
        return this.autoOpen;
    }

    private JButton setSelectButton(int y, int x, int w, String text, SelectListener actionListener) {
        if (this.select == null) {
            this.select = new JButton(text);
        }

        this.select.setBounds(x, y, w, this.hd);
        this.select.setFont(this.font);
        this.select.addActionListener(actionListener);
        return this.select;
    }

    private JButton setCleanButton(int y, int x, int w, String text, CleanListener actionListener) {
        if (this.clean == null) {
            this.clean = new JButton(text);
        }

        this.clean.setBounds(x, y, w, this.hd);
        this.clean.setFont(this.font);
        this.clean.addActionListener(actionListener);
        return this.clean;
    }

    private JButton setAssignButton(int y, int x, int w, String text, AssignListener actionListener) {
        if (this.assign == null) {
            this.assign = new JButton(text);
        }

        this.assign.setBounds(x, y, w, this.hd);
        this.assign.setFont(this.font);
        this.assign.addActionListener(actionListener);
        return this.assign;
    }

    private JTextArea setArea(int x, int y, int w, int h, boolean scroll) {
        if (this.area == null) {
            this.area = new JTextArea();
        }

        this.area.setBounds(x, y, w, h);
        this.area.setAutoscrolls(scroll);
        this.area.setFont(this.font);
        return this.area;
    }

    private JScrollPane setScroll(int x, int y, int w, int h, JTextArea area) {
        if (this.scroll == null) {
            this.scroll = new JScrollPane();
        }

        this.scroll.setBounds(x, y, w, h);
        this.scroll.setViewportView(area);
        return this.scroll;
    }

    private class AssignListener implements ActionListener {
        private AssignListener(AssignListener assignListener) {
        }

        public void actionPerformed(ActionEvent e) {
            String perStr = CaseFrame.this.percentText.getText();
            if (!this.regex(perStr.trim(), "\\d+(\\.\\d+)?(\\s*,\\s*\\d+(\\.\\d+)?)*")) {
                this.append("【分配对象】值有误");
            } else {
                String path = CaseFrame.this.fileText.getText();
                if (path != null && !"".equals(path.trim())) {
                    File file = new File(path);
                    if (!file.exists()) {
                        this.append("【分案文件】不存在");
                    } else {
                        long fileSize = file.length();
                        this.append("文件大小=" + String.format("%.3f", (double)(fileSize / 1024L) / 1024.0) + "MB");
                        Workbook book = this.excel2book(file);
                        if (book == null) {
                            this.append("创建【Workbook】为空");
                        } else {
                            Sheet sheet = book.getSheetAt(0);
                            int rowNum = sheet.getLastRowNum();
                            this.append("总行数=" + (rowNum + 1));
                            List<String> headList = this.row2list(sheet.getRow(0));
                            List<String> mustHeads = Arrays.asList("案件号", "逾期金额");
                            Iterator var13 = mustHeads.iterator();

                            while(var13.hasNext()) {
                                String mustHead = (String)var13.next();
                                if (!headList.contains(mustHead)) {
                                    this.append("表头必须包含【" + mustHead + "】字段");
                                    return;
                                }
                            }

                            List<CaseDto> caseList = new ArrayList<>();
                            this.sheet2list(caseList, sheet, rowNum, headList);
                            if (caseList.isEmpty()) {
                                this.append("【生成case】为空");
                            } else {
                                int max = caseList.size();
                                Map<AssignDto, List<CaseDto>> result = this.assign(caseList, perStr, max);
                                Iterator var16 = result.entrySet().iterator();
                                while(var16.hasNext()) {
                                    Map.Entry<AssignDto, List<CaseDto>> entry = (Map.Entry)var16.next();
                                    ((AssignDto)entry.getKey()).setRealAmt(entry.getValue().stream().map(CaseDto::getAmtBal).reduce(BigDecimal.ZERO, BigDecimal::add));
                                    ((AssignDto)entry.getKey()).setRealNum(((List)entry.getValue()).size());
                                }

                                List<AssignDto> dtos = (List)result.keySet().stream().sorted(Comparator.comparing(AssignDto::getOffset)).collect(Collectors.toList());
                                this.printList("实际结果", dtos, true);
                                this.data2excel(result, path);
                            }
                        }
                    }
                } else {
                    this.append("【分案文件】值为空");
                }
            }
        }

        private Workbook excel2book(File file) {
            InputStream fis = null;

            try {
                fis = new FileInputStream(file);
            } catch (Exception var15) {
                this.append("创建【InputStream】失败");
            }

            Workbook book = null;

            try {
                book = WorkbookFactory.create(fis);
            } catch (Exception var14) {
                this.append("创建【Workbook】失败");
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException var13) {
                        this.append("关闭【InputStream】失败");
                    }
                }

            }

            return book;
        }

        private void sheet2list(List<CaseDto> caseList, Sheet sheet, int rowNum, List<String> headList) {
            int size = headList.size();

            for(int i = 1; i <= rowNum; ++i) {
                Row row = sheet.getRow(i);
                if (row == null) {
                    this.append("【空行】第" + (i + 1) + "行");
                    return;
                }

                CaseDto dto = new CaseDto();

                for(int j = 0; j < size; ++j) {
                    Cell cell = row.getCell(j);
                    String cellVal = null;
                    String var12;
                    switch ((var12 = (String)headList.get(j)).hashCode()) {
                        case 26302985:
                            if (!var12.equals("案件号")) {
                                return;
                            }

                            cellVal = this.cell2string(cell, true);
                            if (StringUtils.isBlank(cellVal)) {
                                this.append("第" + (i + 1) + "行【" + (String)headList.get(j) + "】为空");
                                return;
                            }

                            dto.setCaseId(Long.valueOf(cellVal));
                            break;
                        case 1126628173:
                            if (var12.equals("逾期金额")) {
                                cellVal = this.cell2string(cell, true);
                                if (StringUtils.isBlank(cellVal)) {
                                    this.append("第" + (i + 1) + "行【" + (String)headList.get(j) + "】为空");
                                    return;
                                }

                                dto.setAmtBal(new BigDecimal(cellVal));
                                break;
                            }

                            return;
                        default:
                            return;
                    }
                }

                caseList.add(dto);
            }

        }

        private Map<AssignDto, List<CaseDto>> assign(List<CaseDto> caseList, String percentStr, int max) {
            BigDecimal totalAmt = (BigDecimal)caseList.stream().map(CaseDto::getAmtBal).reduce(BigDecimal.ZERO, BigDecimal::add);
            List<AssignDto> userList = this.buildAssignDto(percentStr, caseList.size(), totalAmt, max);
            this.printAssignDto(userList);
            long start = System.currentTimeMillis();

            this.append("\n<< 分案开始 >>");
            Map<AssignDto, List<CaseDto>> userMap = this.oneStep(caseList, userList, totalAmt.multiply(new BigDecimal("0.0001")), max / 2);
            Map<AssignDto, List<CaseDto>> map = this.fixResult(userMap);
            long end = System.currentTimeMillis();
            this.append("\n<< 分案完成 >> 耗时：" + (double)(end - start) / 1000.0 + "s");
            return map;
        }

        private void printAssignDto(List<AssignDto> userList) {
            Map<String, List<AssignDto>> keyUser = new HashMap();

            AssignDto curr;
            String userId;
            for(Iterator var4 = userList.iterator(); var4.hasNext(); ((List)keyUser.get(userId)).add(curr)) {
                curr = (AssignDto)var4.next();
                userId = curr.getUserId().split("_", 2)[0];
                if (!keyUser.containsKey(userId)) {
                    keyUser.put(userId, new ArrayList());
                }
            }

            List<AssignDto> result = new ArrayList();
            Iterator var11 = keyUser.entrySet().iterator();

            while(var11.hasNext()) {
                Map.Entry<String, List<AssignDto>> entry = (Map.Entry)var11.next();
                AssignDto dto = new AssignDto((String)entry.getKey(), BigDecimal.ZERO);
                Iterator var8 = ((List)entry.getValue()).iterator();

                while(var8.hasNext()) {
                    AssignDto currx = (AssignDto)var8.next();
                    dto.setPercent(currx.getPercent());
                    dto.setAssignNum(dto.getAssignNum() + currx.getAssignNum());
                    dto.setAssignAmt(dto.getAssignAmt().add(currx.getAssignAmt()));
                    dto.setRealNum(dto.getRealNum() + currx.getRealNum());
                    dto.setRealAmt(dto.getRealAmt().add(currx.getRealAmt()));
                }

                result.add(dto);
            }

            this.printList("分配汇总", result, true);
        }

        private List<AssignDto> buildAssignDto(String percentStr, int caseSize, BigDecimal totalAmt, int max) {
            BigDecimal caseNum = BigDecimal.valueOf((long)caseSize);
            BigDecimal avgAmt = totalAmt.divide(caseNum, 2, 4);
            this.append("案件总数=" + caseSize + "，案件总金额=" + totalAmt + "，平均金额=" + avgAmt);
            BigDecimal totalPercent = BigDecimal.ZERO;
            List<BigDecimal> percents = new ArrayList();
            String[] str = percentStr.trim().split("\\s*,\\s*");
            int len;
            int size;
            if (str.length == 1) {
                len = (int)Double.parseDouble(str[0]);

                for(size = 1; size <= len; ++size) {
                    percents.add(BigDecimal.ONE);
                }

                totalPercent = BigDecimal.valueOf((long)len);
            } else {
                for(len = 0; len < str.length; ++len) {
                    BigDecimal curr = new BigDecimal(str[len]);
                    if (curr.compareTo(BigDecimal.ZERO) > 0) {
                        percents.add(curr);
                        totalPercent = totalPercent.add(curr);
                    }
                }
            }

            Collections.sort(percents);
            List<AssignDto> dtos = new ArrayList();
            size = percents.size();
            BigDecimal passAmt = BigDecimal.ZERO;
            int passNum = 0;

            int left;
            for(int i = 0; i < size - 1; ++i) {
                String userIdx = "U" + (i + 1) + "_";
                BigDecimal px = (BigDecimal)percents.get(i);
                int assignNumx = caseNum.multiply(px).divide(totalPercent, 2, 1).intValue();
                BigDecimal assignAmtx = totalAmt.multiply(px).divide(totalPercent, 2, 4);
                left = assignNumx / max;
                int leftx = assignNumx % max;
                BigDecimal passx;
                int j;
                BigDecimal amt;
                AssignDto d;
                AssignDto dx;
                if (leftx > 0) {
                    passx = BigDecimal.ZERO;

                    for(j = 0; j < left; ++j) {
                        amt = assignAmtx.multiply(BigDecimal.valueOf((long)max)).divide(BigDecimal.valueOf((long)assignNumx), 2, 4);
                        d = new AssignDto(userIdx + j, px);
                        d.setAssignNum(max);
                        d.setAssignAmt(amt);
                        dtos.add(d);
                        passx = passx.add(amt);
                    }

                    dx = new AssignDto(userIdx + left, px);
                    dx.setAssignNum(leftx);
                    dx.setAssignAmt(assignAmtx.subtract(passx));
                    dtos.add(dx);
                } else {
                    passx = BigDecimal.ZERO;

                    for(j = 0; j < left - 1; ++j) {
                        amt = assignAmtx.multiply(BigDecimal.valueOf((long)max)).divide(BigDecimal.valueOf((long)assignNumx), 2, 4);
                        d = new AssignDto(userIdx + j, px);
                        d.setAssignNum(max);
                        d.setAssignAmt(amt);
                        dtos.add(d);
                        passx = passx.add(amt);
                    }

                    dx = new AssignDto(userIdx + (left - 1), px);
                    dx.setAssignNum(leftx);
                    dx.setAssignAmt(assignAmtx.subtract(passx));
                    dtos.add(dx);
                }

                passAmt = passAmt.add(assignAmtx);
                passNum += assignNumx;
            }

            if (passNum < caseSize) {
                String userId = "U" + size + "_";
                BigDecimal p = (BigDecimal)percents.get(size - 1);
                int assignNum = caseSize - passNum;
                BigDecimal assignAmt = totalAmt.subtract(passAmt);
                int time = assignNum / max;
                left = assignNum % max;
                BigDecimal pass;
                int jx;
                AssignDto dxx;
                AssignDto dxxx;
                BigDecimal amtx;
                if (left > 0) {
                    pass = BigDecimal.ZERO;

                    for(jx = 0; jx < time; ++jx) {
                        amtx = assignAmt.multiply(BigDecimal.valueOf((long)max)).divide(BigDecimal.valueOf((long)assignNum), 2, 4);
                        dxxx = new AssignDto(userId + jx, p);
                        dxxx.setAssignNum(max);
                        dxxx.setAssignAmt(amtx);
                        dtos.add(dxxx);
                        pass = pass.add(amtx);
                    }

                    dxx = new AssignDto(userId + time, p);
                    dxx.setAssignNum(left);
                    dxx.setAssignAmt(assignAmt.subtract(pass));
                    dtos.add(dxx);
                } else {
                    pass = BigDecimal.ZERO;

                    for(jx = 0; jx < time - 1; ++jx) {
                        amtx = assignAmt.multiply(BigDecimal.valueOf((long)max)).divide(BigDecimal.valueOf((long)assignNum), 2, 4);
                        dxxx = new AssignDto(userId + jx, p);
                        dxxx.setAssignNum(max);
                        dxxx.setAssignAmt(amtx);
                        dtos.add(dxxx);
                        pass = pass.add(amtx);
                    }

                    dxx = new AssignDto(userId + (time - 1), p);
                    dxx.setAssignNum(left);
                    dxx.setAssignAmt(assignAmt.subtract(pass));
                    dtos.add(dxx);
                }
            }

            List<AssignDto> dtosx = (List)dtos.stream().filter((u) -> {
                return u.getAssignNum() > 0;
            }).collect(Collectors.toList());
            dtosx.sort(Comparator.comparing(AssignDto::getAssignNum));
            return dtosx;
        }

        private Map<AssignDto, List<CaseDto>> fixResult(Map<AssignDto, List<CaseDto>> map) {
            Map<String, List<AssignDto>> keyUser = new HashMap();
            Map<String, List<CaseDto>> keyCase = new HashMap();

            Map.Entry entryx;
            String userId;
            for(Iterator var5 = map.entrySet().iterator(); var5.hasNext(); ((List)keyCase.get(userId)).addAll((Collection)entryx.getValue())) {
                entryx = (Map.Entry)var5.next();
                AssignDto curr = (AssignDto)entryx.getKey();
                userId = curr.getUserId().split("_", 2)[0];
                if (!keyUser.containsKey(userId)) {
                    keyUser.put(userId, new ArrayList());
                }

                ((List)keyUser.get(userId)).add((AssignDto)entryx.getKey());
                if (!keyCase.containsKey(userId)) {
                    keyCase.put(userId, new ArrayList());
                }
            }

            Map<AssignDto, List<CaseDto>> result = new HashMap();
            Iterator var12 = keyUser.entrySet().iterator();

            while(var12.hasNext()) {
                Map.Entry<String, List<AssignDto>> entry = (Map.Entry)var12.next();
                AssignDto dto = new AssignDto((String)entry.getKey(), BigDecimal.ZERO);
                Iterator var9 = ((List)entry.getValue()).iterator();

                while(var9.hasNext()) {
                    AssignDto currx = (AssignDto)var9.next();
                    dto.setPercent(currx.getPercent());
                    dto.setAssignNum(dto.getAssignNum() + currx.getAssignNum());
                    dto.setAssignAmt(dto.getAssignAmt().add(currx.getAssignAmt()));
                    dto.setRealNum(dto.getRealNum() + currx.getRealNum());
                    dto.setRealAmt(dto.getRealAmt().add(currx.getRealAmt()));
                }

                result.put(dto, (List)keyCase.get(entry.getKey()));
            }

            return result;
        }

        private Map<AssignDto, List<CaseDto>> oneStep(List<CaseDto> caseList, List<AssignDto> userList, BigDecimal maxOffset, int maxTimes) {
            this.append("\n最大偏差仅=" + maxOffset + "，最大微调次数=" + maxTimes);
            Map<AssignDto, List<CaseDto>> map = new HashMap<>();
            List<CaseDto> left = caseList;
            int usize = userList.size();

            for(int x = 0; x < usize - 1; ++x) {
                int size = ((List<?>)left).size();
                int num = ((AssignDto)userList.get(x)).getAssignNum();
                int mod = size / num;
                List<CaseDto> curr = new ArrayList<>();
                List<CaseDto> temp = new ArrayList<>();

                for(int j = 0; j < size; ++j) {
                    if (j % mod == (j / mod % 2 == 0 ? 0 : mod - 1) && curr.size() < num) {
                        curr.add((CaseDto)((List<?>)left).get(j));
                    } else {
                        temp.add((CaseDto)((List<?>)left).get(j));
                    }
                }

                ((AssignDto)userList.get(x)).setRealAmt((BigDecimal)curr.stream().map(CaseDto::getAmtBal).reduce(BigDecimal.ZERO, BigDecimal::add));
                BigDecimal offset = ((AssignDto)userList.get(x)).getOffset();
                int currSize = curr.size();
                int leftSize = temp.size();
                int times = 1;

                for(String flag = ((AssignDto)userList.get(x)).getUserId() + ":0"; offset.abs().compareTo(maxOffset) > 0 && times < maxTimes; ++times) {
                    BigDecimal lastSub = offset.abs();
                    String lastFlag = flag;
                    int[] idx = new int[]{currSize - 1, leftSize - 1};

                    BigDecimal currSub;
                    for(int k = 0; k < currSize; ++k) {
                        for(int m = 0; m < leftSize; ++m) {
                            currSub = ((CaseDto)temp.get(m)).getAmtBal().subtract(((CaseDto)curr.get(k)).getAmtBal()).add(offset).abs();
                            if (currSub.compareTo(lastSub) < 0) {
                                idx[0] = k;
                                idx[1] = m;
                                lastSub = currSub;
                                lastFlag = ((AssignDto)userList.get(x)).getUserId() + ":" + k;
                            }
                        }
                    }

                    if (offset.abs().compareTo(lastSub) == 0 && flag.equals(lastFlag)) {
                        this.append((times == 1 ? "\n" : "") + "【" + ((AssignDto)userList.get(x)).getUserId() + "】第" + times + "次：已最优，跳出循环");
                        break;
                    }

                    this.append((times == 1 ? "\n" : "") + "【" + ((AssignDto)userList.get(x)).getUserId() + "】第" + times + "次：调前=" + offset + "，调后=" + lastSub + "，交换[ " + idx[0] + " <> " + idx[1] + " ]");
                    CaseDto c1 = (CaseDto)curr.get(idx[0]);
                    CaseDto c2 = (CaseDto)temp.get(idx[1]);
                    curr.remove(idx[0]);
                    temp.remove(idx[1]);
                    curr.add(c2);
                    temp.add(c1);
                    currSub = c2.getAmtBal().subtract(c1.getAmtBal());
                    ((AssignDto)userList.get(x)).setRealAmt(((AssignDto)userList.get(x)).getRealAmt().add(currSub));
                    offset = ((AssignDto)userList.get(x)).getOffset();
                }

                left = temp;
                ((AssignDto)userList.get(x)).setRealNum(curr.size());
                map.put((AssignDto)userList.get(x), curr);
            }

            ((AssignDto)userList.get(usize - 1)).setRealAmt(left.stream().map(CaseDto::getAmtBal).reduce(BigDecimal.ZERO, BigDecimal::add));
            ((AssignDto)userList.get(usize - 1)).setRealNum(((List)left).size());
            map.put((AssignDto)userList.get(usize - 1), left);
            return map;
        }

        private void data2excel(Map<AssignDto, List<CaseDto>> result, String path) {
            Workbook book = new SXSSFWorkbook(64);
            Sheet sheet = book.createSheet("结果");
            List<String> heads = Arrays.asList("案件号", "分配对象", "逾期金额");
            int rix = 0;
            int hsize = heads.size();
            Row row = sheet.createRow(rix++);

            for(int i = 0; i < hsize; ++i) {
                Cell cell = row.createCell(i);
                cell.setCellValue((String)heads.get(i));
            }

            Iterator var28 = result.entrySet().iterator();

            while(var28.hasNext()) {
                Map.Entry<AssignDto, List<CaseDto>> entry = (Map.Entry)var28.next();
                Iterator var12 = ((List)entry.getValue()).iterator();

                while(var12.hasNext()) {
                    CaseDto dto = (CaseDto)var12.next();
                    row = sheet.createRow(rix++);
                    dto.setUserId(((AssignDto)entry.getKey()).getUserId());

                    for(int ix = 0; ix < hsize; ++ix) {
                        Cell cellx = row.createCell(ix);
                        switch ((String)heads.get(ix)) {
                            case "案件号":
                                cellx.setCellValue((double)dto.getCaseId());
                                break;
                            case "分配对象":
                                cellx.setCellValue(dto.getUserId());
                                break;
                            case "逾期金额":
                                cellx.setCellValue(dto.getAmtBal().doubleValue());
                        }
                    }
                }
            }

            String uuid = UUID.randomUUID().toString().replace("-", "");

            String newPath;
            for(newPath = path.replace(".xls", "结果-" + uuid + ".xls"); (new File(newPath)).exists(); newPath = path.replace(".xls", "结果-" + uuid + ".xls")) {
                uuid = UUID.randomUUID().toString().replace("-", "");
            }

            FileOutputStream out = null;

            try {
                out = new FileOutputStream(newPath);
                book.write(out);
                out.flush();
                this.append("\n生成结果文件【" + newPath + "】");
            } catch (Exception var24) {
                this.append("\n生成结果文件【" + newPath + "】失败");
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException var22) {
                        this.append("关闭【FileOutputStream】失败");
                    }
                }

            }

            if (CaseFrame.this.autoOpen.isSelected()) {
                String[] cmd = new String[]{"explorer.exe", newPath};

                try {
                    Runtime.getRuntime().exec(cmd);
                } catch (Exception var23) {
                    this.append("\n打开文件失败【" + newPath + "】");
                }

                this.append("\n自动打开文件【" + newPath + "】");
            }

        }

        private String cell2string(Cell cell, boolean nullToBlock) {
            String value = null;
            switch (cell.getCellType()) {
                case 0:
                    if (DateUtil.isCellDateFormatted(cell)) {
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        value = sdf.format(cell.getDateCellValue());
                    } else {
                        DecimalFormat df = new DecimalFormat("#.##");
                        value = df.format(cell.getNumericCellValue());
                    }
                    break;
                case 1:
                    value = cell.getStringCellValue();
                    break;
                case 2:
                    value = cell.getCellFormula();
                case 3:
                case 5:
                default:
                    break;
                case 4:
                    value = String.valueOf(cell.getBooleanCellValue());
            }

            if (StringUtils.isNotBlank(value)) {
                value = value.trim().replaceAll("\\s+", "").replaceAll(",", "，");
            } else if (nullToBlock) {
                value = "";
            }

            return value;
        }

        private List<String> row2list(Row row) {
            List<String> heads = new ArrayList();
            if (row != null) {
                int cellNum = row.getLastCellNum();

                for(int i = 0; i < cellNum; ++i) {
                    Cell cell = row.getCell(i);
                    if (cell != null) {
                        String feild = cell.getStringCellValue();
                        if (StringUtils.isNotBlank(feild)) {
                            heads.add(feild.trim());
                        }
                    }
                }
            }

            return heads;
        }

        private boolean regex(String input, String regex) {
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(input);
            return m.matches();
        }

        private void append(String text) {
            System.out.println(text);
            CaseFrame.this.area.append(text + "\n");
            CaseFrame.this.area.paintImmediately(CaseFrame.this.area.getBounds());
        }

        private void printList(String head, Collection<?> list, boolean append) {
            System.out.println("\n------------------------------ " + head + " ------------------------------");
            if (append) {
                CaseFrame.this.area.append("\n------------------------------ " + head + " ------------------------------\n");
            }

            list.forEach((a) -> {
                System.out.println(a.toString());
                if (append) {
                    CaseFrame.this.area.append(a.toString() + "\n");
                }

            });
            if (append) {
                CaseFrame.this.area.paintImmediately(CaseFrame.this.area.getBounds());
            }

        }
    }

    private class CleanListener implements ActionListener {
        private CleanListener(CleanListener cleanListener) {
        }

        public void actionPerformed(ActionEvent e) {
            CaseFrame.this.autoOpen.setSelected(false);
            CaseFrame.this.area.setText("");
        }
    }

    private class SelectListener implements ActionListener {
        private SelectListener(SelectListener selectListener) {
        }

        public void actionPerformed(ActionEvent e) {
            JFileChooser fileChooser = new JFileChooser();
            fileChooser.setCurrentDirectory(new File("."));
            fileChooser.setFileSelectionMode(2);
            fileChooser.setFileFilter(new FileNameExtensionFilter("Excel (*.xlsx, *.xls)", new String[]{"xlsx", "xls"}));
            int result = fileChooser.showOpenDialog(new JFrame());
            if (result == 0) {
                File file = fileChooser.getSelectedFile();
                CaseFrame.this.fileText.setText(file.getAbsolutePath());
            }

        }
    }
}
相关依赖
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>3.17</version>
        </dependency>
        
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.8.1</version>
    </dependency>
用到的实体bean
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.zpp.dto;

import java.math.BigDecimal;

public class AssignDto {
    private String userId;
    private BigDecimal percent;
    private int assignNum;
    private int realNum;
    private BigDecimal assignAmt;
    private BigDecimal realAmt;
    private BigDecimal offset;

    public AssignDto(String userId, BigDecimal percent) {
        this.userId = userId;
        this.percent = percent;
        this.assignNum = 0;
        this.realNum = 0;
        this.assignAmt = BigDecimal.ZERO;
        this.realAmt = BigDecimal.ZERO;
        this.offset = BigDecimal.ZERO;
    }

    public String toString() {
        return "用户=" + this.userId + ",  权重=" + this.percent + ",  应分数量=" + this.assignNum + ",  实际数量=" + this.realNum + ",  应分金额=" + this.assignAmt + ",  实际金额=" + this.realAmt + ",  偏差量=" + this.offset;
    }

    public String getUserId() {
        return this.userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public BigDecimal getPercent() {
        return this.percent;
    }

    public void setPercent(BigDecimal percent) {
        this.percent = percent;
    }

    public int getAssignNum() {
        return this.assignNum;
    }

    public void setAssignNum(int assignNum) {
        this.assignNum = assignNum;
        this.realNum = 0;
    }

    public int getRealNum() {
        return this.realNum;
    }

    public void setRealNum(int realNum) {
        this.realNum = realNum;
    }

    public BigDecimal getAssignAmt() {
        return this.assignAmt;
    }

    public void setAssignAmt(BigDecimal assignAmt) {
        this.assignAmt = assignAmt;
        this.offset = BigDecimal.ZERO;
    }

    public BigDecimal getRealAmt() {
        return this.realAmt;
    }

    public void setRealAmt(BigDecimal realAmt) {
        this.realAmt = realAmt;
        this.offset = this.realAmt.subtract(this.assignAmt);
    }

    public BigDecimal getOffset() {
        return this.offset;
    }

    public void setOffset(BigDecimal offset) {
        this.offset = offset;
    }
}
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.zpp.dto;

import java.math.BigDecimal;

public class CaseDto {
    private Long caseId;
    private BigDecimal amtBal;
    private String userId;

    public CaseDto() {
    }

    public String toString() {
        return this.caseId + "," + this.amtBal + "," + this.userId;
    }

    public Long getCaseId() {
        return this.caseId;
    }

    public void setCaseId(Long caseId) {
        this.caseId = caseId;
    }

    public BigDecimal getAmtBal() {
        return this.amtBal;
    }

    public void setAmtBal(BigDecimal amtBal) {
        this.amtBal = amtBal;
    }

    public String getUserId() {
        return this.userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }
}
Mr、追风少年
关注
贷后催收及沟通技巧.pptx
10-08
贷后催收及沟通技巧.pptx
贷后风控中逾期案件差异化的分配逻辑
weixin_45545159的博客
02-22 1570
在风控精细化运营的当下，贷后工作的开展，越来越需要精细化管理。 今天我们总结梳理了番茄风控之前的内容并结合近期开展的内容，为大家带来一个催收模型优化和逾期案件催收差异化策略的内容，详细请看本文介绍。 一.催收模型 在催收模块里，开发的催收模型往往是不止一个模型的，一般我们会通过不同的评分卡去区分不同的风险。 比如我们经常强调的滚动率模型，会用到好几个模型一起叠加来使用，我们有时不仅使用两个模型来叠加，还会使用3个甚至4个模型叠加使用。 下面我们使用两个模型的的叠加来说下具体的操作方法： 上图是一个真实的使
催收分案设计
maxmao1024的博客
11-20 6878
1. 业务背景 逾期账单会进入催收阶段，需要制定和实施合理的催收方案，跟踪催回情况，及时调整分案策略 2. 业务内容 评估逾期：根据历史逾期情况和到期账单数，估计未来一个月的需要催收的账单数量 确定策略：商务与催收公司协商，结合公司情况和逾期评估，制定催收策略，签订协议 分案：根据分案规则使用不同的催收方式，将订单分派给不同的催收人员 报表：统计分案情况，跟踪催回率，对催收策略进行调整 结算：催...
催收 重新分案_贷后风险管理(催收)模型框架搭建
weixin_42509267的博客
01-17 2324
本文转自知乎，作者为过一点划一条直线，原文链接为https://zhuanlan.zhihu.com/p/109912499背景在前两篇文章贷后催收评分卡构建思路和贷后催收分析思路中已经介绍了催收评分卡模型的构建思路和分析思路。本文主要简单的介绍下贷后风险管理框架从0到1的搭建过程，其中即包含模型框架、策略体系以及AB Test思路。目录Part 1. 人群说明Part 2. 模型体系搭...
用Python对催收案件做均匀分配
最新发布
2302_77679648的博客
06-23 785
最近应朋友邀请，帮他写一个催收案件的平均分配小程序......
java实现催收系统对金额平均分，基本保证催收员的绩效一致
qq_23927391的博客
01-09 1641
package test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Ra
贷后策略量化分析系列【1】
qq_44718784的博客
03-24 812
量化风控贷后管理系列 @lbhfox
贷后催收及沟通技巧培训.pptx
10-08
贷后催收及沟通技巧培训 贷后催收及沟通技巧培训的目的是为了提高催收人员的沟通技巧和策略，帮助他们更好地与客户交流，提高还款成功率。根据客户的不同类型，催收人员可以采用不同的策略来应对不同的客户行为。 ...
贷款逾期前期控制和贷后催收技巧以及如何处理.doc
09-29
贷款逾期前期控制与贷后催收是金融行业中风险管理的重要组成部分，尤其在当前经济环境下，金融机构面临的逾期风险不断增加。为了确保贷款安全，降低坏账率，金融机构必须实施有效的控制策略。 首先，逾期的定义是...
贷后策略的一点思考
lc434699300的博客
10-11 1165
 　之前写过一篇贷后策略效果评估的文章，主要是介绍策略的制定以及效果的评估方法，评估方法从常见的命中率、覆盖率控制命中策略的人数，也大致预估了对催收成本以及坏账的影响。本文针对上次的文章进行几点补充，主要是从实际业务的角度，对催收产能以及业绩指标的影响作合理的预估及监控。 目录 预估产能 预估指标 策略监控 总结  　假设现在有缓催3天、5天、15天的3条策略，其命中率和覆盖率如下(策略内容为虚构)：  　三条策略一共覆盖了30%的客群，且缓催15天的客群应该是历史回收率最高的，缓催3天的客群历史回.
java实战算法根据个数百分比，排序金额分配案件金额也趋近百分比
Alice_qixin的博客
01-23 4217
使用场景： 给n个员工分配n个案子。条件是按个数比例分配。分配后的案件金额也趋近于个数的比例，并且趋近公平分配。 设计思路 这里比较复杂的地方就是怎么按个数占比分配，案件金额总数也趋近个数占比。并且趋近公平 例如10个按键，案件金额为1，2，3，4，5，6，7，8，9，10 第一种情况偶数分配： 给两个人分案件，一个分配40%一个分配60%，案件个数就是4：6  = 2：3  怎么让金
04.金融银行_催收系统简介
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
06-08 4506
随着互联网金融的发展和网贷业务的发展，使得借贷融资额度在近两年出现大幅度的增长，催收业务产品也逐渐发展起来； 一、传统催收业务模式是什么样的？传统催收主要分为四个阶段，根据催收阶段不同，会采取不同的催收策略；一般只有“前期催收”阶段是本公司催收人员跟进，后期的催收都会委派给相关催收机构进行处理；所以催收系统需要覆盖从前期催收到后期委派全阶段的需求。二、了解几个关键词定义1）逾期：用户借了一笔款，但是没有在应还日期之前还款，此时订单就会变成逾期状态，逾期状态的订单会进入催收系统，由催员进行跟进回款。2）催收案
数据化风控与催收人员策略管理
weixin_45545159的博客
03-31 1775
在印象中催收也许是个玄学，一个做得好的催收员除了催收技巧外、你需要了解心理学、懂声音学、懂人性、懂风水易经，比如就有个认识的人对什么岁数的人在哪个时辰拨打电话才比较好，都有讲究…总之一切尽在不言中… 但催收的管理却与之相反，在风控全流程贷前、贷中、贷后的各个模块中，贷后催收是相对特别的一个部门，最需要跟人沟通，也需要管理。的确，贷后实务真的就是实务。 所以贷后催收还是有迹可循，今天我们来谈谈催收人员的管理。 一.催收部门的管理 在催收部门管理方面，一般会对催收技能组进行如下划分： 位于M1状态的分的技能组会
java实战算法根据个数百分比，排序金额分配案件金额也趋近百分比(二)
Alice_qixin的博客
02-10 2212
//案件按照金额排序 private void sortCases(List&lt;CaseHead&gt; caseHeads) { Collections.sort(caseHeads, new Comparator&lt;CaseHead&gt;() { @Override public int compare(CaseHead o1, CaseHead o2) { ...
信贷系统学习总结（4）——现金贷之催收业务和后台系统
科技D人生
07-10 5929
一、逾期原因 逾期指客户在和金融机构约定时间内未履行还款的约定，是贷款机构损失的重要来源之一。逾期的原因有很多种，主要有两方面：还款意愿差和还款能力不足。 还款意愿差指客户的信用意识不强，存侥幸心理，故意拖欠金融机构贷款不还，业内对该类客户成为“老赖”。另外由于法律纠纷等情况也可能导致客户还款意愿差，如争议交易、欺诈交易等。 还款能力不足指客户没有足够的能力去支付贷款，这是客户逾期最主要的原...
一种案件按比例分配给用户的算法实现
我也很绝望的博客
07-11 2354
一、背景 日常做需求开发过程中，有以下业务场景：将一批案件分配给一批客户，每个案件具有不同的金额，每个客户有分配比例，需要实现在案件数量按照比例分配给客户的情况下，还要尽量保持客户分配到案件的总金额也能按照分配比例分布。 二、分析 如果案件分配单纯考虑数量或者金额，分配逻辑还是比较简单的。但是既要考虑数量，又要考虑金额，这涉及到两个变量，而且一般案件金额分布并不均匀，直接分配往往达不到期望的效果。 在这里，采用每个客户依次分配方法，一个客户分配到按比例算出的...
JAVA实现平均分配N人 （分配到的数量和总金额近似相等）
热门推荐
初冬夏末
05-16 1万+
              //需要分配的人员集合（list）               //将人员集合顺序随机打乱 因为第一人分配到的案件总金额是最大的                Collections.shuffle(list);                final int size =list.size();                //将list转换成数组userList...
催收分案数据
weixin_30747253的博客
09-09 1088
催收分案数据，邮箱开启smtp服务 import pandas as pd import smtplib from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText from email.mime.image import MIMEImage from...
浅谈贷后管理之贷后跟踪——微金时代解决方案
weixin_33698043的博客
07-03 999
近年来，小贷公司贷款管理体制、机制和制度流程不断完善，特别在贷前调查、风险管控、信贷审批等方面取得长足进步，但是贷后管理始终是一个薄弱环节。从长远看，贷后管理的短板如果不解决，必将制约小贷公司核心竞争力的提升。下面我们就贷后跟踪进行简要的分析，并分析如何通过微金时代的业务系统减少贷后的风险。 众所周知，小贷公司是经营货币的一个特殊的行业，也是一个高风险行...
零售信贷业务的贷后管理与催收策略
"《电话集中催收的贷后管理要求-gps软件接收机教程》源自《兴业银行零售信贷业务操作手册2011版》，详细阐述了零售信贷业务的各个环节，包括基本信贷制度、利率与还款方式、担保方式以及业务合作机构的管理，并特别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值