ios मैं इसमें एनएसएमयूटेबलएरे को कस्टम ऑब्जेक्ट्स के साथ कैसे सॉर्ट करूं?




objective-c sorting (20)

विधि की तुलना करें

या तो आप अपनी ऑब्जेक्ट के लिए तुलना-विधि लागू करते हैं:

- (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 *sortedArray = [drinkDetails sortedArrayUsingDescriptors:@[sortDescriptor]];

आप सरणी में एक से अधिक जोड़कर आसानी से एकाधिक कुंजी द्वारा सॉर्ट कर सकते हैं। कस्टम तुलनित्र-विधियों का उपयोग करना भी संभव है। प्रलेखन पर एक नज़र डालें।

ब्लॉक (चमकदार!)

मैक ओएस एक्स 10.6 और आईओएस 4 के बाद से ब्लॉक के साथ सॉर्ट करने की संभावना भी है:

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

प्रदर्शन

-compare: और ब्लॉक-आधारित विधियां सामान्य रूप से NSSortDescriptor का उपयोग करने की तुलना में काफी तेज़ी से NSSortDescriptor क्योंकि बाद में NSSortDescriptor पर निर्भर करता है। NSSortDescriptor विधि का प्राथमिक लाभ यह है कि यह कोड के बजाए डेटा का उपयोग करके आपके सॉर्ट ऑर्डर को परिभाषित करने का एक तरीका प्रदान करता है, जिससे चीजों को सेट करना आसान हो जाता है ताकि उपयोगकर्ता हेडर पंक्ति पर क्लिक करके NSSortDescriptor को सॉर्ट कर सकें।

मैं जो करना चाहता हूं वह बहुत आसान लगता है, लेकिन मुझे वेब पर कोई जवाब नहीं मिल रहा है। मेरे पास ऑब्जेक्ट्स का NSMutableArray है, और NSMutableArray लें कि वे 'व्यक्ति' ऑब्जेक्ट्स हैं। मैं एनएसएमयूटेबलएरे को व्यक्ति.बर्थडेट द्वारा सॉर्ट करना चाहता हूं जो एनएसडीएटी है।

मुझे लगता है कि इस विधि के साथ इसका कुछ संबंध है:

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

जावा में मैं अपनी ऑब्जेक्ट को तुलनात्मक रूप से कार्यान्वित कर दूंगा, या इनलाइन कस्टम तुलनित्र के साथ Collections.sort का उपयोग करूँगा ... आप उद्देश्य-सी में पृथ्वी पर कैसे करते हैं?


आपको sortDescriptor बनाना है और फिर आप नीचे की तरह sortDescriptor का उपयोग कर nsmutablearray को सॉर्ट कर सकते हैं।

 let sortDescriptor = NSSortDescriptor(key: "birthDate", ascending: true, selector: #selector(NSString.compare(_:)))
 let array = NSMutableArray(array: self.aryExist.sortedArray(using: [sortDescriptor]))
 print(array)

जॉर्ज शॉली के दूसरे जवाब में एक लापता कदम है, लेकिन यह ठीक काम करता है।

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

आपकी Person वस्तुओं को एक विधि को लागू करने की आवश्यकता है, compare: जो किसी अन्य Person वस्तु को लेता है, और 2 ऑब्जेक्ट्स के बीच संबंधों के अनुसार NSComparisonResult है।

फिर आप sortedArrayUsingSelector: को कॉल sortedArrayUsingSelector: @selector(compare:) और यह किया जाना चाहिए।

अन्य तरीके हैं, लेकिन जहां तक ​​मुझे पता है कि Comparable इंटरफेस का कोई कोको-इक्विव नहीं है। sortedArrayUsingSelector: का उपयोग करना sortedArrayUsingSelector: शायद इसे करने का सबसे sortedArrayUsingSelector: तरीका है।


मैंने कस्टम आवश्यकता के आधार पर बहु ​​स्तरीय सॉर्टिंग की है।

// मूल्यों को क्रमबद्ध करें

    [arrItem sortUsingComparator:^NSComparisonResult (id a, id b){

    ItemDetail * itemA = (ItemDetail*)a;
    ItemDetail* itemB =(ItemDetail*)b;

    //item price are same
    if (itemA.m_price.m_selling== itemB.m_price.m_selling) {

        NSComparisonResult result=  [itemA.m_itemName compare:itemB.m_itemName];

        //if item names are same, then monogramminginfo has to come before the non monograme item
        if (result==NSOrderedSame) {

            if (itemA.m_monogrammingInfo) {
                return NSOrderedAscending;
            }else{
                return NSOrderedDescending;
            }
        }
        return result;
    }

    //asscending order
    return itemA.m_price.m_selling > itemB.m_price.m_selling;
}];

https://sites.google.com/site/greateindiaclub/mobil-apps/ios/multilevelsortinginiosobjectivec


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

धन्यवाद, यह ठीक काम कर रहा है ...


NSMutableArray *stockHoldingCompanies = [NSMutableArray arrayWithObjects:fortune1stock,fortune2stock,fortune3stock,fortune4stock,fortune5stock,fortune6stock , nil];

NSSortDescriptor *sortOrder = [NSSortDescriptor sortDescriptorWithKey:@"companyName" ascending:NO];

[stockHoldingCompanies sortUsingDescriptors:[NSArray arrayWithObject:sortOrder]];

NSEnumerator *enumerator = [stockHoldingCompanies objectEnumerator];

ForeignStockHolding *stockHoldingCompany;

NSLog(@"Fortune 6 companies sorted by Company Name");

    while (stockHoldingCompany = [enumerator nextObject]) {
        NSLog(@"===============================");
        NSLog(@"CompanyName:%@",stockHoldingCompany.companyName);
        NSLog(@"Purchase Share Price:%.2f",stockHoldingCompany.purchaseSharePrice);
        NSLog(@"Current Share Price: %.2f",stockHoldingCompany.currentSharePrice);
        NSLog(@"Number of Shares: %i",stockHoldingCompany.numberOfShares);
        NSLog(@"Cost in Dollars: %.2f",[stockHoldingCompany costInDollars]);
        NSLog(@"Value in Dollars : %.2f",[stockHoldingCompany valueInDollars]);
    }
    NSLog(@"===============================");

स्विफ्ट के प्रोटोकॉल और कार्यात्मक प्रोग्रामिंग आपको इतना आसान बनाता है कि आपको अपनी कक्षा को तुलनात्मक प्रोटोकॉल के अनुरूप बनाना होगा, प्रोटोकॉल द्वारा आवश्यक विधियों को लागू करना होगा और फिर क्रमबद्ध (द्वारा:) उच्च ऑर्डर फ़ंक्शन का उपयोग करने के लिए सॉर्ट किए गए सरणी को बनाने के लिए उपयोग करना होगा रास्ते से mutable सरणी।

class Person: Comparable {
    var birthDate: NSDate?
    let name: String

    init(name: String) {
        self.name = name
    }

    static func ==(lhs: Person, rhs: Person) -> Bool {
        return lhs.birthDate === rhs.birthDate || lhs.birthDate?.compare(rhs.birthDate as! Date) == .orderedSame
    }

    static func <(lhs: Person, rhs: Person) -> Bool {
        return lhs.birthDate?.compare(rhs.birthDate as! Date) == .orderedAscending
    }

    static func >(lhs: Person, rhs: Person) -> Bool {
        return lhs.birthDate?.compare(rhs.birthDate as! Date) == .orderedDescending
    }

}

let p1 = Person(name: "Sasha")
p1.birthDate = NSDate() 

let p2 = Person(name: "James")
p2.birthDate = NSDate()//he is older by miliseconds

if p1 == p2 {
    print("they are the same") //they are not
}

let persons = [p1, p2]

//sort the array based on who is older
let sortedPersons = persons.sorted(by: {$0 > $1})

//print sasha which is p1
print(persons.first?.name)
//print James which is the "older"
print(sortedPersons.first?.name)

आप अपने उद्देश्य के लिए निम्नलिखित सामान्य विधि का उपयोग कर सकते हैं। यह आपकी समस्या को हल करना चाहिए।

//Called method
-(NSMutableArray*)sortArrayList:(NSMutableArray*)arrDeviceList filterKeyName:(NSString*)sortKeyName ascending:(BOOL)isAscending{
    NSSortDescriptor *sorter = [[NSSortDescriptor alloc] initWithKey:sortKeyName ascending:isAscending];
    [arrDeviceList sortUsingDescriptors:[NSArray arrayWithObject:sorter]];
    return arrDeviceList;
}

//Calling method
[self sortArrayList:arrSomeList filterKeyName:@"anything like date,name etc" ascending:YES];

NSMutableArray विधि sortUsingFunction:context: देखें sortUsingFunction:context:

आपको तुलनात्मक कार्य स्थापित करने की आवश्यकता होगी जिसमें दो ऑब्जेक्ट्स (प्रकार का Person , क्योंकि आप दो Person वस्तुओं की तुलना कर रहे हैं) और संदर्भ पैरामीटर लेते हैं।

दो वस्तुएं सिर्फ Person उदाहरण हैं। तीसरी वस्तु एक स्ट्रिंग है, उदाहरण के लिए @ "जन्मदिन"।

यह फ़ंक्शन एक NSComparisonResult देता है: यदि PersonA.birthDate देता है तो PersonA.birthDate < PersonB.birthDate । यदि PersonA.birthDate > PersonB.birthDate यदि यह NSOrderedDescending वापस आ जाएगा। अंत में, यह NSOrderedSame वापस NSOrderedSame यदि PersonA.birthDate == PersonB.birthDate

यह किसी न किसी छद्म कोड है; आपको एक तारीख के लिए "कम", "अधिक" या "बराबर" होने की दूसरी तारीख (जैसे सेकेंड-ए-इकोच इत्यादि की तुलना करने) के लिए इसका अर्थ है, इसका मांसपेशियों को बाहर निकालना होगा:

NSComparisonResult compare(Person *firstPerson, Person *secondPerson, void *context) {
  if ([firstPerson birthDate] < [secondPerson birthDate])
    return NSOrderedAscending;
  else if ([firstPerson birthDate] > [secondPerson birthDate])
    return NSOrderedDescending;
  else 
    return NSOrderedSame;
}

यदि आप कुछ और कॉम्पैक्ट चाहते हैं, तो आप टर्नरी ऑपरेटरों का उपयोग कर सकते हैं:

NSComparisonResult compare(Person *firstPerson, Person *secondPerson, void *context) {
  return ([firstPerson birthDate] < [secondPerson birthDate]) ? NSOrderedAscending : ([firstPerson birthDate] > [secondPerson birthDate]) ? NSOrderedDescending : NSOrderedSame;
}

अगर आप इसे बहुत कुछ करते हैं तो इनलाइनिंग शायद इसे थोड़ा तेज कर सकती है।


आईओएस 4 में शुरू करना आप सॉर्टिंग के लिए ब्लॉक का भी उपयोग कर सकते हैं।

इस विशेष उदाहरण के लिए मैं मान रहा हूं कि आपके सरणी में ऑब्जेक्ट्स में 'स्थिति' विधि है, जो एक NSInteger देता है।

NSArray *arrayToSort = where ever you get the array from... ;
NSComparisonResult (^sortBlock)(id, id) = ^(id obj1, id obj2) 
{
    if ([obj1 position] > [obj2 position]) 
    { 
        return (NSComparisonResult)NSOrderedDescending;
    }
    if ([obj1 position] < [obj2 position]) 
    {
        return (NSComparisonResult)NSOrderedAscending;
    }
    return (NSComparisonResult)NSOrderedSame;
};
NSArray *sorted = [arrayToSort sortedArrayUsingComparator:sortBlock];

नोट: "क्रमबद्ध" सरणी स्वत: समाप्त हो जाएगी।


NSSortDescriptor  *sort = [[NSSortDescriptor alloc] initWithKey:@"_strPrice"
                                                 ascending:sortFlag selector:@selector(localizedStandardCompare:)] ;

स्विफ्ट में ऐरे सॉर्ट करें

नीचे Swifty व्यक्ति के लिए वैश्विक स्तर पर उपरोक्त लक्ष्य प्राप्त करने के लिए एक बहुत ही साफ तकनीक है। आइए User का एक कस्टम क्लास क्लास है जिसमें कुछ विशेषताएं हैं।

class User: NSObject {
    var id: String?
    var name: String?
    var email: String?
    var createdDate: Date?
}

अब हमारे पास एक सरणी है जिसे हमें createdDate के आधार पर आरोही और / या अवरोही के आधार पर क्रमबद्ध करने की आवश्यकता है। तो चलिए तिथि तुलना के लिए एक समारोह जोड़ें।

class User: NSObject {
    var id: String?
    var name: String?
    var email: String?
    var createdDate: Date?
    func checkForOrder(_ otherUser: User, _ order: ComparisonResult) -> Bool {
        if let myCreatedDate = self.createdDate, let othersCreatedDate = otherUser.createdDate {
            //This line will compare both date with the order that has been passed.
            return myCreatedDate.compare(othersCreatedDate) == order
        }
        return false
    }
}

अब User लिए Array extension । सरल शब्दों में केवल उन ऐरे के लिए कुछ विधियां जोड़ें जो केवल इसमें User ऑब्जेक्ट्स हैं।

extension Array where Element: User {
    //This method only takes an order type. i.e ComparisonResult.orderedAscending
    func sortUserByDate(_ order: ComparisonResult) -> [User] {
        let sortedArray = self.sorted { (user1, user2) -> Bool in
            return user1.checkForOrder(user2, order)
        }
        return sortedArray
    }
}

आरोही आदेश के लिए उपयोग

let sortedArray = someArray.sortUserByDate(.orderedAscending)

उतरने के आदेश के लिए उपयोग

let sortedArray = someArray.sortUserByDate(.orderedAscending)

उसी आदेश के लिए उपयोग

let sortedArray = someArray.sortUserByDate(.orderedSame)

extension में उपरोक्त विधि केवल तभी पहुंच योग्य होगी जब Array प्रकार [User] || है Array<User>


NSComparator का उपयोग करके क्रमबद्ध करें

यदि हम कस्टम ऑब्जेक्ट्स को सॉर्ट करना चाहते हैं तो हमें NSComparator प्रदान करने की आवश्यकता है, जिसका उपयोग कस्टम ऑब्जेक्ट्स की तुलना करने के लिए किया जाता है। ब्लॉक दो ऑब्जेक्ट्स के ऑर्डर को इंगित करने के लिए एक NSComparisonResult मूल्य देता है। तो पूरे सरणी को क्रमबद्ध करने के लिए NSComparator का उपयोग निम्न तरीके से किया जाता है।

NSArray *sortedArray = [employeesArray sortedArrayUsingComparator:^NSComparisonResult(Employee *e1, Employee *e2){
    return [e1.firstname compare:e2.firstname];    
}];

NSSortDescriptor का उपयोग कर प्रकार
मान लीजिए, उदाहरण के तौर पर, हमारे पास एक कस्टम क्लास के उदाहरण वाले सरणी हैं, कर्मचारी के पास प्रथम नाम, अंतिम नाम और आयु विशेषता है। निम्न उदाहरण बताता है कि कैसे एक NSSortDescriptor बनाने के लिए उपयोग किया जा सकता है जिसे सरणी सामग्री को आयु कुंजी द्वारा आरोही क्रम में सॉर्ट करने के लिए उपयोग किया जा सकता है।

NSSortDescriptor *ageDescriptor = [[NSSortDescriptor alloc] initWithKey:@"age" ascending:YES];
NSArray *sortDescriptors = @[ageDescriptor];
NSArray *sortedArray = [employeesArray sortedArrayUsingDescriptors:sortDescriptors];

कस्टम तुलना का उपयोग करके क्रमबद्ध करें
नाम स्ट्रिंग हैं, और जब आप उपयोगकर्ता को तारों को सॉर्ट करते हैं तो आपको हमेशा स्थानीयकृत तुलना का उपयोग करना चाहिए। अक्सर आप एक केस असंवेदनशील तुलना करना भी चाहते हैं। आखिरी और पहले नाम से सरणी को ऑर्डर करने के लिए यहां (localizedStandardCompare :) के साथ एक उदाहरण आता है।

NSSortDescriptor *lastNameDescriptor = [[NSSortDescriptor alloc]
              initWithKey:@"lastName" ascending:YES selector:@selector(localizedStandardCompare:)];
NSSortDescriptor * firstNameDescriptor = [[NSSortDescriptor alloc]
              initWithKey:@"firstName" ascending:YES selector:@selector(localizedStandardCompare:)];
NSArray *sortDescriptors = @[lastNameDescriptor, firstNameDescriptor];
NSArray *sortedArray = [employeesArray sortedArrayUsingDescriptors:sortDescriptors];

संदर्भ और विस्तृत चर्चा के लिए कृपया देखें: https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/SortDescriptors/Articles/Creating.html
http://www.ios-blog.co.uk/tutorials/objective-c/how-to-sort-nsarray-with-custom-objects/


NSMutableArray , sortUsingSelector विधि का उपयोग करें। यह एक नया उदाहरण बनाये बिना, यह जगह बनाता है।


छंटनी NSMutableArray बहुत आसान है:

NSMutableArray *arrayToFilter =
     [[NSMutableArray arrayWithObjects:@"Photoshop",
                                       @"Flex",
                                       @"AIR",
                                       @"Flash",
                                       @"Acrobat", nil] autorelease];

NSMutableArray *productsToRemove = [[NSMutableArray array] autorelease];

for (NSString *products in arrayToFilter) {
    if (fliterText &&
        [products rangeOfString:fliterText
                        options:NSLiteralSearch|NSCaseInsensitiveSearch].length == 0)

        [productsToRemove addObject:products];
}
[arrayToFilter removeObjectsInArray:productsToRemove];

आप त्वरित क्रम का उपयोग कर कस्टम ऑब्जेक्ट्स की सरणी सॉर्ट कर सकते हैं। स्विफ्ट 4 का उपयोग करके नीचे उदाहरण पाएं

func sortArrayOfPersonInAscendingOrder() {
        if self.arrSortingPersons != nil, self.arrSortingPersons.count > 0 {
            self.arrSortingPersons.sort(by: { (person1, person2) -> Bool in
                return person1.birthDate < person2.birthDate
            })
        }

        print("Sorted Array In Ascending Order:\n\(self.arrSortingPersons)")
    }

मैंने श्रेणी विधियों की एक छोटी लाइब्रेरी बनाई है, जिसे लिंक टू ऑब्जेक्टिव सी कहा जाता है, जो इस तरह की चीज को और अधिक आसान बनाता है। एक कुंजी चयनकर्ता के साथ sort विधि का उपयोग करके, आप birthDate क्रमबद्ध कर सकते हैं:

NSArray* sortedByBirthDate = [input sort:^id(id person) {
    return [person birthDate];
}]

मैंने सभी की कोशिश की, लेकिन यह मेरे लिए काम किया। एक कक्षा में मेरे पास " crimeScene " नामक एक और वर्ग है, और " crimeScene " की संपत्ति द्वारा क्रमबद्ध करना चाहता है।

यह एक आकर्षण की तरह काम करता है:

NSSortDescriptor *sorter = [[NSSortDescriptor alloc] initWithKey:@"crimeScene.distance" ascending:YES];
[self.arrAnnotations sortUsingDescriptors:[NSArray arrayWithObject:sorter]];

मेरे मामले में, मैं सरणी को सॉर्ट करने के लिए "sortedArrayUsingComparator" का उपयोग करता हूं। नीचे दिए गए कोड को देखें।

contactArray = [[NSArray arrayWithArray:[contactSet allObjects]] sortedArrayUsingComparator:^NSComparisonResult(ContactListData *obj1, ContactListData *obj2) {
    NSString *obj1Str = [NSString stringWithFormat:@"%@ %@",obj1.contactName,obj1.contactSurname];
    NSString *obj2Str = [NSString stringWithFormat:@"%@ %@",obj2.contactName,obj2.contactSurname];
    return [obj1Str compare:obj2Str];
}];

इसके अलावा मेरी वस्तु है,

@interface ContactListData : JsonData
@property(nonatomic,strong) NSString * contactName;
@property(nonatomic,strong) NSString * contactSurname;
@property(nonatomic,strong) NSString * contactPhoneNumber;
@property(nonatomic) BOOL isSelected;
@end




nsmutablearray