Meilleure façon de supprimer à partir de NSMutableArray lors de l'itération?

Dans le Cacao, si je veux faire une boucle par un NSMutableArray et supprimer plusieurs objets qui correspondent à certains critères, quelle est la meilleure façon de le faire sans avoir à redémarrer la boucle à chaque fois que j'ai supprimer un objet?

Merci,

Edit: Juste pour préciser - je cherchais le meilleur moyen, par exemple, quelque chose de plus élégant que manuellement la mise à jour de l'index, je suis à la. Par exemple en C++ je peux le faire;

iterator it = someList.begin();

while (it != someList.end())
{
    if (shouldRemove(it))   
        it = someList.erase(it);
}

Boucle à partir de l'arrière vers l'avant.
Pas de réponse au "POURQUOI"
L'un de mes tous les temps favoris et les plus sous-estimés de la solution dans la programmation en général 😀

InformationsquelleAutor Andrew Grant | 2008-09-21

cocoa objective-c

383

Pour plus de clarté, je tiens à faire une première boucle où je rassemble les éléments à supprimer. Puis-je les supprimer. Voici un exemple de l'aide Objective-C 2.0 syntaxe:
```
NSMutableArray *discardedItems = [NSMutableArray array];

for (SomeObjectClass *item in originalArrayOfItems) {
    if ([item shouldBeDiscarded])
        [discardedItems addObject:item];
}

[originalArrayOfItems removeObjectsInArray:discardedItems];
```
Alors il n'est pas question de savoir si les indices sont mis à jour correctement, ou autres peu de tenue de la comptabilité de détails.

Modifiées afin d'ajouter:

Il a été noté dans d'autres réponses que la formulation inverse devrait être plus rapide. c'est à dire Si vous parcourir le tableau et la composition d'un tableau d'objets à garder, au lieu de les objets à jeter. C'est peut-être vrai (bien que ce sujet de la mémoire et du coût de traitement d'allouer un nouveau tableau, et le rejet de l'ancien?) mais même si c'est plus rapide, il peut ne pas être aussi important que ce serait pour une implémentation naïve, parce que NSArrays ne se comportent pas comme des tableaux "normaux". Ils parlent l'entretien, mais ils marchent sur un autre pied. Voir une bonne analyse ici:

La formulation inverse peut être plus rapide, mais je n'ai jamais eu besoin de se préoccuper de savoir si c'est parce que l'énoncé ci-dessus a toujours été assez rapide pour mes besoins.

Pour moi le message est à utiliser quelle que soit la formulation est plus claire pour vous. Optimiser uniquement si nécessaire. Personnellement, je trouve la formule la plus claire, c'est pourquoi je l'utilise. Mais si la formulation inverse est plus clair pour vous, d'aller pour elle.
- Méfiez-vous que cela pourrait créer des bugs si les objets sont plus d'une fois dans un tableau. Comme alternative, vous pouvez utiliser un NSMutableIndexSet et -(void)removeObjectsAtIndexes.
- Vous lié à ridiculousfish.com. Vous doit être à droite.
- Il est effectivement plus rapide de faire l'inverse. La différence de performances est assez énorme, mais si votre tableau n'est pas si grande, puis les heures vont être trivial de toute façon.
- J'ai utilisé revers... au tableau en tant que néant.. alors seulement ajouté ce que je voulais et récupérer les données... fait... créé dummyArray qui est le miroir du tableau principal, de sorte que nous avons principales données
- Excellent! Cela a parfaitement fonctionné!
- La mémoire supplémentaire doit être alloué à faire inverse. Ce n'est pas un algorithme sur place et pas une bonne idée dans certains cas. Lorsque vous supprimez directement que vous venez de déplacer le tableau (qui est très efficace car il ne bougera pas, un par un, il peut se déplacer un gros morceau), mais lorsque vous créez un nouveau tableau vous avez besoin de tous les allouer et de l'affectation. Donc, si vous ne supprimez quelques éléments, l'inverse sera beaucoup plus lente. C'est un typique semble-algorithme de droite.
InformationsquelleAutor Christopher Ashworth
82

Une variation. Ainsi, vous obtenez la lisibilité et de la bonne performance:
```
NSMutableIndexSet *discardedItems = [NSMutableIndexSet indexSet];
SomeObjectClass *item;
NSUInteger index = 0;

for (item in originalArrayOfItems) {
    if ([item shouldBeDiscarded])
        [discardedItems addIndex:index];
    index++;
}

[originalArrayOfItems removeObjectsAtIndexes:discardedItems];
```
- C'est génial. J'ai essayé de supprimer plusieurs éléments de la matrice et cela a fonctionné parfaitement. D'autres méthodes ont été à l'origine des problèmes 🙂 Merci man
- Corey, cette réponse (ci-dessous) dit que, removeObjectsAtIndexes est la pire méthode pour supprimer les objets, êtes-vous d'accord avec ça? Je demande cela parce que votre réponse est trop vieux maintenant. Néanmoins, il sera bon de choisir le meilleur?
- J'aime cette solution en termes de lisibilité. Comment est-il en termes de performances, comparativement à @HotLicks réponse?
- Cette méthode doit être certainement encouragé lors de la suppression d'objets de la matrice en Obj-C.
- enumerateObjectsUsingBlock: vous obtenir l'indice d'échelon gratuit.
InformationsquelleAutor Corey Floyd
41

C'est très simple problème. Vous venez d'effectuer une itération à l'envers:
```
for (NSInteger i = array.count - 1; i >= 0; i--) {
   ElementType* element = array[i];
   if ([element shouldBeRemoved]) {
       [array removeObjectAtIndex:i];
   }
}
```
C'est un schéma très commun.
- aurait manqué Jens réponse, parce qu'il n'a pas d'écrire le code :P.. thnx m8
- C'est la meilleure méthode. Important de se rappeler que la variable d'itération doit être signé, malgré que les indices de tableau en Objective-C sont déclarées comme non signé (je ne peux imaginer comment Apple regrette que maintenant).
InformationsquelleAutor Hot Licks
39

Certains des autres réponses auraient de mauvaises performances sur des tableaux de très grande taille, parce que les méthodes comme removeObject: et removeObjectsInArray: impliquent de faire une recherche linéaire du récepteur, qui est une perte de temps parce que vous le savez déjà où se trouve l'objet. Aussi, tout appel à removeObjectAtIndex: devrez copier les valeurs de l'index à la fin du tableau par une fente à la fois.

Plus efficace serait la suivante:
```
NSMutableArray *array = ...
NSMutableArray *itemsToKeep = [NSMutableArray arrayWithCapacity:[array count]];
for (id object in array) {
    if (! shouldRemove(object)) {
        [itemsToKeep addObject:object];
    }
}
[array setArray:itemsToKeep];
```
Parce que nous avons fixé la capacité de itemsToKeep, nous ne perdez pas de temps à copier les valeurs lors d'un redimensionnement. Nous n'avons pas modifier le tableau en place, de sorte que nous sommes libres d'utiliser Rapide Énumération. À l'aide de setArray: pour remplacer le contenu de array avec itemsToKeep sera efficace. En fonction de votre code, vous pouvez même remplacer la dernière ligne avec:
```
[array release];
array = [itemsToKeep retain];
```
Donc il n'y a même pas besoin de copier les valeurs, permuter uniquement un pointeur.
- Cette algo prouve bien être en termes de temps de la complexité. Je suis en train d'essayer de le comprendre en termes d'espace que de la complexité. J'ai le même de la mise en œuvre va partout où j'ai mis la capacité de 'itemsToKeep" avec le Tableau de compter". Mais disons que je ne veux pas quelques objets de tableau donc je n'ai pas l'ajouter à itemsToKeep. Afin que la capacité de mon itemsToKeep est de 10, mais j'ai vraiment magasin seulement 6 objets à l'intérieur. Est-ce à dire que je suis perdre de l'espace de 4 objets? P. S. ne suis pas la recherche de défauts, juste essayer de comprendre la complexité de l'algo. 🙂
- Oui, vous avez de l'espace réservé pour quatre pointeurs que vous ne l'utilisez pas. Gardez à l'esprit le tableau ne contient que des pointeurs, et non les objets eux-mêmes, donc, pour les quatre objets qui signifie que 16 octets (32 bits de l'architecture) ou 32 octets (64 bits).
- Noter que les solutions sont au meilleur exiger 0 de l'espace supplémentaire (suppression d'éléments de la place) ou, au pire, le double de l'original de la taille de la matrice (parce que vous faites une copie du tableau). De nouveau, parce que nous avons affaire avec des pointeurs et pas des copies complètes des objets, ce qui est assez bon marché dans la plupart des circonstances.
- D'accord obtenu. Grâce Benzado!!
- Selon ceci post, l'indice de la arrayWithCapacity: méthode sur la taille du tableau n'est pas en cours d'utilisation.
- Sur la route, de la peinture jaune est impuissante à arrêter le trafic venant en sens inverse à partir de l'entrée de votre lane. Mais nous l'utilisons tous les mêmes.
- Je ne suis pas déconseillent l'utilisation de arrayWithCapacity: il est en effet utile pour comprendre le code 🙂 . Ce que je veux dire, c'est que d'après ce que je comprends, à l'aide, il ne semble pas pour éviter de gaspiller de temps à copier les valeurs lors d'un redimensionnement comme vous l'avez suggéré.
- Ce n'est pas une bonne solution. Allouer de la mémoire supplémentaire et ne affectation sont beaucoup plus lent que de la supprimer et changement de tableau.
InformationsquelleAutor benzado
28

Vous pouvez utiliser NSpredicate pour supprimer des éléments de votre mutable tableau. Ceci nécessite pas de boucles.

Par exemple, si vous avez un NSMutableArray de noms, vous pouvez créer un prédicat comme celui-ci:
```
NSPredicate *caseInsensitiveBNames = 
[NSPredicate predicateWithFormat:@"SELF beginswith[c] 'b'"];
```
La ligne suivante va vous laisser avec un tableau qui contient uniquement les noms commençant par b.
```
[namesArray filterUsingPredicate:caseInsensitiveBNames];
```
Si vous avez de la difficulté à créer les prédicats dont vous avez besoin, utilisez ce apple developer lien.
- Nécessite pas de visible pour les boucles. Il y a une boucle dans le filtre de l'opération, vous n'avez tout simplement pas le voir.
InformationsquelleAutor
18

J'ai fait un test de performance à l'aide de 4 méthodes différentes. Chaque test itérer sur tous les éléments de 100.000 élément de tableau, et enlevé toutes les 5ème élément. Les résultats ne varient pas beaucoup avec/sans optimisation. Ceci a été fait sur un iPad 4:

(1) removeObjectAtIndex: -- 271 ms

(2) removeObjectsAtIndexes: -- 1010 ms (parce que la construction de l'indice d'ensemble prend ~700 ms; sinon, c'est essentiellement le même que l'appel à la removeObjectAtIndex: pour chaque élément)

(3) removeObjects: -- 326 ms

(4) faire un tableau avec des objets, en passant le test -- 17 ms

Donc, création d'un nouveau tableau est de loin le plus rapide. Les autres méthodes sont toutes comparables, sauf que l'utilisation removeObjectsAtIndexes: ce sera pire avec plus d'éléments à supprimer, en raison du temps nécessaire à la construction de l'indice d'ensemble.
- Avez-vous compter le temps de faire un nouveau tableau et de libérer par la suite. Je ne crois pas qu'il peut le faire seul dans ms 17. Plus de 75 000 affectation?
- Le temps nécessaire pour créer et libérer un nouveau tableau est minime
- Vous n'a apparemment pas à la mesure de la boucle de retournement régime.
- Le premier test est équivalent à l'inverse de la boucle de régime.
- ce qui se passe quand vous êtes de gauche avec votre newArray, et votre prevArray est entaché de nullité? Vous devez copier le newArray à ce que le PrevArray a été nommé ( ou renommer ) sinon, comment serait votre code de référence-il?
InformationsquelleAutor user1032657
17

Soit utiliser la boucle de comptage vers le bas sur les indices:
```
for (NSInteger i = array.count - 1; i >= 0; --i) {
```
ou de faire une copie avec les objets que vous souhaitez garder.

En particulier, ne pas utiliser de for (id object in array) boucle ou NSEnumerator.
- vous devez écrire votre réponse dans le code m8. haha presque manqué.
- Ce n'est pas juste. "pour(id de l'objet dans le tableau)" est plus rapide que "pour (NSInteger i = array.count - 1; i >= 0; --i)", et est appelé fast itération. À l'aide d'itérateur est nettement plus rapide que l'indexation.
- Mais si vous supprimez un élément de la vertu d'un itérateur vous avez l'habitude de créer des ravages. (Et rapide "itération" n'est pas toujours beaucoup plus rapide.)
- La réponse est à partir de 2008. Rapide itération n'existe pas.
InformationsquelleAutor Jens Ayton

Pour iOS 4+ ou OS X 10.6+, Apple a ajouté passingTest série d'Api dans NSMutableArray, comme – indexesOfObjectsPassingTest:. Une solution avec ces API serait:

NSIndexSet *indexesToBeRemoved = [someList indexesOfObjectsPassingTest:
    ^BOOL(id obj, NSUInteger idx, BOOL *stop) {
    return [self shouldRemove:obj];
}];
[someList removeObjectsAtIndexes:indexesToBeRemoved];

InformationsquelleAutor zavié

12

Aujourd'hui, vous pouvez utiliser inversé basé sur des blocs de l'énumération. Un exemple simple de code:
```
NSMutableArray *array = [@[@{@"name": @"a", @"shouldDelete": @(YES)},
                           @{@"name": @"b", @"shouldDelete": @(NO)},
                           @{@"name": @"c", @"shouldDelete": @(YES)},
                           @{@"name": @"d", @"shouldDelete": @(NO)}] mutableCopy];

[array enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    if([obj[@"shouldDelete"] boolValue])
        [array removeObjectAtIndex:idx];
}];
```
Résultat:
```
(
    {
        name = b;
        shouldDelete = 0;
    },
    {
        name = d;
        shouldDelete = 0;
    }
)
```
une autre option avec juste une ligne de code:
```
[array filterUsingPredicate:[NSPredicate predicateWithFormat:@"shouldDelete == NO"]];
```
- Est-il une garantie que le tableau ne serait pas réaffecté?
- Que voulez-vous dire avec une redistribution?
- Lors de la suppression de l'élément de structure linéaire, il peut être efficace d'allouer un nouveau bloc de mémoire contiguë et déplacer tous les éléments. Dans ce cas, tous les pointeurs serait invalidé.
- Comme l'opération de suppression ne sais pas combien d'éléments de pari supprimé à la fin, il wold pas de sens de le faire lors de l'enlèvement. De toute façon: détail de l'implémentation, nous avons à faire confiance à apple pour écrire raisonnable code.
- La première n'est pas plus agréable (parce que vous avez à penser à beaucoup sur la façon dont il fonctionne en premier lieu) et le deuxième n'est pas refactoring coffre-fort. Donc au final j'ai fini avec les classiques de la solution retenue, qui est tout à fait lisible en fait.
- Je n'ai aucune idée de ce que tu veux dire avec “refactoring de sécurité”. Et pense "trop" est une expérience très personnelle qui dépend de la capacité individuelle.
- 1 "refactoring sûr" signifie que j'utilise objectif c de l'éditeur qui peut faire de la sécurité refactorings comme renommer changement de signature, etc, et si j'utilise quelque chose comme ceci "obj[@"shouldDelete"]" il suffit confondre éditeur, parce que pour renommer correctement à cause de la recherche des chaînes et je dois faire plus attention à ne pas introduire des bugs par refactoring si j'utilise des constructions de ce genre qui sont dangereux. 2 "la Pensée de beaucoup n'est pas si personnelle" ses toujours mieux d'écrire votre code plus simple et compréhensible possible et enregistrer votre mémoire et de l'énergie pour important de pièces difficiles et de la logique d'application.
- si vous écrivez doit compréhensible code, vous serait-il suffit d'écrire votre code de haut en bas. Mais le code de la réutilisabilité, la testabilité et la facilité de maintenance nécessite code modulaire que vous pouvez coller ensemble, d'échanger et de mettre en bibliothèques. Ce n'est pas possible sans une certaine indirections. Aussi, vous semblez avoir un problème avec l'énumération. Il est préférable, car elle élimine plusieurs problèmes peuvent se produire dans de simples pour le bouclage. Aussi subscripting est valide et facile à comprendre la syntaxe de la langue. Si vous ne l'utilisez pas à cause de refactoring, peut-être que vous êtes refactoring trop souvent.
InformationsquelleAutor vikingosegundo
8

Dans un plus déclaratif, selon les critères de correspondance les éléments à supprimer, vous pouvez utiliser:
```
[theArray filterUsingPredicate:aPredicate]
```
@Nathan doit être très efficace

InformationsquelleAutor
6

Voici le facile et propre. Je tiens à dupliquer mon tableau à droite dans le rapide énumération appel:
```
for (LineItem *item in [NSArray arrayWithArray:self.lineItems]) 
{
    if ([item.toBeRemoved boolValue] == YES) 
    {
        [self.lineItems removeObject:item];
    }
}
```
De cette façon, vous énumérer une copie du tableau étant supprimé, les deux possédant les mêmes objets. Un NSArray détient pointeurs d'objet uniquement si cela est tout à fait bien de la mémoire/performance sage.
- Ou encore plus simple - for (LineItem *item in self.lineItems.copy)
InformationsquelleAutor Matjan
5

Ajouter les objets que vous souhaitez supprimer pour un second tableau, et, après la boucle, utilisez -removeObjectsInArray:.

InformationsquelleAutor Nathan Kinsinger
5

cela devrait le faire:
```
    NSMutableArray* myArray = ....;

    int i;
    for(i=0; i<[myArray count]; i++) {
        id element = [myArray objectAtIndex:i];
        if(element == ...) {
            [myArray removeObjectAtIndex:i];
            i--;
        }
    }
```
espère que cela aide...
- pas censé être la mutation de la matrice au cours d'une itération
- Bien que peu orthodoxe, j'ai trouvé une itération à l'arrière et de suppression que je vais être simple et propre solution. Habituellement, un seul de la plus rapide des méthodes ainsi.
- Quel est le problème avec cela? C'est propre, rapide, facilement lisible, et il fonctionne comme un charme. Pour moi, il ressemble à la meilleure réponse. Pourquoi faut-il avoir un score négatif? Suis-je manqué quelque chose?
- La question des états "quelque chose de plus élégant que manuellement la mise à jour de l'index."
- oh. J'avais manqué la I-absolument-ne-veulent-à-jour-le-index-manuellement la partie. merci steve. OMI, cette solution est plus élégante que celle choisie (pas de tableau temporaire nécessaire), de sorte votes négatifs contre il se sentent injuste.
- Si vous cochez l'édite, la partie a été ajouté après que j'ai soumis ma réponse.... si non, j'aurais répondu avec "l'Itération vers l'arrière EST la solution la plus élégante" :). Have a nice day!
- Ce obtient mon vote, trop. Je ne pense pas qu'à l'aide d'une beaucoup plus inefficace méthode est justifiée pour éviter la "complexité" de celui-ci.
InformationsquelleAutor
1

Pourquoi ne pas ajouter les objets à supprimer à l'autre NSMutableArray. Lorsque vous avez terminé l'itération, vous pouvez supprimer les objets que vous avez recueillies.

InformationsquelleAutor Paul Croarkin
1

Comment sur la permutation des éléments que vous souhaitez supprimer à l'aide du n-ième élément, 'n-1 ième élément, et ainsi de suite?

Lorsque vous avez terminé, vous redimensionner le tableau précédent-taille - nombre de contrats de swaps de'

InformationsquelleAutor Cyber Oliveira
1

Si tous les objets de votre tableau sont uniques ou que vous souhaitez supprimer toutes les occurrences d'un objet trouvé, vous pouvez rapidement énumérer sur un tableau à copier et à utiliser [NSMutableArray removeObject:] pour supprimer l'objet de l'original.
```
NSMutableArray *myArray;
NSArray *myArrayCopy = [NSArray arrayWithArray:myArray];

for (NSObject *anObject in myArrayCopy) {
    if (shouldRemove(anObject)) {
        [myArray removeObject:anObject];
    }
}
```
- qu'advient-il si original montableau est mise à jour tout en +arrayWithArrayest en cours d'exécution?
- Ensuite, vous avez un bug dans votre code. NSMutableArray n'est pas thread-safe, vous êtes tenu de contrôler l'accès via les verrous. Voir cette réponse
InformationsquelleAutor lajos
1

benzado la réponse ci-dessus est ce que vous devez faire pour preformace. Dans une de mes applications removeObjectsInArray a eu une durée de 1 minute, juste l'ajout d'un nouveau tableau a pris .023 secondes.

InformationsquelleAutor Kaiser

De définir une catégorie qui me permet de filtrer à l'aide d'un bloc, comme ceci:

@implementation NSMutableArray (Filtering)

- (void)filterUsingTest:(BOOL (^)(id obj, NSUInteger idx))predicate {
    NSMutableIndexSet *indexesFailingTest = [[NSMutableIndexSet alloc] init];

    NSUInteger index = 0;
    for (id object in self) {
        if (!predicate(object, index)) {
            [indexesFailingTest addIndex:index];
        }
        ++index;
    }
    [self removeObjectsAtIndexes:indexesFailingTest];

    [indexesFailingTest release];
}

@end

qui peut ensuite être utilisé comme ceci:

[myMutableArray filterUsingTest:^BOOL(id obj, NSUInteger idx) {
    return [self doIWantToKeepThisObject:obj atIndex:idx];
}];

InformationsquelleAutor Kristopher Johnson

Une meilleure mise en œuvre pourrait être l'utilisation de la catégorie de la méthode ci-dessous sur NSMutableArray.

@implementation NSMutableArray(BMCommons)

- (void)removeObjectsWithPredicate:(BOOL (^)(id obj))predicate {
    if (predicate != nil) {
        NSMutableArray *newArray = [[NSMutableArray alloc] initWithCapacity:self.count];
        for (id obj in self) {
            BOOL shouldRemove = predicate(obj);
            if (!shouldRemove) {
                [newArray addObject:obj];
            }
        }
        [self setArray:newArray];
    }
}

@end

Le prédicat bloc peut être mis en œuvre pour faire le traitement sur chaque objet du tableau. Si le prédicat renvoie true, l'objet est supprimé.

Un exemple pour une date de tableau pour supprimer toutes les dates qui se trouvent dans le passé:

NSMutableArray *dates = ...;
[dates removeObjectsWithPredicate:^BOOL(id obj) {
    NSDate *date = (NSDate *)obj;
    return [date timeIntervalSinceNow] < 0;
}];

InformationsquelleAutor Werner Altewischer

0

De l'itération en arrière-ly a été mon préféré pendant des années , mais pendant longtemps je n'ai jamais rencontré le cas où l 'profonde' ( plus grand nombre) de l'objet a été retiré en premier. Momentanément avant de le pointeur se déplace vers le prochain indice il n'y a pas rien et il se bloque.

Benzado de la façon la plus proche de ce que je fais maintenant, mais je n'ai jamais réalisé qu'il y aurait de la pile remaniement après tous les supprimer.

sous Xcode 6 cela fonctionne
```
NSMutableArray *itemsToKeep = [NSMutableArray arrayWithCapacity:[array count]];

    for (id object in array)
    {
        if ( [object isNotEqualTo:@"whatever"]) {
           [itemsToKeep addObject:object ];
        }
    }
    array = nil;
    array = [[NSMutableArray alloc]initWithArray:itemsToKeep];
```
InformationsquelleAutor aremvee

Vous devez vous connecter pour publier un commentaire.