Ajout d'éléments à un NSArray

Je sais qu'on pourrait tout simplement utiliser un NSMutableArray pour l'objet, mais que faire si ce n'est pas une option et nous avons besoin d'ajouter de nouveaux éléments à un NSArray. Comment pourrions-nous le faire?

Ma réponse immédiate serait de créer un NSMutableArray avec l'original NSArray, ajouter de nouveaux éléments sur, puis jeté à la NSMutableArray en arrière à l'original NSArray.

M'a demandé dans une interview et je suis curieux de savoir ce qu'est une bonne solution pourrait être, d'ailleurs il suffit d'utiliser un NSMutableArray en premier lieu.

OriginalL'auteur Oscar | 2012-12-12

11
```
NSArray *array = [NSArray arrayWithObjects:@"One", @"Two", nil];

array = [array arrayByAddingObject:@"Three"];
```
ou
```
NSArray *newArray = [NSArray arrayWithObjects:@"Three", @"Four", nil];

array = [array arrayByAddingObjectsFromArray:newArray];
```
Supposons que j'ai un très grand tableau. Quel serait le moyen le plus efficace de faire ce que l'OP demande? Votre solution, ou la mutableCopy->add->cast solution proposée par l'OP?
La plus efficace. Mutable tableau. Ensuite le tableau en ajoutant dans ma méthode. je ne sais pas si. De le tester et de me faire part de vos constats 🙂
J'ai testé cela et ils s'est avéré être le même aussi longtemps que vous êtes seulement en ajoutant un élément de plus, indépendamment de la taille. Voici la longue explication: stackoverflow.com/a/26517217/1564332
vous êtes génial !!!!

OriginalL'auteur Fogmeister
3

Vous pouvez utiliser mutableCopy sur votre NSArray objet de retour d'un NSMutableArray contenant les objets précédents.

OriginalL'auteur jimpic
3

NSArray objets sont immuable de sorte qu'ils ne peuvent pas être modifiés. La seule option est de créer un nouveau NSArray (par le biais d'un intermédiaire NSMutableArray objet peut-être) et de mettre cette nouvelle matrice de retour dans la possession de l'objet (si elle le permet).

OriginalL'auteur trojanfoe

Je me demandais ce que la différence de performances d'être entre l'aide d' arrayByAddingObject et la création d'une mutable copie, puis en ajoutant un élément.

J'ai trouvé qu'il n'a pas d'importance.

Voici ce que j'ai utilisé

- (IBAction)doTest
{
    for(int n = 0; n < 7; n++){
        [self runTestWithExponent:n];
    }
    NSLog(@"done");
}

- (void)runTestWithExponent:(double)exponent
{
    int arraySize = pow(10.0, exponent);

    NSMutableArray *originalMutableArray = [NSMutableArray arrayWithCapacity:arraySize];
    for(int i = 0; i < arraySize; i++){
        [originalMutableArray addObject:@(i)];
    }
    NSArray *originalArray = [NSArray arrayWithArray:originalMutableArray];
    originalMutableArray = nil;

    //test first time
    NSDate *now = [NSDate date];
    NSArray *newArray = [originalArray arrayByAddingObject:@(-1)];
    NSTimeInterval time1 = [[NSDate date] timeIntervalSinceDate:now];
    newArray = nil;

    //test second time
    now = [NSDate date];
    NSMutableArray *mutable = [originalArray mutableCopy];
    [mutable addObject:@(-1)];
    NSTimeInterval time2 = [[NSDate date] timeIntervalSinceDate:now];
    mutable = nil;

    NSString *winner = (time1 == time2) ? @"same" : ((time1 < time2) ? @"arrayByAdding" : @"mutable");
    NSLog(@"%i : %f --- %f : %@ %f%%", arraySize, time1, time2, winner, (time1/time2 * 100));
}

Comme vous pouvez le voir, je teste différentes taille des matrices. Tailles de 1, 10, 100 et 1 000 000 d'. J'ai trouvé quelle que soit leur taille, les temps sont très semblables les uns aux autres. Pour toute longueur, parfois, une méthode est plus rapide, et les autres, l'autre. Je devine en interne, ils font la même chose.

Voici la sortie de trois pistes:

1 : 0.000026 --- 0.000034 : arrayByAdding 76.491228%
10 : 0.000011 --- 0.000011 : same 100.000000%
100 : 0.000021 --- 0.000024 : arrayByAdding 87.344913%
1000 : 0.000228 --- 0.000260 : arrayByAdding 87.689133%
10000 : 0.001458 --- 0.001406 : mutable 103.696638%
100000 : 0.015396 --- 0.015625 : arrayByAdding 98.534393%
1000000 : 0.158018 --- 0.162849 : arrayByAdding 97.033438%
done
1 : 0.000011 --- 0.000012 : arrayByAdding 92.039801%
10 : 0.000012 --- 0.000014 : arrayByAdding 85.531915%
100 : 0.000020 --- 0.000025 : arrayByAdding 79.952267%
1000 : 0.000185 --- 0.000144 : mutable 128.435430%
10000 : 0.001397 --- 0.001437 : arrayByAdding 97.216807%
100000 : 0.014448 --- 0.014132 : mutable 102.235803%
1000000 : 0.145622 --- 0.149862 : arrayByAdding 97.170746%
done
1 : 0.000013 --- 0.000012 : mutable 107.920792%
10 : 0.000011 --- 0.000013 : arrayByAdding 84.862385%
100 : 0.000025 --- 0.000029 : arrayByAdding 86.036961%
1000 : 0.000165 --- 0.000135 : mutable 122.207506%
10000 : 0.001547 --- 0.001470 : mutable 105.242884%
100000 : 0.014817 --- 0.014337 : mutable 103.347954%
1000000 : 0.146554 --- 0.148468 : arrayByAdding 98.710857%
done

Gardez à l'esprit que cela n'a été testé pour l'ajout d'un élément. Je soupçonne que (par exemple) l'ajout de 500 éléments de 1000 tableau de taille sera probablement plus rapide à l'aide de la seconde méthode, mais je le laisse de telles expériences à quelqu'un d'autre.

OriginalL'auteur Rob

0

C'est simplement une question piège. NSArrays sont immuables et ne peut être modifié sans la création d'un nouveau NSArray ou NSMutableArray à partir du tableau précédent, pure et simple.

OriginalL'auteur Mark McCorkle

Vous devez vous connecter pour publier un commentaire.