Ricerca…


Sintassi

  • NSArray * words; // Dichiarazione di array immutabile
  • NSMutableArray * words; // Dichiarazione della matrice mutabile
  • NSArray * words = [NSArray arrayWithObjects: @ "one", @ "two", nil]; // Sintassi di inizializzazione dell'array
  • NSArray * words = @ [@ "lista", @ "di", @ "parole", @ 123, @ 3,14]; // Dichiarazione dei letterali di array
  • NSArray * stringArray = [array NSArrayWithObjects: [array NSMutableArray], [array NSMutableArray], [array NSMutableArray], nil]; // Creazione di array multidimentali

Creare matrici

Creazione di matrici immutabili:

NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];

// Using the array literal syntax:
NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];

Per gli array mutabili, vedere NSMutableArray .

Scoprire il numero di elementi in una matrice

NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];
NSLog (@"Number of elements in array = %lu", [myColors count]);

Accesso agli elementi

NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
// Preceding is the preferred equivalent to [NSArray arrayWithObjects:...]

Ottenere un singolo oggetto

L' objectAtIndex: metodo fornisce un singolo oggetto. Il primo oggetto in un NSArray è l'indice 0. Poiché un NSArray può essere omogeneo (contenente diversi tipi di oggetti), il tipo restituito è id ("qualsiasi oggetto"). (Un id può essere assegnato a una variabile di qualsiasi altro tipo di oggetto.) Importante, gli NSArray possono contenere solo oggetti. Non possono contenere valori come int .

NSUInteger idx = 2;
NSString *color = [myColors objectAtIndex:idx];
// color now points to the string @"Green"

Clang fornisce una migliore sintassi del pedice come parte della sua funzionalità letterale di array :

NSString *color = myColors[idx];

Entrambi generano un'eccezione se l'indice passato è inferiore a 0 o maggiore di count - 1 .

Primo e ultimo elemento

NSString *firstColor = myColors.firstObject;
NSString *lastColor = myColors.lastObject;

Il firstObject e lastObject sono proprietà calcolate e restituiscono nil piuttosto che crash per gli array vuoti. Per gli array di singoli elementi restituiscono lo stesso oggetto. Sebbene, il metodo firstObject non sia stato introdotto in NSArray fino a iOS 4.0.

NSArray *empty = @[]
id notAnObject = empty.firstObject;    // Returns `nil`
id kaboom = empty[0];    // Crashes; index out of bounds

Array di filtraggio con predicati

NSArray *array = [NSArray arrayWithObjects:@"Nick", @"Ben", @"Adam", @"Melissa", nil];

NSPredicate *aPredicate = [NSPredicate predicateWithFormat:@"SELF beginswith[c] 'a'"];
NSArray *beginWithA = [array filteredArrayUsingPredicate:bPredicate];
     // beginWithA contains { @"Adam" }.

NSPredicate *ePredicate = [NSPredicate predicateWithFormat:@"SELF contains[c] 'e'"];
[array filterUsingPredicate:ePredicate];
    // array now contains { @"Ben", @"Melissa" }

Di più

NSPredicate :

Apple doc: NSPredicate

Conversione di NSArray in NSMutableArray per consentire la modifica

NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];

// Convert myColors to mutable
NSMutableArray *myColorsMutable = [myColors mutableCopy]; 

Ordinamento dell'array con oggetti personalizzati

Confronta il metodo

O implementa un metodo di confronto per il tuo oggetto:

- (NSComparisonResult)compare:(Person *)otherObject {
    return [self.birthDate compare:otherObject.birthDate];
}

NSArray *sortedArray = [drinkDetails sortedArrayUsingSelector:@selector(compare:)];

NSSortDescriptor

NSSortDescriptor *sortDescriptor;
sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"birthDate"
                                              ascending:YES];
NSArray *sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
NSArray *sortedArray = [drinkDetails sortedArrayUsingDescriptors:sortDescriptors];

È possibile ordinare facilmente più chiavi aggiungendo più di una all'array. È anche possibile utilizzare metodi di confronto personalizzati. Dai un'occhiata alla documentazione .

blocchi

NSArray *sortedArray;
sortedArray = [drinkDetails sortedArrayUsingComparator:^NSComparisonResult(id a, id b) {
    NSDate *first = [(Person*)a birthDate];
    NSDate *second = [(Person*)b birthDate];
    return [first compare:second];
}];

Prestazione

Il -compare: e i metodi basati su blocchi saranno un po 'più veloci, in generale, rispetto all'utilizzo di NSSortDescriptor poiché quest'ultimo si basa su KVC. Il vantaggio principale del metodo NSSortDescriptor è che fornisce un modo per definire il tuo ordinamento usando i dati, piuttosto che il codice, il che rende facile, ad esempio, impostare le cose in modo che gli utenti possano ordinare un NSTableView facendo clic sulla riga dell'intestazione.

Conversione tra insiemi e matrici

NSSet *set = [NSSet set];
NSArray *array = [NSArray array];

NSArray *fromSet = [set allObjects];
NSSet *fromArray = [NSSet setWithArray:array];

Invertire una matrice

NSArray *reversedArray = [myArray.reverseObjectEnumerator allObjects];

Looping through

NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];

// Fast enumeration
// myColors cannot be modified inside the loop
for (NSString *color in myColors) {
    NSLog(@"Element %@", color);
}

// Using indices
for (NSUInteger i = 0; i < myColors.count; i++) {
    NSLog(@"Element %d = %@", i, myColors[i]);
}

// Using block enumeration
[myColors enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL * stop) {
    NSLog(@"Element %d = %@", idx, obj);

    // To abort use:
    *stop = YES
}];

// Using block enumeration with options
[myColors enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL * stop) {
    NSLog(@"Element %d = %@", idx, obj);
}];

Uso di Generics

Per maggiore sicurezza possiamo definire il tipo di oggetto che contiene la matrice:

NSArray<NSString *> *colors = @[@"Red", @"Green", @"Blue", @"Yellow"];
NSMutableArray<NSString *> *myColors = [NSMutableArray arrayWithArray:colors];
[myColors addObject:@"Orange"]; // OK
[myColors addObject:[UIColor purpleColor]]; // "Incompatible pointer type" warning

Va notato che questo è controllato solo durante il tempo di compilazione.

Enumerazione mediante blocchi

NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
[myColors enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    NSLog(@"enumerating object %@ at index %lu", obj, idx);
}];

Impostando il parametro stop su YES è possibile indicare che non è necessaria un'ulteriore enumerazione. per farlo basta impostare &stop = YES .

NSEnumerationOptions
È possibile enumerare la matrice in ordine inverso e / o simultaneo:

[myColors enumerateObjectsWithOptions:NSEnumerationConcurrent | NSEnumerationReverse
                               usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
                                   NSLog(@"enumerating object %@ at index %lu", obj, idx);
                               }];

Enumerazione del sottoinsieme di array

NSIndexSet *indexSet = [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(1, 1)];
[myColors enumerateObjectsAtIndexes:indexSet
                            options:kNilOptions
                         usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
                                NSLog(@"enumerating object %@ at index %lu", obj, idx);
                            }];

Confronto tra matrici

Le matrici possono essere confrontate per l'uguaglianza con il nome appropriatamente isEqualToArray: method, che restituisce YES quando entrambi gli array hanno lo stesso numero di elementi e ogni coppia supera un isEqual: confronto.

NSArray *germanMakes = @[@"Mercedes-Benz", @"BMW", @"Porsche",
                     @"Opel", @"Volkswagen", @"Audi"];
NSArray *sameGermanMakes = [NSArray arrayWithObjects:@"Mercedes-Benz",
                        @"BMW", @"Porsche", @"Opel",
                        @"Volkswagen", @"Audi", nil];

if ([germanMakes isEqualToArray:sameGermanMakes]) {
    NSLog(@"Oh good, literal arrays are the same as NSArrays");
}

La cosa importante è che ogni coppia deve superare isEqual: test. Per gli oggetti personalizzati questo metodo dovrebbe essere implementato. Esiste nel protocollo NSObject.

Aggiungi oggetti a NSArray

NSArray *a = @[@1];
a = [a arrayByAddingObject:@2];
a = [a arrayByAddingObjectsFromArray:@[@3, @4, @5]];

Questi metodi sono ottimizzati per ricreare il nuovo array in modo molto efficiente, di solito senza dover distruggere l'array originale o allocare più memoria.



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow