[求算法达人！]关于多对多ArrayList处理！核心是核销！

Question

实在不好弄了。 集思广益
我先说下 业务场景
现在 2张表 非别代表  销售订单 与 回款单
在 同业务员 同客商的 未核销的数据  基础 上这是一个多对多的关系。
在8月 到11月 同时 发生了4比 销售 和4比回款
如何进行核销？SO                                               HK
单号   日期      金额     核销标志位           单号               日期       金额     核销标志位
——————————————           ——————————————————————————
订单1 8-26      500          N                 回款订单1         8-28          1000       N
订单2 9-1       1000         N                 回款订单2         8-29          5000       N
订单3 10-22     2000         N                 回款订单3         9-10          2000       N
订单4 11-5      5000         N                 回款订单4         12-31         500        N从数据库中 查出的数据是这样的在程序中的 得到 一个
ArrayList<销售订单> 的集合 
现在有4个销售订单  但是 每个销售订单实体里 又分别 有 4个 回款单如何写个 递归？就是每循环 把 销售和 回款 冲抵 了。后续的订单 就不在计算了。就是
订单1 8-26      500          N                 回款订单1         8-28          1000       N28号的回款 1000块  把 8-26的销售的500 给 核销了 N 变成Y了
但是 后续的销售订单 就不应该 跟 28号的 500 核销了。
这样的逻辑

Answer 1

用MAP吧，订单做key  汇款单做  value,map会冲掉原来值的  主要是这里还有个日期要考虑 ，后面的日期冲掉前面的日期 ，你在做的时候判断下两个日期

Answer 2

我现在就是用 Map 来存的

Answer 3

ArrayList<销售订单> 的集合  
现在有4个销售订单 但是 每个销售订单实体里 又分别 有 4个 回款单你的销售订单实体里有个汇款单的信息
所以遍历的你销售订单，查看订单实体的汇款单，看看是否有日期一致的，然后判断款额是否抵消，然后修改订单实体的核销标志位

Answer 4

用一个ArrayList来保存数据是不合逻辑的，虽然也可以实现建议你不要把从两个表查到的数据合并在一条记录里，因为任何一个订单和回单之间并没有必然联系。
把它们分别返回成两个ArrayList之后是两个ArrayList的对冲，能对冲掉的才修改数据库，改变核销状态。对冲的算法取决于你设计的业务逻辑，必须X张订单和Y张回单刚好完全对冲，还是可以X张订单和Y+0.5张回单对冲？如果是后者，数据库中需要扩充修改表结构，以保存未核销的半张回单。

Answer 5

同业务员 同客商
销售订单 回款单
销售单号 销售日期 销售金额 已回款 未回款 是否结算 回款单号 回款日期 回款金额  余额 是否结算
SO---1 8月26日 500 0 500 N HK---1 8月28日 1000 1000 N
SO---2 9月1日 1000 0 1000 N HK---2 8月29日 5000 5000 N
SO---3 10月22日 2000 0 2000 N HK---3 9月10日 2000 2000 N
SO---4 11月9日 5000 0 5000 N HK---4 12月31日 500 500 N


应该生成的单据
销售单号 销售日期 销售金额 已回款 未回款 回款单号 回款日期 回款金额  余额
SO---1 8月26日 500 500 0 HK---1 8月28日 500 500
SO---2 9月1日 1000 500 500 HK---1 8月28日 500 0
SO---2 9月1日 1000 500 0 HK---2 8月29日 500 4500
SO---3 10月22日 2000 2000 0 HK---2 8月29日 2000 2500
SO---4 11月9日 5000 2500 2500 HK---2 8月29日 2500 0
SO---4 11月9日 5000 500 2000 HK---4 12月31日 500 0

销售订单 回款单
销售单号 销售日期 销售金额 已回款 未回款 是否结算 回款单号 回款日期 回款金额  余额 是否结算
SO---1 8月26日 500 500 0 Y HK---1 8月28日 1000 0 Y
SO---2 9月1日 1000 1000 0 Y HK---2 8月29日 5000 0 Y
SO---3 10月22日 2000 2000 0 Y HK---3 9月10日 2000 0 Y
SO---4 11月9日 5000 500 2000 N HK---4 12月31日 500 0 Y

Answer 6

SO---4 11月9日 5000 2500 2500 HK---2 8月29日 2500 0
SO---4 11月9日 5000 500 2000 HK---4 12月31日 500 0 销售单号和回款单号是用什么关联起来的？

Answer 7

SO---4 11月9日 5000 500 2000 N  HK---4 12月31日 500 0 Y错了 不应该是500
应该是3000
SO---4 11月9日 5000 3000 2000 N  HK---4 12月31日 500 0 Y

Answer 8

public class SaleInfo {
private String saleNo; private String saleDate; private int saleAmount; private int saleReceived; private int saleUnreceived; private boolean isClosed;        //getter/setter....
}public class ReceivedInfo extends SaleInfo {
private String receivedNo; private String receivedDate; private int received; private int balance; private boolean isClosed;        //getter/setter....
}import java.util.ArrayList;
import java.util.List;
//SO---1 8月26日 500 0 500 N HK---1 8月28日 1000 1000 N
//SO---2 9月1日 1000 0 1000 N HK---2 8月29日 5000 5000 N
//SO---3 10月22日 2000 0 2000 N HK---3 9月10日 2000 2000 N
//SO---4 11月9日 5000 0 5000 N HK---4 12月31日 500 500 N
public class AggregationInfo extends ReceivedInfo {
@Override
public String toString() {
return super.toString();
} public static void main(String[] args) {
List<SaleInfo> saleList = new ArrayList<SaleInfo>();
List<ReceivedInfo> receivedList = new ArrayList<ReceivedInfo>();
List<AggregationInfo> aggreList = new ArrayList<AggregationInfo>(); SaleInfo saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---1");
saleInfo.setSaleDate("8月26日");
saleInfo.setSaleAmount(500);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(500);
saleList.add(saleInfo); saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---2");
saleInfo.setSaleDate("9月1日");
saleInfo.setSaleAmount(1000);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(1000);
saleList.add(saleInfo); saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---3");
saleInfo.setSaleDate("10月22日");
saleInfo.setSaleAmount(2000);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(2000);
saleList.add(saleInfo); saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---4");
saleInfo.setSaleDate("11月9日");
saleInfo.setSaleAmount(5000);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(5000);
saleList.add(saleInfo); ReceivedInfo receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---1");
receivedInfo.setReceivedDate("8月28日");
receivedInfo.setReceived(1000);
receivedInfo.setBalance(1000);
receivedList.add(receivedInfo); receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---2");
receivedInfo.setReceivedDate("8月29日");
receivedInfo.setReceived(5000);
receivedInfo.setBalance(5000);
receivedList.add(receivedInfo); receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---3");
receivedInfo.setReceivedDate("9月10日");
receivedInfo.setReceived(2000);
receivedInfo.setBalance(2000);
receivedList.add(receivedInfo); receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---4");
receivedInfo.setReceivedDate("12月31日");
receivedInfo.setReceived(500);
receivedInfo.setBalance(500);
receivedList.add(receivedInfo);
for(int i = 0; i < saleList.size(); i++) {
saleInfo = saleList.get(i);
receivedInfo = receivedList.get(i);

if(saleInfo.getSaleUnreceived() != 0 && receivedInfo.getReceived() != 0) {
int r = receivedInfo.getReceived() - saleInfo.getSaleUnreceived(); if(r > 0) {
ReceivedInfo ri = new ReceivedInfo();
ri.setReceivedNo(receivedInfo.getReceivedNo());
ri.setReceivedDate(receivedInfo.getReceivedDate());
ri.setReceived(r);
ri.setBalance(0);
receivedList.add(i, ri);
}
else {
SaleInfo si = new SaleInfo();
si.setSaleNo(saleInfo.getSaleNo());
si.setSaleDate(saleInfo.getSaleDate());
si.setSaleAmount(saleInfo.getSaleAmount());
si.setSaleReceived(receivedInfo.getReceived());
si.setSaleUnreceived(0);
saleList.add(i, si);
} AggregationInfo aggreInfo = new AggregationInfo();
aggreInfo.setSaleNo(saleInfo.getSaleNo());
aggreInfo.setSaleDate(saleInfo.getSaleDate());
aggreInfo.setSaleAmount(saleInfo.getSaleAmount());
aggreInfo.setSaleReceived(saleInfo.getSaleReceived());
aggreInfo.setSaleUnreceived(saleInfo.getSaleUnreceived());
aggreInfo.setReceivedNo(receivedInfo.getReceivedNo());
aggreInfo.setReceivedDate(receivedInfo.getReceivedDate());
aggreInfo.setReceived(r > 0 ? r : receivedInfo.getReceived());
aggreInfo.setBalance(r > 0 ? r : 0);
System.err.println(aggreInfo);
}
}
}
}
大概就这么个思想，你自己调试吧。

Answer 9

public   class   SaleInfo   {
private   String   saleNo;private   String   saleDate;private   int   saleAmount;private   int   saleReceived;private   int   saleUnreceived;private   boolean   isClosed;                //getter/setter....
}public   class   ReceivedInfo   extends   SaleInfo   {
private   String   receivedNo;private   String   receivedDate;private   int   received;private   int   balance;private   boolean   isClosed;                //getter/setter....
}

Answer 10

import java.util.ArrayList;
import java.util.List;
//SO---1 8月26日 500 0 500 N HK---1 8月28日 1000 1000 N
//SO---2 9月1日 1000 0 1000 N HK---2 8月29日 5000 5000 N
//SO---3 10月22日 2000 0 2000 N HK---3 9月10日 2000 2000 N
//SO---4 11月9日 5000 0 5000 N HK---4 12月31日 500 500 N
public class AggregationInfo extends ReceivedInfo {
@Override
public String toString() {
return super.toString();
} public static void main(String[] args) {
List<SaleInfo> saleList = new ArrayList<SaleInfo>();
List<ReceivedInfo> receivedList = new ArrayList<ReceivedInfo>();
List<AggregationInfo> aggreList = new ArrayList<AggregationInfo>(); SaleInfo saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---1");
saleInfo.setSaleDate("8月26日");
saleInfo.setSaleAmount(500);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(500);
saleList.add(saleInfo); saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---2");
saleInfo.setSaleDate("9月1日");
saleInfo.setSaleAmount(1000);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(1000);
saleList.add(saleInfo); saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---3");
saleInfo.setSaleDate("10月22日");
saleInfo.setSaleAmount(2000);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(2000);
saleList.add(saleInfo); saleInfo = new SaleInfo();
saleInfo.setSaleNo("SO---4");
saleInfo.setSaleDate("11月9日");
saleInfo.setSaleAmount(5000);
saleInfo.setSaleReceived(0);
saleInfo.setSaleUnreceived(5000);
saleList.add(saleInfo); ReceivedInfo receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---1");
receivedInfo.setReceivedDate("8月28日");
receivedInfo.setReceived(1000);
receivedInfo.setBalance(1000);
receivedList.add(receivedInfo); receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---2");
receivedInfo.setReceivedDate("8月29日");
receivedInfo.setReceived(5000);
receivedInfo.setBalance(5000);
receivedList.add(receivedInfo); receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---3");
receivedInfo.setReceivedDate("9月10日");
receivedInfo.setReceived(2000);
receivedInfo.setBalance(2000);
receivedList.add(receivedInfo); receivedInfo = new ReceivedInfo();
receivedInfo.setReceivedNo("HK---4");
receivedInfo.setReceivedDate("12月31日");
receivedInfo.setReceived(500);
receivedInfo.setBalance(500);
receivedList.add(receivedInfo);
for(int i = 0; i < saleList.size(); i++) {
saleInfo = saleList.get(i);
receivedInfo = receivedList.get(i);

if(saleInfo.getSaleUnreceived() != 0 && receivedInfo.getReceived() != 0) {
int r = receivedInfo.getReceived() - saleInfo.getSaleUnreceived(); if(r > 0) {
ReceivedInfo ri = new ReceivedInfo();
ri.setReceivedNo(receivedInfo.getReceivedNo());
ri.setReceivedDate(receivedInfo.getReceivedDate());
ri.setReceived(r);
ri.setBalance(0);
receivedList.add(i, ri);
}
else {
SaleInfo si = new SaleInfo();
si.setSaleNo(saleInfo.getSaleNo());
si.setSaleDate(saleInfo.getSaleDate());
si.setSaleAmount(saleInfo.getSaleAmount());
si.setSaleReceived(receivedInfo.getReceived());
si.setSaleUnreceived(0);
saleList.add(i, si);
} AggregationInfo aggreInfo = new AggregationInfo();
aggreInfo.setSaleNo(saleInfo.getSaleNo());
aggreInfo.setSaleDate(saleInfo.getSaleDate());
aggreInfo.setSaleAmount(saleInfo.getSaleAmount());
aggreInfo.setSaleReceived(saleInfo.getSaleReceived());
aggreInfo.setSaleUnreceived(saleInfo.getSaleUnreceived());
aggreInfo.setReceivedNo(receivedInfo.getReceivedNo());
aggreInfo.setReceivedDate(receivedInfo.getReceivedDate());
aggreInfo.setReceived(r > 0 ? r : receivedInfo.getReceived());
aggreInfo.setBalance(r > 0 ? r : 0);
System.err.println(aggreInfo);
}
}
}
}

Answer 11

我思考了一下LZ的课题，因没有LZ所涉及的商务经验，
所以纯粹是根据猜想写出一个粗线条的业务逻辑，
就算是做个练习吧，如能给LZ提供点帮助更好。//为说明问题，先粗定义几个Pojo类class 购货公司{
private String id    //主键，不可重复
private String 名称
....
}class So{  //销售订单类
private String  购货公司ID //外键
private String  单号
private String  日期
private Long    金额
private String  核销标志位
//privave Set<Hk> 回单集   根据情况设计是不是要它（下面的例子可以不要它）
//
//geter/seter
//
}
class Hk{ //回款单类
private String  购货公司ID //外键
private String  单号
private String  日期
private Long    金额
private String  核销标志位
privave Set<So> 订单集     //销售订单集
//
//geter/seter
//
}
//上面的两个类属性好像是一样的，但是其中的方法（职责）应该是不一样的。
//上面两个类的关键点是，与其相关联的实体集采取什么样的映射策略。
//我下面的例子，主类是Hk , So是从属类。//还有LZ中间要生成的单据类，（略）///////////////////////////////////////////////////////
/* 核销业务描述 */
public void 核销订单{
//
//连接数据库，初始化Dao(视情而定)
....
//
//准备一个销售订单集：
Set<So> soSet = null;//销售订单集
//根据购货公司ID，从数据库取得回款单集
List<Hk> hkList = (ArryList<Hk>)hkDao.getHkList(购货公司.getId());
//注：hk对象中包含了与其相关联的未冲销订单集 //hkList不空就做下面的循环
//扫描回款单集
for(Hk hk : hkList){
//从每个回款单中取得与其相关的未冲销的销售订单集：
soSet = (Set<So>)hk.get订单集();
//再扫描上边取得的销售订单集（现在回款单号已锁定）
//soSet不空就做下面的事
for (So so : soSet){
//
//根据 回款单(hk)和销售订单(so)的数据，
//做具体的冲销业务，记入相关类中。
// //调用数据库持久类，将名对象写入数据库:
hkDao.update(hk);    //这个持久关联销售订单跟着持久（这要看你的实体类是如何设计的）
//soDao.update(so);  //不需要了（这要看你的实体类是如何设计的）
其他单据持久(不是有一个中间生成的什么单据吗)
}
}
return;
}

Answer 12

修改一下///////////////////////////////////////////////////////
/* 核销业务描述 */
public void 核销订单{
//
//连接数据库，初始化Dao(视情而定)
....
//
//准备一个销售订单集：
Set<So> soSet = null;//销售订单集
//根据购货公司ID，从数据库取得回款单集
List<Hk> hkList = (ArryList<Hk>)hkDao.getHkList(购货公司.getId());
//注：hk对象中包含了与其相关联的未冲销订单集 //hkList不空就做下面的循环
//扫描回款单集
for(Hk hk : hkList){
//从每个回款单中取得与其相关的未冲销的销售订单集：
soSet = (Set<So>)hk.get订单集();
//再扫描上边取得的销售订单集（现在回款单号已锁定）
//soSet不空就做下面的事
for (So so : soSet){
//
//根据 回款单(hk)和销售订单(so)的数据，
//做具体的冲销业务，记入相关类中。
// }
//调用数据库持久类，将名对象写入数据库:
hkDao.update(hk);    //这个持久关联销售订单跟着持久（这要看你的实体类是如何设计的）
//soDao.update(so);  //不需要了（这要看你的实体类是如何设计的）
其他单据持久(不是有一个中间生成的什么单据吗)
}
return;
}