Comparer NSArray avec NSMutableArray en ajoutant des objets delta à NSMutableArray

Question

J'ai un NSMutableArray qui est rempli avec des objets de chaînes. Par souci de simplicité, nous dirons que les objets sont une personne et que chaque objet personne contient des informations sur cette personne.

Ainsi j'aurais un NSMutableArray qui est peuplé d'objets personne:

person.firstName 
person.lastName 
person.age 
person.height 

Et ainsi de suite.

La source initiale de données provient d'un serveur Web et est remplie lorsque mon application charge et termine son initialisation avec le serveur. Périodiquement mon application interroge le serveur pour la dernière liste de noms.

Actuellement je crée un NSArray du jeu de résultats, vider le NSMutableArray puis repeupler la NSMutableArray avec NSArray résultats avant de détruire l'objet NSArray.

Cela me semble inefficace sur quelques niveaux et me pose également un problème en perdant des références de lignes de table que je peux contourner, mais je pourrais créer plus de travail pour moi-même. L'inefficacité semble être que je devrais être en mesure de comparer les deux tableaux et se retrouver avec un NSArray filtré. Je pourrais alors ajouter l'ensemble filtré au NSMutableArray. Cela signifierait que je peux simplement ajouter de nouvelles données au NSMutableArray au lieu de tout jeter et de re-peupler. Inversement, j'aurais besoin de faire le même filtre à l'envers pour voir s'il y a des enregistrements qui ont besoin d'être retirés du NSMutableArray.

Existe-t-il une méthode pour le faire de manière plus efficace? Ai-je négligé quelque chose dans les docs quelque part qui se réfère à une technique plus simple?

J'ai un problème lorsque je vide le NSMutableArray et que je répète que toutes les tables de référence perdent leur état de ligne sélectionné. Je peux le suivre et le resélectionner, mais ma théorie est que l'utilisation d'une certaine forme de comparaison et d'ajout d'objets et de suppression d'objets au lieu de traiter tout le tableau dans un bloc peut signifier que je conserve ma référence de ligne (en supposant que supprimé bien sûr).

Toute suggestion ou aide très appréciée.

Mise à jour

Serait-il aussi vite faire une énumération rapide sur chaque comparant chaque élément de ligne que je vais? Il semble comme une opération coûteuse, mais avec le dernier code d'énumération rapide, il peut être assez efficace ...

Solution

J'ai fini par aller avec la suggestion de Abizem. Créer la copie mutable du tableau et une copie de l'objet semble être l'approche légèrement plus rapide que l'utilisation de la solution de booth lorsqu'il s'agit de grands ensembles de données. Les deux ont bien fonctionné, j'ai juste eu plus d'avantage en utilisant l'approche de la copie mutable. Cela étant dit, cela a ouvert mes yeux à NSSet où je n'avais pas regardé auparavant.

Merci pour vos commentaires.

Answer 1

Deux points.

1. Le nouveau NSArray contient toutes les données que vous devez afficher. C'est pourquoi vous ajoutez et supprimez du NSMutableArray pour faire correspondre le nouveau.
2. Vous ne voulez pas perdre l'état sélectionné des lignes dans votre table.

Here're mes suggestions

1. Plutôt que de vider le NSMutableArray et repeupler avec le nouveau réseau; pourquoi ne pas créer un mutableCopy de NSArray et définir cela comme votre nouveau NSMutableArray? Plutôt que de s'inquiéter de l'ordre des articles (et donc du numéro de ligne sélectionné); que diriez-vous de créer une copie de l'objet sélectionné et après avoir créé votre NSMutableArray comme à l'étape 1, trouvez l'objet correspondant dans le nouveau tableau et définissez-le comme la ligne sélectionnée dans la table en utilisant son nouvel index.

Answer 2

Vous pouvez utiliser NSSet pour faire ce genre de chose facilement (en supposant que vos objets personne sont uniques):

NSSet *existingItems = [NSSet setWithArray:existingItemArray]; 
NSSet *newItems = /* Get the new items from the server */ 

// Determine which items were removed 
NSMutableSet *removedItems = [NSMutableSet setWithSet:existingItems]; 
[removedItems minusSet:newItems]; 

// Determine which items were added 
NSMutableSet *addedItems = [NSMutableSet setWithSet:newItems]; 
[addedItems minusSet:existingItems]; 

// Modify the original array 
[existingItemArray removeObjectsInArray:[removedItems allObjects]]; 
[existingItemArray addObjectsFromArray:[addedItems allObjects]]; 

Je serais surpris si les performances ne sont pas décents, comme je suis sûr de la la mise en œuvre est optimisée.