项目中有个算法写不出来了，求助各位大虾们

如果AB两列不相等就直接return false不考虑了哈？
那么AB两列就当一个参数啊，这里取A。
至于C，D两列，把C-D的差当另一个值E，//伪代码
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
E = C-D;
if(map.contains(A)){
map.put(map.get(A)+E);
}else{
map.put(A, E);
}
//然后 for(Integer key : map.getKeySet()) 判断map.get(key)是否为0就行？
个人想法，期待更好的算法。

推荐下，那些个sql大牛一句话给你搞定

是这个意思吗实在不明白a b为什么分成两列
select a, b, case when sum(c) = sum(d) then 'accept' else 'error' end
from table_name
group by a ,b

我觉得主要是lz没解释清楚
“在AB列都必须相等的情况下” 是A列和B列相等还是 A列和A列相等,B列和B列相等
但是看lz后面的求和应该是后面的意思

这是找出所有error的
select T1.* from (
select A,sum(C) as SC, sum(D) as SD from item where A = B group by A) T1
where T1.SC <> T1.SD

select sum(d)as d,sum(c) as c from table
where a=b
group by aselect * from (
select sum(d)as d,sum(c) as c from table
where a=b
group by a
)
where d=c没试不知道正确不正确。

楼上的，分组sum 满足不？

不好意思哈，SQL文不能够变更，list里的数据就是查询之后放进去的，只不过做校验时有这个需求

为了保证业务逻辑清晰，便于维护，建议还是分两步走。第一步：将A,B列作为Key，做两个动作：1.跳过A不等于B的；2.C列求和，D列求和。第二步：判断第一步得到的集合中，C列和是否等于D列和。我觉得，既然是正是项目，就别搞那么多花样，老老实实地按照原始逻辑来做。优化那是以后的事情，现在关键要易读易改。

4楼与9楼的朋友刚好把楼主不同情况的要求瞒住了一下，楼主你的问题解决了么不能够用SQL，只能单纯java查找

感谢你提供的算法，但是有办法找出不符合的吗，我要不符合的所有都变色，报一个error

感谢你提供的算法，但是有办法找出不符合的吗，我要不符合的所有都变色，报一个error
感谢你提供的算法，但是有办法找出不符合的吗，我要不符合的所有都变色，报一个error你在MSDN查一下map的使用，就可以发现，你的需求是可以满足的！至于逻辑上的思路，这个貌似很简单吧！

select a, b, case when sum(c) = sum(d) then 'accept' else 'error' end
from table_name WHERE a = b
group by a ,b

还有一个问题是怎么输出不等列的在列表的位置番号
例如上面：
AB列均为“2 ” C列40+50+60与 D列的100+200+300不相等，输出“error”
还要输出 “第4行第5行第6行错误”

还有一个问题是怎么输出不等列的在列表的位置番号
例如上面：
AB列均为“2 ”   C列40+50+60与 D列的100+200+300不相等，输出“error”
还要输出  “第4行第5行第6行错误”
不知道你具体数据结构，看一下这样写是否符合你的要求。羡丑：package csdn;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;class Data{
/**
* 模拟一下数据
*/
private int argA;
private int argB;
private int argC;
private int argD;
public int getArgA() {
return argA;
}
public void setArgA(int argA) {
this.argA = argA;
}
public int getArgB() {
return argB;
}
public void setArgB(int argB) {
this.argB = argB;
}
public int getArgC() {
return argC;
}
public void setArgC(int argC) {
this.argC = argC;
}
public int getArgD() {
return argD;
}
public void setArgD(int argD) {
this.argD = argD;
}
public Data(int argA, int argB, int argC, int argD) {
super();
this.argA = argA;
this.argB = argB;
this.argC = argC;
this.argD = argD;
}
public Data(){

}
@Override
public String toString(){
return String.format("%d,%d,%d,%d", argA, argB, argC, argD);
}

}
/**
* 数据检测
* @author sztsiang
*
*/
public class DataChecker { private  Map<Integer, Integer> map = new HashMap<Integer, Integer>();

private void add(int key, int value){
if(map.containsKey(key))
map.put(key, map.get(key) + value);
else{
map.put(key, value);
}
}

public void add(int argA, int argB, int argC, int argD){
if(argA == argB){
add(argA, argC - argD);
}
}
private boolean check(int key){
Integer v = map.get(key);
return null != v && v == 0;//仅值不为空且为0时为符合条件的
}

public boolean check(int argA, int argB){
return argA == argB && check(argA);//仅A值与B值相等才去查找，否则直接不符合
}

public static void main(String[] args) {
// TODO Auto-generated method
List<Data> list = new ArrayList<Data>();//表面上模拟一下，不知道你项目中真实的数据结构
list.add(new Data(1, 1, 10, 10));
list.add(new Data(1, 1, 20, 20));
list.add(new Data(2, 2, 10, 10));
list.add(new Data(3, 4, 10, 10));
list.add(new Data(2, 2, 20, 10));

DataChecker dc = new DataChecker();
//存入map
for(Data data : list){
dc.add(data.getArgA(), data.getArgB(), data.getArgC(), data.getArgD());
}
//遍历打印
for(Data d : list){
System.out.print(d);
if(dc.check(d.getArgA(), d.getArgB())){
System.out.println(" true");
}else{
System.out.println(" error");
}
}
}}
/**运行结果：
1,1,10,10 true
1,1,20,20 true
2,2,10,10 error
3,4,10,10 error
2,2,20,10 error
*/

还有一个问题是怎么输出不等列的在列表的位置番号
例如上面：
AB列均为“2 ”   C列40+50+60与 D列的100+200+300不相等，输出“error”
还要输出  “第4行第5行第6行错误”
不知道你具体数据结构，看一下这样写是否符合你的要求。羡丑：package csdn;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;class Data{
/**
* 模拟一下数据
*/
private int argA;
private int argB;
private int argC;
private int argD;
public int getArgA() {
return argA;
}
public void setArgA(int argA) {
this.argA = argA;
}
public int getArgB() {
return argB;
}
public void setArgB(int argB) {
this.argB = argB;
}
public int getArgC() {
return argC;
}
public void setArgC(int argC) {
this.argC = argC;
}
public int getArgD() {
return argD;
}
public void setArgD(int argD) {
this.argD = argD;
}
public Data(int argA, int argB, int argC, int argD) {
super();
this.argA = argA;
this.argB = argB;
this.argC = argC;
this.argD = argD;
}
public Data(){

}
@Override
public String toString(){
return String.format("%d,%d,%d,%d", argA, argB, argC, argD);
}

}
/**
* 数据检测
* @author sztsiang
*
*/
public class DataChecker { private  Map<Integer, Integer> map = new HashMap<Integer, Integer>();

private void add(int key, int value){
if(map.containsKey(key))
map.put(key, map.get(key) + value);
else{
map.put(key, value);
}
}

public void add(int argA, int argB, int argC, int argD){
if(argA == argB){
add(argA, argC - argD);
}
}
private boolean check(int key){
Integer v = map.get(key);
return null != v && v == 0;//仅值不为空且为0时为符合条件的
}

public boolean check(int argA, int argB){
return argA == argB && check(argA);//仅A值与B值相等才去查找，否则直接不符合
}

public static void main(String[] args) {
// TODO Auto-generated method
List<Data> list = new ArrayList<Data>();//表面上模拟一下，不知道你项目中真实的数据结构
list.add(new Data(1, 1, 10, 10));
list.add(new Data(1, 1, 20, 20));
list.add(new Data(2, 2, 10, 10));
list.add(new Data(3, 4, 10, 10));
list.add(new Data(2, 2, 20, 10));

DataChecker dc = new DataChecker();
//存入map
for(Data data : list){
dc.add(data.getArgA(), data.getArgB(), data.getArgC(), data.getArgD());
}
//遍历打印
for(Data d : list){
System.out.print(d);
if(dc.check(d.getArgA(), d.getArgB())){
System.out.println(" true");
}else{
System.out.println(" error");
}
}
}}
/**运行结果：
1,1,10,10 true
1,1,20,20 true
2,2,10,10 error
3,4,10,10 error
2,2,20,10 error
*/
可能是我没说清楚
A列和B列完全一样的时候，是一个组合，此时判断这组数据的C列和D列是否相等。
1,1,10,10 true
1,1,20,20 true
这个是对的，这组数据，C列的和等于D列的和，所以输出“true”。2,2,10,10 error
2,2,20,10 error
这个是对的，这组数据，C列的和不等于D列的和,所以输出“false”。3,4,10,10 error
这个是错的，这组数据，C列的和等于D列的和,所以输出“true”。

用sql还是c++
sql 这么来select case sum(c) - sum(d) when 0 then 'true' else 'false' from tablename where a  = b group by a,b
c++的话么先定义一个结构体或者类，然后排序（排序同学你就自己做吧，你别说排序不会呀）,最后逐条判断，输出#include <iostream>
#define INT_DATA_NUM 10
struct Data
{
  int a;
  int b;
  int c;
  int d;
}int main()
{
  Data MyDatas[INT_DATA_NUM];
  for (int i = 0; i < INT_DATA_NUM; i++)
{
     MyDatas[i].a =// 自己填吧，ABCD,生成待判断的数据
}
//接下来排序，排序方法很多自己弄吧，比如你可以把A * 10000然后加上B生成一个AB，用AB排序，冒泡就行。（取决于A,B的最大值）
//判断c和d的值。
int SumC,SumD, LastA, LastB;
SumC = 0;
SumD = 0;
for(int j = 0 ; j <  INT_DATA_NUM; j++)
{
   if (j == 0)
  {
      LastA = MyDatas[j].a;
      LastB = MyDatas[j].b;
      SumC = MyDatas[j].c;
      SumD = MyDatas[j].d;
  }
  else
  {

     if (MyDatas[j].a == LastA && MyDatas[j].b == LastB)
    {
       SumC += MyDatas[j].c;
       SumD += MyDatas[j].d;
    }
    else
    {
        if (SumC == SumD  && LastA == LastB)
           cout << "true" << endl;
        else (SumC!= SumD && LastA == LastB)
           cout << "false" << endl;
        SumC = 0;
        SumD = 0;
    }
  }

}
}代码细节可能有错，总之你领会一下意思，自己好好写。不要学上班逢包就发到青岛的美国佬。

子查询不是只是获取 C 与 D 的和么条件是A=B A 分组
外查询才比对，是我理解错了还是？求指点

感觉逻辑应该是对的，只是输出没有达到楼主想要的，改了一下输出方式，楼主认为这样如何？
List<Integer> a=new ArrayList<Integer>();
for(Data d : list){
            if(map.containsKey(d.getArgA())){
                        if(a.contains(d.getArgA())){
                            continue;
                         }else{
                              a.add(d.getArgA());
                         }
                         System.out.print(d);
                         if(dc.check(d.getArgA(), d.getArgB())){
                             System.out.println(" true");
                        }else{
                               System.out.println(" error");
            }
}结果：
1 1 true
2 2 error

我去，没法编辑自己帖子，刚才有写错，是这样
List<Integer> a=new ArrayList<Integer>();
        for(Data d : list){
            if(map.containsKey(d.getArgA())){
             if(a.contains(d.getArgA())){
             continue;
             }else{
             a.add(d.getArgA());
             }
             System.out.print(d.getArgA()+"\t"+d.getArgB()+"\t");
            if(dc.check(d.getArgA(), d.getArgB())){
                 System.out.println("true");
            }else{
                   System.out.println("error");
            }
           }
        }
结果：
1 1 true
2 2 error

"3,4,10,10 error
这个是错的，这组数据，C列的和等于D列的和,所以输出“true”。"
看LZ说的这个就更不懂你这个到底是怎么个要求了

public class Test {
    public static class Key {
        public Key(int i, int j) {
            this.i = i;
            this.j = j;
        }        int i;
        int j;        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + i;
            result = prime * result + j;
            return result;
        }        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Key other = (Key) obj;
            if (i != other.i)
                return false;
            if (j != other.j)
                return false;
            return true;
        }
    }    public static void main(String[] args) {
        int[][] nums = { { 1, 1, 10, 10 }, { 1, 1, 20, 20 }, { 1, 1, 30, 30 }, { 2, 2, 40, 100 }, { 2, 2, 50, 200 }, { 2, 2, 60, 300 }, { 3, 3, 70, 70 }, { 3, 4, 80, 80 }, { 3, 4, 90, 90 }, { 4, 3, 90, 90 }, { 4, 3, 100, 100 }, { 4, 3, 100, 100 } };
        Map<Key, List<int[]>> map = new HashMap<Key, List<int[]>>();
        int index = 0;
        for (int[] row : nums) {
            Key key = new Key(row[0], row[1]);
            if (map.containsKey(key)) {
                List<int[]> list = map.get(key);
                int value[] = list.get(0);
                int[] o = new int[6];
                System.arraycopy(row, 0, o, 0, 4);
                o[4] = value[4] + row[2] - row[3];
                o[5] = index++;
                value[4] = o[4];
                list.add(o);
            } else {
                int[] o = new int[6];
                System.arraycopy(row, 0, o, 0, 4);
                o[4] = row[2] - row[3];
                o[5] = index++;
                List<int[]> list = new ArrayList<int[]>();
                list.add(o);
                map.put(key, list);
            }
        }
        for (Key key : map.keySet()) {
            List<int[]> list = map.get(key);
            for (int[] row : list) {
                System.out.println("第" + row[5] + "行[" + row[0] + "," + row[1] + "," + row[2] + "," + row[3] + "," + "] : " + (row[4] == 0 ? "OK" : "Error"));
            }
        }
    }
}

将AB列做成一个联合主键，值为C和D，这样的话，map<key,value> 就是最终的结果。
每一个key对应的alue 由多个 C和D ，然后再进行判断。就可以了

还有一个问题是怎么输出不等列的在列表的位置番号
例如上面：
AB列均为“2 ”   C列40+50+60与 D列的100+200+300不相等，输出“error”
还要输出  “第4行第5行第6行错误”
不知道你具体数据结构，看一下这样写是否符合你的要求。羡丑：package csdn;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;class Data{
/**
* 模拟一下数据
*/
private int argA;
private int argB;
private int argC;
private int argD;
public int getArgA() {
return argA;
}
public void setArgA(int argA) {
this.argA = argA;
}
public int getArgB() {
return argB;
}
public void setArgB(int argB) {
this.argB = argB;
}
public int getArgC() {
return argC;
}
public void setArgC(int argC) {
this.argC = argC;
}
public int getArgD() {
return argD;
}
public void setArgD(int argD) {
this.argD = argD;
}
public Data(int argA, int argB, int argC, int argD) {
super();
this.argA = argA;
this.argB = argB;
this.argC = argC;
this.argD = argD;
}
public Data(){

}
@Override
public String toString(){
return String.format("%d,%d,%d,%d", argA, argB, argC, argD);
}

}
/**
* 数据检测
* @author sztsiang
*
*/
public class DataChecker { private  Map<Integer, Integer> map = new HashMap<Integer, Integer>();

private void add(int key, int value){
if(map.containsKey(key))
map.put(key, map.get(key) + value);
else{
map.put(key, value);
}
}

public void add(int argA, int argB, int argC, int argD){
if(argA == argB){
add(argA, argC - argD);
}
}
private boolean check(int key){
Integer v = map.get(key);
return null != v && v == 0;//仅值不为空且为0时为符合条件的
}

public boolean check(int argA, int argB){
return argA == argB && check(argA);//仅A值与B值相等才去查找，否则直接不符合
}

public static void main(String[] args) {
// TODO Auto-generated method
List<Data> list = new ArrayList<Data>();//表面上模拟一下，不知道你项目中真实的数据结构
list.add(new Data(1, 1, 10, 10));
list.add(new Data(1, 1, 20, 20));
list.add(new Data(2, 2, 10, 10));
list.add(new Data(3, 4, 10, 10));
list.add(new Data(2, 2, 20, 10));

DataChecker dc = new DataChecker();
//存入map
for(Data data : list){
dc.add(data.getArgA(), data.getArgB(), data.getArgC(), data.getArgD());
}
//遍历打印
for(Data d : list){
System.out.print(d);
if(dc.check(d.getArgA(), d.getArgB())){
System.out.println(" true");
}else{
System.out.println(" error");
}
}
}}
/**运行结果：
1,1,10,10 true
1,1,20,20 true
2,2,10,10 error
3,4,10,10 error
2,2,20,10 error
*/
可能是我没说清楚
A列和B列完全一样的时候，是一个组合，此时判断这组数据的C列和D列是否相等。
1,1,10,10 true
1,1,20,20 true
这个是对的，这组数据，C列的和等于D列的和，所以输出“true”。2,2,10,10 error
2,2,20,10 error
这个是对的，这组数据，C列的和不等于D列的和,所以输出“false”。3,4,10,10 error
这个是错的，这组数据，C列的和等于D列的和,所以输出“true”。

感觉被你玩了。

弄了半天你告诉我，不管A与B相等不相等，都要把C和D的列值求和各判断相等不相等，这与你之前的说法性质上不一样啊。
如果是这样的话，你把A与B的组合作为KEY，C与D的差作为值，放入map就可以了。
一个简单示例代码：package csdn;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;class Data{
private int argA;
private int argB;
private int argC;
private int argD;
public Data(){

}
public Data(int argA, int argB, int argC, int argD) {
super();
this.argA = argA;
this.argB = argB;
this.argC = argC;
this.argD = argD;
}
public int getArgA() {
return argA;
}
public void setArgA(int argA) {
this.argA = argA;
}
public int getArgB() {
return argB;
}
public void setArgB(int argB) {
this.argB = argB;
}
public int getArgC() {
return argC;
}
public void setArgC(int argC) {
this.argC = argC;
}
public int getArgD() {
return argD;
}
public void setArgD(int argD) {
this.argD = argD;
}
@Override
public String toString(){
return String.format("[%d,%d,%d,%d]", argA, argB, argC, argD);
}

}
public class DataChecker2 { private Map<String, Integer> map = new HashMap<String, Integer>();
private void add(String key, Integer value){//私有方法
if (map.containsKey(key)) {
map.put(key, map.get(key)+value);//累加
}else{
map.put(key, value);//如果之前没有直接放入
}
}
public void add(int argA, int argB, int argC, int argD){//传入为一个Data对象的四个参数
add(argA+"_"+argB, argC - argD);
}
public void add(Data data){//参数为一个Data对象
add(data.getArgA(), data.getArgB(), data.getArgC(), data.getArgD());
}
private boolean check(String key){
Integer value = map.get(key);
return null != value && value == 0;//只有不为null且等于0为真
}
public boolean check(int argA, int argB){//参数为A与B
return check(argA + "_" + argB);
}
public boolean check(Data data){//传入为一个Data对象
return check(data.getArgA(), data.getArgB());
}
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Data> list = new ArrayList<Data>();
list.add(new Data(1, 1, 10, 10));
        list.add(new Data(1, 1, 20, 20));
        list.add(new Data(2, 2, 10, 10));
        list.add(new Data(2, 2, 20, 10));
        list.add(new Data(3, 4, 10, 10));        DataChecker2 dc = new DataChecker2();
        for(Data data : list){
         dc.add(data);
        }
        //打印
        for(Data data : list){

         System.out.print(data);
         System.out.print("==>");
         if(dc.check(data)){
         System.out.println("true");
         }else{
         System.out.println("false");
         }
        }
}}
输出结果：
[1,1,10,10]==>true
[1,1,20,20]==>true
[2,2,10,10]==>false
[2,2,20,10]==>false
[3,4,10,10]==>true还要改需求么？

#include "stdafx.h"
#include <string.h>#pragma pack(4)
struct DataGroup
{
int A;
int B;
int C;
int D;
};
#pragma pack()const DataGroup datas[] = {
{ 1, 1, 10, 10 },
{ 1, 1, 20, 20 },
{ 1, 1, 30, 30 },
{ 2, 2, 40, 100},
{ 2, 2, 50, 200},
{ 2, 2, 60, 300},
{ 3, 3, 70, 70 },
{ 3, 4, 80, 80 },
{ 3, 4, 90, 90 },
{ 4, 3, 90, 90 },
{ 4, 3, 100,100},
{ 4, 3, 100,100}
};#define MAX_INT 0x7FFFFFFFvoid procSum(int i, int dataCount, char* , int A, int B, int& sumC, int& sumD)
{
for(; i < dataCount; i++)
{
if(datas[i].A == A && B == datas[i].B)
{
sumC += datas[i].C;
sumD += datas[i].D;
[i] = (char)1; //设置计算标识
}
}
}int _tmain(int argc, _TCHAR* argv[])
{
int start = 0;
int sumC, sumD;
int dataCount = sizeof(datas) / sizeof(DataGroup); if( dataCount < 1)
{
return 0;
} //分配是否才查找过的标识
char* = new char[dataCount];
if(NULL == )
{
printf("Alloc new memory error.");
return -1;
}
memset(, 0, dataCount); for(int i = start; i < dataCount; i++)
{
if([i] == (char)0)
{
sumC = 0; sumD = 0;
procSum( i, dataCount, , datas[i].A, datas[i].B, sumC, sumD); printf("A: %d, B: %d, sumC: %d, sumD: %d. ", datas[i].A, datas[i].B, sumC, sumD);
if(sumC != sumD)
{
printf("Result: error.\n");
}
else
{
printf("Result: Success.\n");
}
}
} return 0;
}

先看看他的需求，他的意思是先根据A，B值归类，再判断整个类中数据是否符合规定，true或false反应的就是整体，而不是单个

调试易

项目中有个算法写不出来了，求助各位大虾们

解决方案 »