Question

我有两个列表，其中匹配索引的列表之间的项目已链接。第一个列表提供与第二个列表值相关的键：

List<Double> a1 = [10,20,20,30,10];           // keys
List<Double> y1 = [2012,2013,2012,2012,2013]; // values

我想从密钥（索引）列表中删除重复项，以便在找到重复项时添加密钥的值。因此，例如，如果找到值为10的两个键，我想用一个值为20的单个键替换两个键。将重复此过程，直到没有重复键为止。所以我希望列表的输出如下：

List<Double> a1 = [60,30];
List<Double> y1 = [2012,2013];

我尝试使用以下代码解决此问题，但输出不正确。

y2=new ArrayList<Double>();
a2 = new ArrayList<Double>();
String y = "";
double a = 0;

for (int i = 0; i < y1.size(); i++) {

    if (y1.get(i).equals(y)) {
        a = a + y1.get(i);
    } else {
        if (!y.equals("")) {
            y2.add(y);
            a2.add(a);
        }

        y = y1.get(i);
        a = a1.get(i);
    }
}

y2.add(y);
a2.add(a);

感谢任何帮助，谢谢。

Answer 1

使用Map

Map<Double, Double> map = new HashMap<>();
for (int i = 0; i < y1.size(); i++) {
    double oldValue = map.containsKey(y1.get(i)) ? map.get(y1.get(i)) : 0.0;

    map.put(y1.get(i), oldValue + a1.get(i));
}

y1.clear();
a1.clear();

for (Entry<Double, Double> entry : map.entrySet()) {
    y1.add(entry.getKey());
    a1.add(entry.getValue());
}

Answer 2

private void method(List<Double> y1, List<Double> a1) {
    for (int i = 0; i < y1.size(); i++) {
        if (y1.get(i) != -1) {
        for (int j = i + 1; j < y1.size(); j++) {
            if (y1.get(i).equals(y1.get(j))) {
            y1.set(j, -1d);
            a1.set(i, a1.get(i) + a1.get(j));
            a1.set(j, -1d);
            }
        }
        }
    }
    for (Iterator<Double> itr = y1.iterator(); itr.hasNext();)
        if (itr.next().equals(-1d))
        itr.remove();
    for (Iterator<Double> itr = a1.iterator(); itr.hasNext();)
        if (itr.next().equals(-1d))
        itr.remove();
    }

Answer 3

您的代码失败，因为未订购y1数组。如果要保留y1和a1之间的映射，则应创建一个具有此值的类，并创建此类的数组：

public class Elem implements Comparable<Elem> 
{
    double year;
    double value;

// getters and setters 

public double getValue() {
    return value;
}

public void setValue(double value) {
    this.value = value;
}


public int compareTo(Elem item) 
    {
        if (this.getYear() == item.getYear())
        return 0;
    else if (this.getYear() > item.getYear())
        return 1;
    else 
        return -1;
}

public int hashCode()
{
    StringBuffer buffer = new StringBuffer();
    buffer.append(this.year);
    buffer.append(this.value);
    return buffer.toString().hashCode();
}

public boolean equals(Object item)
{
    if (item instanceof Elem)
    {
        Elem e = (Elem) item;
        if (e.getYear() == this.getYear())
        {
            return true;
        }
        return false;
    }
    return false;
}
}

现在你可以对阵列进行打包，捣乱并对其进行排序：

    List<Elem> y1 = new ArrayList<Elem>();

    //---- populate array ----

    Collections.sort(y1);

    ArrayList<Elem> y2;

    y2 = new ArrayList<Elem>();
    Elem y = null;

    double a = 0;

    for(int i = 0;i<y1.size();i++){
        if((y != null) && (y1.get(i).equals(y))){
            a = y.getValue() + y1.get(i).getValue();
            y1.get(i).setValue(a);
            y = y1.get(i);
        }
        else{
            if(y != null) {
                y2.add(y);
            }

            y = y1.get(i);
        }


    }
    if(y != null) {
        y2.add(y);
    }

递归地聚合键控列表对中的重复项

3 个答案: