Aider le tri d'un NSArray à travers deux propriétés (avec NSSortDescriptor?)

La sortedArrayUsingDescriptors: NSArray méthode n'est plus de ce dont vous avez besoin:

Le premier descripteur spécifie la clé primaire de chemin pour être utilisé dans le tri, le récepteur du contenu. Toute demande subséquente de descripteurs sont utilisés pour affiner le tri des objets avec des valeurs en double. Voir NSSortDescriptor pour plus d'informations.

Un filtrage avec NSPredicate est également requise:

NSSortDescriptor *timeSD = [NSSortDescriptor sortDescriptorWithKey: @"time" ascending: YES];

NSMutableArray *sortedByTime = [UnsortedArray sortedArrayUsingDescriptors: timeSD];
NSMutableArray *sortedArray = [NSMutableArray arrayWithCapacity:[sortedByTime count]];

while([sortedByTime count]) 
{
        id groupLead = [sortedByTime objectAtIndex:0];  
        NSPredicate *groupPredicate = [NSPredicate predicateWithFormat:@"name = %@", [groupLead name]];

        NSArray *group = [sortedByTime filteredArrayUsingPredicate: groupPredicate];

        [sortedArray addObjectsFromArray:group];
        [sortedByTime removeObjectsInArray:group];
}

Je n'ai aucune idée si c'est la méthode la plus efficace, mais jusqu'à ce que vous avez des raisons de croire qu'il est à l'origine de problèmes il n'y a pas besoin de s'inquiéter de l'incidence sur les performances. Il est prématuré d'optimisation. Je ne voudrais pas avoir des préoccupations au sujet de la performance de cette méthode. Vous avez confiance en la cadre sinon vous allez réécrire (ce qui minent le point du cadre) en raison d'une non fondé de la paranoïa.

OriginalL'auteur Benedict Cohen

Je voudrais créer une nouvelle classe appelée ItemGroup, puis ajouter un supplément de ivar appelé group à votre classe d'article:

@interface ItemGroup : NSObject
{
    NSNumber * time;
}
@property (nonatomic, copy) time;
@end

@interface ItemClass : NSobject
{
    NSString * name;
    NSNumber * time;
    ItemGroup * group;
}
@property (nonatomic, copy) NSString * name;
@property (nonatomic, copy) NSNumber * time;
@property (nonatomic, assign) ItemClass * group; //note: must be assign
@end

Ensuite, vous pouvez effectuer les opérations suivantes:

NSMutableDictionary * groups = [NSMutableDictionary dictionaryWithCapacity:0];
for (ItemClass * item in sourceData)
{
    ItemGroup * group = [groups objectForKey:item.name];
    if (group == nil)
    {
        group = [[ItemGroup alloc] init];
        [groups setObject:group forKey:item.name];
        [group release];

        group.time = item.time;
    }
    else if (item.time < group.time)
    {
        group.time = item.time;
    }
    item.group = group;
}

Ce code parcourt le tableau non trié, garder une trace de la durée minimale pour chaque groupe, et aussi réglage le groupe pour chaque élément. Avec ce complet, il vous suffit de trier sur group.time et time:

NSSortDescriptor * groupSorter;
groupSort = [NSSortDescriptor sortDescriptorWithKey:@"group.time" ascending:YES];

NSSortDescriptor * timeSorter;
timeSort = [NSSortDescriptor sortDescriptorWithKey:@"time" ascending:YES];

NSArray * sortDescriptors = [NSArray arrayWithObjects:groupSort, timeSort, nil];

NSArray * sorted = [sourceData sortedArrayUsingDescriptors:sortDescriptors];

Et qui devrait faire l'affaire!

Mise à JOUR: Notez que vous pourriez obtenir beaucoup de meilleures performances si vous avez été en mesure d'affecter les groupes tout droit sorti de la porte. Quelque chose comme ceci:

@interface ItemGroup : NSObject
{
    NSString * name;
    NSNumber * time;
}
@property (nonatomic, copy) NSString * name;
@property (nonatomic, copy) NSSNumber * time;
@end

@interface ItemClass : NSObject
{
    ItemGroup * group;
    NSNumber * time;
}
@property (nonatomic, retain) ItemGroup * group;
@property (nonatomic, copy) NSNumber * time;
@end

Maintenant, si vous maintenez une liste de groupes quelque part (ils pourraient même aller dans un tableau quelque part, en cas de besoin):

ItemGroup * group_A = [[ItemGroup alloc] init];
group_A.name = @"A";
ItemGroup * group_B = [[ItemGroup alloc] init];
group_B.name = @"B";
...

Et au lieu de définir la noms de vos éléments de données, vous pouvez définir leur groupe:

someItem.group = group_A;
someItem.time = GetSomeRandomTimeValue();
[sourceData addObject:someItem];
....

Cela permettrait de simplifier considérablement la boucle utilisée pour définir le groupe de fois:

for (ItemClass * item in sourceData)
{
    if (item.time < group.time) { group.time = item.time; }
}

Et, si tu voulais vraiment être flamboyant rapide à ce sujet, vous pouvez même modifier la propriété setter pour votre time de propriété pour définir le groupe de fois à la volée:

@implementation ItemClass
- (void)setTime:(NSNumber *)newTime
{
    if (newTime < group.time) { group.time = newTime; }
    time = [newTime copy];
}
@end

Noter que vous devez être sûr que group avait été mis en avant de régler l'heure. Avec cela en place, vous n'auriez pas besoin que le tri boucle à tous. Le sortDescriptors serait suffisant.

OriginalL'auteur e.James

Vous pouvez utiliser NSSortDescriptor. Ces descripteurs sont très utiles car ils vous permettent de faire plusieurs clés de tri ainsi seule clé de tri. Le cas de la sensibilité et de l'insensibilité est également facilement réalisables. J'ai trouvé un exemple détaillé ICI

OriginalL'auteur guPra