algorithme efficace pour mettre à jour une gamme de propriétés d'objets

Question

(je ne suis pas sûr de savoir comment résumer cette question dans le titre)

J'ai un nombre aléatoire d'objets de classe A avec deux propriétés, y compris Couleur. Je reçois ensuite un nombre aléatoire d'objets de classe B, qui ont tous la propriété de couleur. J'ai besoin de mettre à jour ma gamme d'objets de classe A pour correspondre à la fois aux propriétés de couleur des objets de classe B et au nombre d'objets de classe B. Les objets de classe A peuvent être supprimés, créés ou modifiés. Notamment, il peut ne jamais exister deux objets de classe A avec la même couleur. La méthode la plus simple consiste à supprimer tous les objets de classe A puis à en créer de nouveaux (le même nombre d'objets de classe B) et à définir la propriété color de chaque objet nouvellement créé pour qu'il corresponde à la propriété color. Cependant, en termes de performances, il est très avantageux de modifier la propriété color d'un objet de classe A pour qu'il corresponde à la propriété color d'un objet de classe B, plutôt que de supprimer un objet de classe A et d'en créer un nouveau.

Les objets de classe A sont initialement contenus dans une carte. Les objets de classe B arrivent dans un vecteur.

Je me demande si quelqu'un reconnaît le problème et connaît un certain type de motif élégant?

Answer 1

Code non testé mais devrait fonctionner. Ir démontre certainement l'algorithme (pas de motif).

public void test() { 
    // Start data. 
    Map<String, A> asInAMap = new HashMap<>(); 
    // The B's arrive. 
    List<B> arrivingBs = new ArrayList<>(); 
    // Grab the A's and key them on colour. 
    Map<Colour, A> asInColour = new HashMap<>(); 
    // Keep track of all As. 
    Set<A> availableAs = new HashSet<>(asInAMap.values()); 
    // Roll them into the Map. 
    for (A a : availableAs) { 
     // Key all A's by colour. 
     asInColour.put(a.colour, a); 
    } 
    // Walk the Bs, matching up the A's 
    Set<A> matchedAs = new HashSet<>(); 
    Set<B> unMatchedBs = new HashSet<>(); 
    for (B b : arrivingBs) { 
     // Is there a matching A with the right colour? 
     A aMatched = asInColour.get(b.colour); 
     if (aMatched != null) { 
      // Keep track of the ones that matched. 
      matchedAs.add(aMatched); 
     } else { 
      // Keep track of all not-matched Bs. 
      unMatchedBs.add(b); 
     } 
    } 
    // Don't touch any of the matched ones. 
    availableAs.removeAll(matchedAs); 
    // Change colours of any A.s left. 
    Iterator<B> bsWithNewColours = unMatchedBs.iterator(); 
    for (A changeAColour : availableAs) { 
     if (bsWithNewColours.hasNext()) { 
      B newB = bsWithNewColours.next(); 
      // Change a spare A's colour. 
      changeAColour.colour = newB.colour; 
      // Finished with that one. 
      bsWithNewColours.remove(); 
     } 
    } 
    // All that are left in notMatched must generate new A's. 
    for (B newColour : unMatchedBs) { 
     // Make a new A with a non-matched colour. 
     asInAMap.put(String.valueOf(newColour.colour), new A(newColour.colour)); 
    } 
} 

essentiellement:

1. Faites une liste de tous les A.
2. Index tout Comme par couleur.
3. Pour chaque B, si un A existe avec la même couleur, marquez-le comme un gardien. Si ce n'est pas le cas, marquez-le pour une attention future. Pour tous les A restants qui ne correspondent pas, changez sa couleur pour la couleur de l'un des B marqués et désélectionnez le B.
4. Pour tous les B marqués restants, il n'y avait pas de A correspondant à sa couleur et tous les A disponibles sont épuisés alors faites de nouveaux A pour eux.