Itérer et calculer des nombres dans une carte

Question

J'ai une carte de listes avec la clé = GROUP et la valeur = Liste les numéros stockés en tant que chaînes. Un élément est inférieur

GROUP1/[3.0, 4.0, 2.0, 3.0, 3.0, 2.0, 2.0, 2.0, 2.0, -2.0, -2.0, -2.0, 2.0] 

Ce que je dois faire est d'annuler (retirez) tous les nombres négatifs contre les points positifs, mais réduire le nombre + ve par cette valeur.

Dans l'exemple ci-dessus, 3 annulera contre -2 au large (premier -ve) laissant 1 que le total

par intérim puis +1 (total de la précédente) annule de -2 (à côté -ve) laissant -1 comme étant le total provisoire

-1 a carré contre 4 (côté + ve dans la liste), laissant 3 que le total

provisoire Ensuite, 3 carrés hors contre -2 (à côté -ve) laissant un total de 1.

Ainsi, tous les -ve sont éliminés de la liste, tout comme 3.0, 4.0 mais le premier élément est maintenant 1,0 (1,0 étant le dernier intermédiaire au total)

Séquence finale étant

[1.0, 2.0, 3.0, 3.0, 2.0, 2.0, 2.0, 2.0, 2.0] 

Le code que je suis jusqu'à présent que totalise la liste ci-dessous.

Map<String, List<String>> m = new HashMap<String, List<String>>(); 

...

for (Entry<String, List<String>> entry : m.entrySet()) 
{ 
    System.out.println(entry.getKey() + "/" + entry.getValue()); 
    double calc = 0; 
    for (String element:entry.getValue()){ 
     //System.out.println(element); 
     calc = calc + new Double(element).doubleValue(); 

    } 
    //if (calc > 0.0) 
     System.out.println("Total for Item: " + entry.getKey() + " is "+calc); 
} 

Total pour objet: GROUPE1 est 19,0

Je sais que nous ne devrions pas supprimer des éléments de la liste que nous parcourons, si la question est

A) Logique idéale pour supprimer les numéros dans la séquence ci-dessus. B) Dois-je créer une nouvelle liste et y ajouter des éléments pendant que je répète? C) Dois-je changer la collection que je stocke de la carte des listes à une structure de classe?

Answer 1

Je pense que la solution la plus simple consiste à parcourir deux fois la liste, à extraire les nombres négatifs lors des premières itérations, puis à ajuster les nombres restants sur la deuxième itération. S'il n'est pas nécessaire de conserver l'état original de la carte, je ferais tout en place, bien que je ne sache pas pourquoi vous pensez que vous modifiez la carte pendant que vous itérez, car il n'y a rien dans votre code (à moins que est une faute de frappe et vous vouliez dire la liste). En ce qui concerne le type de collection, je pense que la question principale est de savoir quel type de performance avez-vous besoin pour les différentes opérations, par rapport à la taille/type de données. Voici une implémentation de l'algorithme que j'ai décrit ci-dessus. Comme cela peut potentiellement faire beaucoup de suppressions (en fonction de vos données), il peut être préférable que les listes soient LinkedLists puisqu'elles peuvent être supprimées en temps constant. Bien sûr, vous pouvez toujours faire ces calculs avec LinkedLists et ensuite faire une copie des données comme un autre type tel que ArrayList si vous avez besoin de meilleures performances pour l'accès indexé.

Comme je l'ai déjà dit, voici une implémentation utilisant une approche en deux passes.Remarque Je ne suis pas supprimer les valeurs zéro, et à la fin, il insère une seule valeur négative si le total est négatif (pas sûr de votre requriements sont dans ce cas):

for (Entry<String, List<String>> entry : m.entrySet()){ 
    System.out.println(entry.getKey() + "/" + entry.getValue()); 
    double calc=0,acc = 0, item; 
    //First look for negative values 
    for (Iterator<String> it=entry.getValue().iterator();it.hasNext();){ 
    item = Double.parseDouble(it.next()); 
    calc += item; 
    if(item < 0){ 
     //accumulate them, and remove them from the list 
     acc += item; 
     it.remove(); 
    } 
    } 
    if(calc > 0){ 
    //now adjust the remaining positive numbers 
    for (Iterator<String> it=entry.getValue().iterator();it.hasNext();){ 
     item = Double.parseDouble(it.next()); 
     //remove the number as we adjust it if it 
     //is the last positive it will be reinserted 
     //when the loop breaks 
     it.remove(); 
     if((acc+=item) >= 0){ 
     //the accumulated numbers are now positive 
     break; 
     } 
    } 
    //re-insert the adjusted positive back into the list 
    entry.getValue().add(0, Double.toString(acc)); 
    }else{ 
    //the total sum was negative or zero 
    entry.getValue().clear(); 
    entry.getValue().add(Double.toString(calc)); 
    } 
    System.out.println("Total for Item: " + entry.getKey() + " is "+calc); 
    System.out.println("List is now: "+entry.getValue()); 
}