怎样合并List的问题，很着急！！！！！！！，100分求助

Question

现在有一个List，里面有一个4个对象VoOrder，在VoOrder中有下面的属性（acctcode，acctno，amt，itemtype）和值acctcode      acctno         amt       itemType
CASH          0000ITME       100.00      C
CASH          0000ITEM       1000.00     C
CASHD         11111ITME      100.00      C
CASH          0000ITEM       900.00      C
ADVICE        2222ITEM       100.00      C
CASH          0000ITEM       900.00      C现在我想把acctcode相同的合并成一个，同时汇总amt，也就说，结果变成下面的这样子acctcode      acctno         amt       itemType
CASH          0000ITME       2900.00     C
CASHD         1111ITME       100.00      C
ADVICE        2222ITEM       100.00      C
不知道代码如何写，请高手帮忙，100分求助

Answer 1

我的意思是，我想要的结果同样放到一个list中，循环能出来。

Answer 2

怎么不一样呢，
遍历放入
HashMap<String,VoOrder>

Answer 3

但是我的属性非常多，可能不是上面的4个，或许太多
高手liushaoyi0704清给出一段清晰的代码，谢谢
100分全给你。

Answer 4

感觉你这个表结构设计的有问题，大量冗余数据。
是不是只要acctcode相同，acctno和itemType也都相同？

Answer 5

循环list把相同的合并.
List newList = null; //创建新的list
for(int i=0; i <orderList.size(); i++){ //stuList是你的那个封装好的list
  VoOrder order = (VoOrder) orderList.get(i); 
  if(newList == null){ 
      newList = new ArrayList(); 
      newList.add(order); 
  }else{ 
      for(int j=0; j <newList.size(); j++){ 
          VoOrder order1 = (VoOrder) newList.get(j); 
          if(order1.getAcctcode().equals(order.getAcctcode())){ 
              stu1.setAge(order1.getAmt() + order.getAmt()); //汇总amt
              newList.add(order1); 
          }else{ 
              newList.add(order); 
          } 
      } 
  } 
}

Answer 6

感觉你这个表结构设计的有问题，大量冗余数据。 
是不是只要acctcode相同，acctno和itemType也都相同？
是这样的

Answer 7

定义个Map<list,int>
再新定义个list2 ,把acctcode      相同的放在list2中，同时计算amt，然后再放入map中。
不知道这样行不行？！

Answer 8

ZhaoHuiZiXin
你是把过滤后的结果放到一个LIST中，是吗 ？怎么出不来啊 ！

Answer 9

List<VoOrder> list = ... ;//楼主现有的List对象。
Map<String,VoOrder> result = new HashMap<String,VoOrder>();//汇总辅助类。
for(VoOrder vo : list){
  VoOrder sum = result.get(vo.getAcctcode());
  if(sum==null){
    VoOrder newObj = new VoOrder();
    newObj.setAcctcode(vo.getAcctcode());newObj.setAcctno(vo.getAcctno());
    newObj.setAmt(vo.getAmt());newObj.setItemType(vo.getItemType());
    result.put(vo.getAcctcode(),newObj);
  }else{
    sum.setAmt(sum.getAmt()+vo.getAmt());
  }
}
List<VoOrder> result = new ArrayList<VoOrder>(sum.values());
//result就是楼主要的汇总结果。

Answer 10

方法可以，但是似乎效率不高，看看api，是否可以直接在原list中操作

Answer 11

是的, 你打印list.size()有值吗?

Answer 12

List<VoOrder> list = ... ;//楼主说的那个List对象。
Map<String,VoOrder> result = new HashMap<String,VoOrder>();
for(VoOrder stu : list){
if (result.containtsKey(stu.acctcode))
{
VoOrder temp = result.get(stu.acctcode);
float amt = temp.getAmt()+stu.getAmt();
temp.setAmt(amt);
} else {
VoOrder temp = new VoOrder();
temp.setAcctcode(stu.getAcctcode());
temp.setAcctno(stu.getAcctno());
temp.setItemType(stu.getItemType());
temp.setAmt(stu.getAmt());
result.put(stu.getAcctcode(),temp);
}}
//最后结果在result里面。

Answer 13

pubilc static ArrayList<VoOrder> countVoOrder(List<VoOrder>,myList){
ArrayList<VoOrder> result=new ArrayList<VoOrder>();
HashMap<String,VoOder> map=new HashMap<String,VoOrder>();
for(VoOrder vo:myList){
if(map.get(vo.acctno)!==null){
vo.amt+=map.get(vo.acctno).amt;
}
map.put(vo.acctno,vo);
}
result.addAll(map.value()s);
}

Answer 14

pubilc static ArrayList<VoOrder> countVoOrder(List<VoOrder> myList){
ArrayList<VoOrder> result=new ArrayList<VoOrder>();
HashMap<String,VoOder> map=new HashMap<String,VoOrder>();
for(VoOrder vo:myList){
if(map.get(vo.acctno)!==null){
vo.amt+=map.get(vo.acctno).amt;
}
map.put(vo.acctno,vo);
}
result.addAll(map.values());
}

Answer 15

谢谢liushaoyi0704
我最终还是想用这个LIST,也就是说我原来可能插入6行，现在过滤后我只需插入3行，好像你没有把结果放到我需要的LIST中啊 。

Answer 16

ZhaoHuiZiXin
你写的函数，一直循环，没有退出来。

Answer 17

修改以下，我上面的代码有误.List newList = null; //创建新的list for(int i=0; i <orderList.size(); i++){ //orderList是你的那个封装好的list   VoOrder order = (VoOrder) orderList.get(i); 
  if(newList == null){ 
      newList = new ArrayList(); 
      newList.add(order); 
  }else{ 
      for(int j=0; j <newList.size(); j++){ 
          VoOrder order1 = (VoOrder) newList.get(j); 
          if(order1.getAcctcode().equals(order.getAcctcode())){ 
              order1.remove(order1);//先删除
              order1.setAge(order1.getAmt() + order.getAmt());//汇总amt               newList.add(order1); //再添加          }else{ 
              newList.add(order); 
          } 
      } 
  } 
}

Answer 18

这个要求太简单了,不用新建result了,用myList.clear()把myList清空,再myList.addAll(map.values()).就可以了.

Answer 19

ZhaoHuiZiXin
你的函数还是有重复的数据。

Answer 20

原来我循环LIST,把需要的结果插入到数据库中，从 LIST中取VoOrder，
现在我执行同样的操作，还是从 LIST中取VoOrder，只不过我的LIST中的VoOrder过滤了，去掉重复的行。

Answer 21

关键是能给出一段清晰的代码。
也就是把LIST过滤后，在重新放到一个LIST中，是这样的吗？如果是，请高手们给出代码，
我还在学习中，请高手们帮助啊 ，万分谢谢

Answer 22

你的sql语句是怎么样的？
这么多重复数据？？
其实可以优化一下sql语句不就解决问题了么

Answer 23

好像还要在VoOrder类中重写equals方法

Answer 24

public class VoOrder { private String acctcode;
private String  acctno;
private double amt;
private String itemType;
/**
 * @return the acctcode
 */
public String getAcctcode() {
return acctcode;
}
/**
 * @return the acctno
 */
public String getAcctno() {
return acctno;
}
/**
 * @return the amt
 */
public double getAmt() {
return amt;
}
/**
 * @return the itemType
 */
public String getItemType() {
return itemType;
}
/**
 * @param acctcode the acctcode to set
 */
public void setAcctcode(String acctcode) {
this.acctcode = acctcode;
}
/**
 * @param acctno the acctno to set
 */
public void setAcctno(String acctno) {
this.acctno = acctno;
}
/**
 * @param amt the amt to set
 */
public void setAmt(double amt) {
this.amt = amt;
}
/**
 * @param itemType the itemType to set
 */
public void setItemType(String itemType) {
this.itemType = itemType;
}
}
测试类public class Test{ public static void main(String[] orgs)
{ /**这是在模拟你给出的数据*/
//begin
List<VoOrder> list=new ArrayList<VoOrder>();
VoOrder vo=null;
String[][] dateArryA={{"CASH","0000ITME","100.00","C"},
{"CASH","0000ITME","1000.00","C"},
{"CASHD","11111ITME","100.00","C"},
{"CASH","0000ITME","900.00","C"},
{"ADVICE","2222ITEM","100.00","C"},
{"CASH","0000ITME","900.00","C"}
};
for(int i=0;i<6;i++)
{
vo=new VoOrder();
vo.setAcctcode(dateArryA[i][0].toString());
vo.setAcctno(dateArryA[i][1].toString());
vo.setAmt(Double.valueOf(dateArryA[i][2]));
vo.setItemType(dateArryA[i][3].toString());
list.add(vo);
}
//end
        ArrayList<VoOrder> resultList=new ArrayList<VoOrder>();
        HashMap<String,VoOrder> map=new HashMap<String,VoOrder>();
        for(VoOrder voOrder:list){
            if(!map.isEmpty()&&map.containsKey(voOrder.getAcctcode())){
             voOrder.setAmt(voOrder.getAmt()+map.get(voOrder.getAcctcode()).getAmt());
              map.put(voOrder.getAcctcode(),voOrder);
            }
            else
            {
             map.put(voOrder.getAcctcode(),voOrder);  
            }
           
        }
        Set<String> set = map.keySet();   
        System.out.println("Acctcode"+ "  " +"Acctno"+"   "+"Amt"+"   "+"ItemType");   
            for (String key : set) {   
                System.out.println(key + "  " +map.get(key).getAcctno() +"  "+map.get(key).getAmt()+"   "+map.get(key).getItemType());   
            } 
    }
}

Answer 25

Acctcode  Acctno   Amt   ItemType
CASHD  11111ITME  100.0   C
ADVICE  2222ITEM  100.0   C
CASH  0000ITME    2900.0   C这是测试结果，这里的ArrayList<VoOrder> resultList=new ArrayList<VoOrder>();
没有用到。

Answer 26

楼主，sorry！ 刚才代码随手写的. 所以有测试了.List newList = null; //创建新的list 
for(int i=0; i <orderList.size(); i++){ //orderList是你的那个封装好的list   
  VoOrder order = (VoOrder) orderList.get(i); 
  if(newList == null){ 
      newList = new ArrayList(); 
      newList.add(order); 
  }else{ 
      boolean isexists = false;
      for(int j=0; j <newList.size(); j++){ 
          VoOrder order1 = (VoOrder) newList.get(j); 
          if(order1.getAcctcode().equals(order.getAcctcode())){ 
             order1.remove(order1);//先删除 
               order1.setAge(order1.getAmt() + order.getAmt());  
             newList.add(order1); //再添加          
               isexists = true;
             break;
           }
      } 
      if(!isexists)
         newlist.add(order);
  } 
}

Answer 27

如果你的list数据是从数据库里查除来的。建议你使用数据库的group by功能，查除来就是汇总的数据
select acctcode, acctno, sum( amt ) as amt , itemType , from TableName group by acctcode, acctno, itemType 

Answer 28

！！！！ order1.remove(order1);//先删除

Answer 29

25修改后还是有问题，你没有在全部iterator新list后才加入order，而是第一条记录就有可能加入，但是思想是对的，我稍微作了点修改修改25楼后给出例子假设搂主的原listname=aaa
你sql的statement就是从这个list中拿元素
利用代码处理后List newList = new ArrayList(); //这里可以使用和你原list相同类型的list
for(int i=0; i <aaa.size(); i++){ 
VoOrder order = (VoOrder) aaa.get(i); 
  if(newList == null){ 
      newList = new ArrayList(); 
      newList.add(order); 
  }else{ 
      for(int j=0; j <newList.size(); j++){ 
          boolean flag=false;
          VoOrder order1 = (VoOrder) newList.get(j); 
          if(order1.getAcctcode().equals(order.getAcctcode())){ 
              flag=true;
              order1.remove(order1);//先删除 
              order1.setAge(order1.getAmt() + order.getAmt());//汇总amt                newList.add(order1);        
           }
          if(flag=false&&newList.size==j+1){
              newList.add(order); 
          }
      } 
  } 
}最后这个名字为newList的就是整合后的list，你可以从这个list中读取数据到数据库也许还有错误，公司的电脑没有java环境，不好测试，实现的方法很多，用map可能更简单，楼主还是需要理解思想后自己考虑解决才能应对以后同样的问题

Answer 30

根据(才鸟一只)改的List<VoOrder> list2 = new ArrayList<VoOrder>();
Integer count = 0;
List<VoOrder> newList = null; // 创建新的list
for (int i = 0; i < list.size(); i++)
{ // orderList是你的那个封装好的list
VoOrder order = (VoOrder) list.get(i);
if(newList == null)
{
newList = new ArrayList<VoOrder>();
newList.add(order);
}
else{
boolean isexists = false;
for (int j = 0; j < newList.size(); j++){
VoOrder order1 =  newList.get(j);
if(order1.getAcctcode().equals(order.getAcctcode())){
newList.remove(order1);// 先删除
order1.setAmt(order1.getAmt() + order.getAmt());
newList.add(order1); // 再添加
isexists = true;
break;
}
}
if(!isexists)
newList.add(order);
}
}

Answer 31

其实，因为新list不会出现重复Acctcode，可以在循环中加入break，在查找到第一个相同Acctcode后就结束循环，提高效率

Answer 32

List <VoOrder> list = ... ;//楼主现有的List对象。 
Map <String,VoOrder> result = new HashMap <String,VoOrder>();//汇总辅助类。 
for(VoOrder vo : list){ //遍历List对象，进行汇总
  VoOrder sum = result.get(vo.getAcctcode()); //查看辅助map里面有没有汇总过类似的对象
  if(sum==null){ //没汇总过这个对象
    VoOrder newObj = new VoOrder(); //创建一个用于汇总的对象，目前只汇总当前对象。
    newObj.setAcctcode(vo.getAcctcode());newObj.setAcctno(vo.getAcctno()); 
    newObj.setAmt(vo.getAmt());newObj.setItemType(vo.getItemType()); 
    result.put(vo.getAcctcode(),newObj); 
  }else{ //汇总过类似的对象，继续汇总就可以了。
    sum.setAmt(sum.getAmt()+vo.getAmt()); //汇总amt的值。
  } 
} 
//将汇总后的结果放置到新的List对象中
List <VoOrder> result = new ArrayList <VoOrder>(sum.values()); 
//result就是楼主要的汇总结果。

Answer 33

public static List add(List oldList) { List newList = new ArrayList();
for (Iterator iterator = oldList.iterator(); iterator.hasNext();) { Object obj = (Object) iterator.next();

for (Iterator iterator2 = newList.iterator(); iterator2.hasNext();) {
Object newObj = (Object) iterator2.next();
if(obj.getId() == newObj.getId()) {
newList.remove(newObj);
obj.setAge(newObj.getAge() + obj.getAge());
break;
}
}
newList.add(obj);
}
return newList;
}

Answer 34

 newList.remove(order1);//先删除 

Answer 35

List<VoOrder> yourList = ;
List<VoOrder> newList = new ArrayList<VoOrder>();
Map<String,Double> record = new HashMap<String,Double>();
for(VoOrder order:yourList){
    if(record.containsKey(order.getAcctcode())){
        record.get(order.getAcctcode())+order.getAmt();
    }else{
        record.put(order.getAcctcode(),order.getAmt());
        newList.add(order);
    }
}
for(VoOrder order:newList){
    order.setAmt(record.get(order.getAcctcode()));
}
//newList 就是你想要的 

Answer 36

谢谢大家的回复。
我的意思很简单，就是如果重复，就合并，如果不重复，就原样操作，由于原来是循环List，进行插入数据库操作，因此我还想用循环List来插入数据库。

Answer 37

closewbq：你好，你能把你的结果更改成用LIST输出吗？不要用set输出。

Answer 38

非常感谢ZhaoHuiZiXin和wysunning，用你门的方法满足了我的要求。preferme的方法也不错，可是就是不能出来我需要的结果，preferme能给解决一下吗？谢谢。

Answer 39

public class CountVoOrder {
public static void main(String args[]) {

List<VoOrder> orderList = new ArrayList<VoOrder>();

orderList.add(new VoOrder("CASH", "0000ITME", 100.00, "C"));
orderList.add(new VoOrder("CASH", "0000ITME", 1000.00, "C"));
orderList.add(new VoOrder("CASHD", "11111ITME", 100.00, "C"));
orderList.add(new VoOrder("CASH", "0000ITME", 900.00, "C"));
orderList.add(new VoOrder("ADVICE", "2222ITEM", 100.00, "C"));
orderList.add(new VoOrder("CASH", "0000ITEM", 900.00, "C")); Map<String, VoOrder> orderMap = new HashMap<String, VoOrder>();
for(VoOrder order: orderList){
if(order != null && order.getAcctcode() != null){
if (orderMap.get(order.getAcctcode()) == null){
orderMap.put(order.getAcctcode(), order);
}else{
orderMap.get(order.getAcctcode()).setAmt(orderMap.get(order.getAcctcode()).getAmt() + order.getAmt());
}
}
}

// 其实这样就已经可以循环了：
//     for(String key: orderMap.keySet()){ 
//      VoOrder order = orderMap.get(key); 
// System.out.println(order.getAcctcode() + "\t\t" + order.getAcctno()+ "\t" + order.getAmt() + "\t\t" + order.getItemtype() );
//     }

orderList.clear();
orderList.addAll(orderMap.values());
System.out.println("acctcode\tacctno\t\tamt\t\titemType");
    for(VoOrder order: orderList){
System.out.println(order.getAcctcode() + "\t\t" + order.getAcctno()+ "\t" + order.getAmt() + "\t\t" + order.getItemtype() );
    }

}}

Answer 40

VoOrder是不是数据库中的对象啊？
如果是可以用SQL查询的时候直接处理，
select acctcode,acctno,sum(amt),itemType  from VoOrder group by acctcode;

Answer 41

sunnyfun888：谢谢你的回复。orderMap.get(order.getAcctcode()).setAmt(orderMap.get(order.getAcctcode()).getAmt() + order.getAmt());
这个有问题

Answer 42

sunnyfun888：谢谢你的回复。估计你也没有测试好，-_-

Answer 43

sunnyfun888：谢谢你的回复。估计你也没有测试好，-_-,汇总amt有问题/

Answer 44

什么问题？
这是运行结果acctcode acctno amt itemType
CASH 0000ITME 2900.0 C
CASHD 11111ITME 100.0 C
ADVICE 2222ITEM 100.0 C这是VoOrder类public class VoOrder {
String acctcode;
String acctno;
Double amt;
String itemtype;

VoOrder() { }
VoOrder(String acctcode, String acctno, Double amt, String itemtype) {
this.acctcode = acctcode;
this.acctno = acctno;
this.amt = amt;
this.itemtype = itemtype;
}
public String getAcctcode() {
return acctcode;
}
public void setAcctcode(String acctcode) {
this.acctcode = acctcode;
}
public String getAcctno() {
return acctno;
}
public void setAcctno(String acctno) {
this.acctno = acctno;
}
public Double getAmt() {
return amt;
}
public void setAmt(Double amt) {
this.amt = amt;
}
public String getItemtype() {
return itemtype;
}
public void setItemtype(String itemtype) {
this.itemtype = itemtype;
}
}如果amt有空值的话加点判断好了。

Answer 45

如果你是从数据库里取出的数据的话，
我建议你用SQL直接就先过滤了，比如，
你取出acctcode = CASH，借助数据库会很快，不要拿出来再用程序自己弄，慢，

Answer 46

既然说数据量很大，不建议在数据库外的操作
还是一个原因，Java内存管理原因
否则Map是最好的结构，快捷，方便。如果Map因为内存问题而不可用
希望你可以去SQL版问问。我可以很明确的告诉你，绝对可以解决。数据库是我们的朋友，放下你的戒心和烦躁

Answer 47

在写SQL的时候就一个 弄成你想要的结果吧 select sum(amt),acctcode，acctno,itemType from table  where ...  group by acctcode,acctno,itemType 

Answer 48

我就不明白了 List中你要合并两个list的值，list中本来就有增加元素的方法，你可以直接加进去啊 不就行了？

Answer 49

把acctcode相同的合并成一个这个你应该在sql中优化的,汇总amt这个也应该是在sql中进行的吧

Answer 50

将表和直接进行关联 将相同的字段只显示一条数据并对amt值进行相加不就可以了？

Answer 51

我也写了一个，参考一下：package org.chy;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class ATest { /**
 * @param args
 */
public static void main(String[] args) { VoOrder v1 = new VoOrder("CASH", "0000ITME", 100.00, "C");
VoOrder v2 = new VoOrder("CASH", "0000ITME", 1000.00, "C");
VoOrder v3 = new VoOrder("CASHD", "11111ITMEE", 100.00, "C");
VoOrder v4 = new VoOrder("CASH", "0000ITME", 100.00, "C");
VoOrder v5 = new VoOrder("CASH", "0000ITME", 900.00, "C");
VoOrder v6 = new VoOrder("ADVICE", "2222ITEM", 100.00, "C");
VoOrder v7 = new VoOrder("CASH", "0000ITME", 900.00, "C"); List<VoOrder> list = new ArrayList<VoOrder>();
list.add(v1);
list.add(v2);
list.add(v3);
list.add(v4);
list.add(v5);
list.add(v6);
list.add(v7); // 归并
List<VoOrder> lists = merge(list); // 打印验证
for (VoOrder v : lists) {
System.out.println(v.getAcctcod() + ":" + v.getAcctno() + ":"
+ v.getAmt() + ":" + v.getItemtype());
}
} public static class VoOrder implements Comparable<VoOrder> { private String acctcod;
private String acctno;
private double amt;
private String itemtype; public VoOrder() {
}; public VoOrder(String acctcod, String acctno, double amt,
String itemtype) {
this.acctcod = acctcod;
this.acctno = acctno;
this.amt = amt;
this.itemtype = itemtype;
} public String getAcctcod() {
return acctcod;
} public void setAcctcod(String acctcod) {
this.acctcod = acctcod;
} public String getAcctno() {
return acctno;
} public void setAcctno(String acctno) {
this.acctno = acctno;
} public String getItemtype() {
return itemtype;
} public void setItemtype(String itemtype) {
this.itemtype = itemtype;
} public int compareTo(VoOrder o) {
return this.acctno.compareTo(o.getAcctno());
} public double getAmt() {
return amt;
} public void setAmt(double amt) {
this.amt = amt;
} } public static List<VoOrder> merge(List<VoOrder> lists) {
// 先排序,将acctno相同的排在一起
Collections.sort(lists); List<VoOrder> results = new ArrayList<VoOrder>();
VoOrder first = lists.get(0); VoOrder current = null;
for (int i = 1; i < lists.size(); i++) {
current = lists.get(i);
if (first.getAcctno().equals(current.getAcctno())) {
double sum = first.getAmt();
first.setAmt(sum += current.getAmt());
} else {
VoOrder newVo = new VoOrder();
newVo.setAcctcod(first.getAcctcod());
newVo.setAcctno(first.getAcctno());
newVo.setAmt(first.getAmt());
newVo.setItemtype(first.getItemtype());
results.add(newVo);
first = current;
}
}
results.add(current);
return results;
}}

Answer 52

哦，对不起，上面的算法有BUG,更正如下：package org.chy;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class ATest { /**
 * @param args
 */
public static void main(String[] args) { VoOrder v1 = new VoOrder("CASH", "0000ITME", 100.00, "C");
VoOrder v2 = new VoOrder("CASH", "0000ITME", 1000.00, "C");
VoOrder v3 = new VoOrder("CASHD", "11111ITMEE", 100.00, "C");
VoOrder v4 = new VoOrder("CASH", "0000ITME", 100.00, "C");
VoOrder v5 = new VoOrder("CASH", "0000ITME", 900.00, "C");
VoOrder v6 = new VoOrder("ADVICE", "2222ITEM", 100.00, "C");
VoOrder v7 = new VoOrder("CASH", "0000ITME", 900.00, "C");
VoOrder v8 = new VoOrder("ADVICE", "2222ITEM", 100.00, "C"); List<VoOrder> list = new ArrayList<VoOrder>();
list.add(v1);
list.add(v2);
list.add(v3);
list.add(v4);
list.add(v5);
list.add(v6);
list.add(v7);
list.add(v8); // 归并
List<VoOrder> lists = merge(list); // 打印验证
for (VoOrder v : lists) {
System.out.println(v.getAcctcod() + ":" + v.getAcctno() + ":"
+ v.getAmt() + ":" + v.getItemtype());
}
} public static class VoOrder implements Comparable<VoOrder> { private String acctcod;
private String acctno;
private double amt;
private String itemtype; public VoOrder() {
}; public VoOrder(String acctcod, String acctno, double amt,
String itemtype) {
this.acctcod = acctcod;
this.acctno = acctno;
this.amt = amt;
this.itemtype = itemtype;
} public String getAcctcod() {
return acctcod;
} public void setAcctcod(String acctcod) {
this.acctcod = acctcod;
} public String getAcctno() {
return acctno;
} public void setAcctno(String acctno) {
this.acctno = acctno;
} public String getItemtype() {
return itemtype;
} public void setItemtype(String itemtype) {
this.itemtype = itemtype;
} public int compareTo(VoOrder o) {
return this.acctno.compareTo(o.getAcctno());
} public double getAmt() {
return amt;
} public void setAmt(double amt) {
this.amt = amt;
} } public static List<VoOrder> merge(List<VoOrder> lists) {
// 先排序,将acctno相同的排在一起
Collections.sort(lists); List<VoOrder> results = new ArrayList<VoOrder>();
VoOrder first = lists.get(0); VoOrder current = null;
java.util.Iterator<VoOrder> it = lists.iterator();
while (it.hasNext()) {
current = it.next();
if (first.getAcctno().equals(current.getAcctno())) {
double sum = first.getAmt();
first.setAmt(sum += current.getAmt());
} else {
VoOrder newVo = new VoOrder();
newVo.setAcctcod(first.getAcctcod());
newVo.setAcctno(first.getAcctno());
newVo.setAmt(first.getAmt());
newVo.setItemtype(first.getItemtype());
results.add(newVo);
first = current;
}
}
results.add(first);
return results;
}}

Answer 53

为什么不用数据库？这种操作一个sql就解决了啊

Answer 54

用sql把重复数据去掉就行了