java的循环取值判断下一层的逻辑问题

昨天做安卓开发的时候，在进入一个界面初始化的时候。由于上一次提交了数据，在这次get的时候 会有一些不全的数据出来会有一些不好看而且影响后面的数据正确性和有效性。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class Test {

static List<Map<String, Object>> list = new ArrayList<>();

public static void main(String[] args) {
listValue();
deduplication(list);
}

public static void deduplication(List<Map<String, Object>> list) {
/*最后得到的数据*/
Map<String, Map<String, Object>> dataMap = new HashMap<>();
/*存放比较dataMap中的Key(不会出现后续已经添加的对象的key)*/
List<String> keys;
System.out.println("========================请求得到的数据");
boolean flag = true; // 第一次进入是将list中的第一个放入dataMap中
for (Map<String, Object> map : list) {
if(map.isEmpty()){
// 当list中map出现空时跳过
continue;
}
keys = new ArrayList<>();
for (Entry<String, Map<String, Object>> entry : dataMap.entrySet()) {
keys.add(entry.getKey());
}
String key = map.get("b") + "+" + map.get("a"); // 存放dataMap中的key，防止出现重复，以特殊符号拼接
if (flag) {
dataMap.put(key, map); // 第一次将list中第一个map放入dataMap，此时dataMap存在一个唯一的对象
flag = false;
} else {
if(dataMap.size() > 0){ // 当dataMap的大小大于0时进行循环
for (String keyM : keys) { // 循环keys  上一次dataMap中存在的key，因为循环可能添加值进入dataMap中，不能直接循环dataMap
// 当循环的list中的map的key[a]和key[b]值与dataMap中的map的key[a]和key[b]值相同时
if (dataMap.get(keyM).get("a").equals(map.get("a")) && dataMap.get(keyM).get("b").equals(map.get("b"))) {
double tempC = (double) map.get("c");
// 判断key[c]的值的大小，取得较大对象，重新对dataMap的值进行覆盖，实现获取最大值
if (tempC >= Double.parseDouble(dataMap.get(keyM).get("c").toString())) {
dataMap.put(key, map);
}
} else {
dataMap.put(key, map);
}
}
}

}
System.out.println(map);
}
System.out.println("========================最后结果");
for (String key : dataMap.keySet()) {
System.out.println(dataMap.get(key));
}

}

public static void listValue() {
Map<String, Object> map1 = new HashMap<>();
map1.put("a", "a");
map1.put("b", "b");
map1.put("c", 2.0);

Map<String, Object> map2 = new HashMap<>();
map2.put("a", "a2");
map2.put("b", "b2");
map2.put("c", 10.0);

Map<String, Object> map3 = new HashMap<>();
map3.put("a", "a");
map3.put("b", "b");
map3.put("c", 1.5);

Map<String, Object> map4 = new HashMap<>();
map4.put("a", "a");
map4.put("b", "b");
map4.put("c", 211.0);

Map<String, Object> map5 = new HashMap<>();
map5.put("a", "a5");
map5.put("b", "b5");
map5.put("c", 2.5);

Map<String, Object> map6 = new HashMap<>();
map6.put("a", "a6");
map6.put("b", "b6");
map6.put("c", 2.5);

Map<String, Object> map7 = new HashMap<>();
map7.put("a", "a6");
map7.put("b", "b6");
map7.put("c", 2.9);

list.add(map1);
list.add(map2);
list.add(map3);
list.add(map4);
list.add(map5);
list.add(map6);
list.add(map7);

}

}

这个是一段例子解决的问题 把a=a ,b=b 然后这2个相等了 在去判断c的大小。刚刚开始的时候我知道这个思想如何做。但是那会下午4点中 中午有没吃饭，就卡壳了，晚上回去之后花了点时间优化 了下变成了这个样子。下面上我实际开发的代码：

/**
*
* @Title: initview
* @Description: 用于初始化之后设置界面上的字段
* @param 设定文件
* @return void 返回类型
* @throws
*/
public void initview() {
List<pack_operations> pack_operatios3 = new ArrayList<pack_operations>();
/*存放比较pack_operatios5中的Key(不会出现后续已经添加的对象的key)*/
//List<pack_operations> pack_operatios5 =new ArrayList<pack_operations>();
Map<String, pack_operations> pack_operatios5 = new HashMap<String, pack_operations>();
List<String> keys;
pack_operations[]    pack_operatios4;

for (int i = 0; i < incomingdate.getData().getTask().length; i++) {
String idss = incomingdate.getData().getTask()[i].getId()
.toString();// 获取当前的id
if (ids.equals(idss)) {
taskname.setText(incomingdate.getData().getTask()[i].getId().toString());
Targettary.setText(incomingdate.getData().getTask()[i].getName().toString());
pack_operatios4=incomingdate.getData().getTask()[i].getPack_operations();
for (int j = 0; j < pack_operatios4.length; j++) {
pack_operatios3.add(pack_operatios4[j]);
}
boolean flag = true;
for (pack_operations s1 : pack_operatios3) {
//第一次循环
if(s1==null||s1.equals("")){
// 当list中map出现空时跳过
continue;
}
keys = new ArrayList<String>();

for (Entry<String, pack_operations> entry : pack_operatios5.entrySet() ) {
keys.add(entry.getKey());
}
String key=s1.getEan13();//获取到en13
if (flag) {
pack_operatios5.put(key,  s1);
flag = false;
}else {
if (pack_operatios5.size()>0) {// 当dataMap的大小大于0时进行循环
int  c=0;
for (String keyM : keys) {// 循环keys  上一次dataMap中存在的key，因为循环可能添加值进入dataMap中，不能直接循环dataMap				if (pack_operatios5.get(keyM).getEan13().equals(s1.getEan13())) {
// 判断key[c]的值的大小，取得较大对象，重新对dataMap的值进行覆盖，实现获取最大值
double tempC = Double.parseDouble( s1.getProduct_qty().toString());
if (tempC <= Double.parseDouble(pack_operatios5.get(keyM).getProduct_qty().toString())) {
pack_operatios5.put(key,  pack_operatios5.get(keyM));
c=1;
}
}

}
if (c==0) {
pack_operatios5.put(key,   s1);
}
}
}
}
System.out.println("========================最后结果");
for (String key : pack_operatios5.keySet()) {
System.out.println(pack_operatios5.get(key));
}
List<pack_operations> list = new ArrayList(pack_operatios5.values());
pack_operations[] arr = (pack_operations[])list.toArray(new pack_operations[list.size()]);
incomingdate.getData().getTask()[i].setPack_operations(arr);
for (int k = 0; k < incomingdate.getData().getTask()[i].getPack_operations().length; k++) {
HashMap<String, Object> map1 = new HashMap<String, Object>();
String sff;
if (incomingdate.getData().getTask()[i].getPack_operations()[k].getProduct_qty()!=null||incomingdate.getData().getTask()[i].getPack_operations()[k].getProduct_qty().equals("")) {
sff=incomingdate.getData().getTask()[i].getPack_operations()[k].getProduct_qty().toString();
Double d2 = Double.parseDouble(sff);
}else {
sff="0";
}
Double d2 = Double.parseDouble(sff);
map1.put("bestincomingtextname",incomingdate.getData().getTask()[i].getPack_operations()[k].getEan13() );
System.out.println(incomingdate.getData().getTask()[i].getPack_operations()[k].getEan13() );
map1.put("bestincomingnumber",(new Double(d2)).intValue() );
map1.put("bestincomingtegert",incomingdate.getData().getTask()[i].getPack_operations()[k].getLocation_dest_id()[1]);
map1.put("bestincomingStocknumber","0");
mListItem.add(map1);
System.out.println(mListItem);
}
}
}
}

如果有问题可以发邮件给我：haiabi@163.com