दिलचस्प पोस्ट
HTML5 में शामिल फ़ाइल जावा 7 और 8 में एक विधि का अधिकतम आकार कैसे एक तत्व पर दोनों onclick और onblblick का उपयोग करने के लिए? jQuery एसवीजी बनाम रफेल CSS3 की सीमा-त्रिज्या संपत्ति और सीमा-पतन: पतन मिश्रण नहीं है। गोल कोनों के साथ एक संक्षिप्त तालिका बनाने के लिए मैं सीमा-त्रिज्या का उपयोग कैसे करूं? HTTP मूलभूत प्रमाणीकरण के लिए शुद्ध जावास्क्रिप्ट कोड? HTML.ActionLink एक बटन या एक छवि के रूप में, एक लिंक नहीं यादृच्छिक अल्फा-न्यूमेरिक स्ट्रिंग कैसे उत्पन्न करें? स्ट्रिंग के लिए XmlDocument कन्वर्ट करें C ++ में निजी विधि को कॉल करना पायथन – एक्सपोनेंट में अंकों की संख्या {x: नल} बनाम पारदर्शी? सी # में संरचना के लिए 16 बाइट की अनुशंसित आकार क्यों है? आईआईएस 7.0 के अंतर्गत क्लासिक एएसपी एप्लीकेशन काम करने के लिए मार्गदर्शन कैसे करें I WRITE_SECURE_SETTINGS अनुमति त्रुटि भी मैनिफ़ेस्ट में जोड़े जाने पर

मैं इसे कैसे कस्टम ऑब्जेक्ट के साथ एक NSMutableArray सॉर्ट कर सकता हूँ?

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

मुझे लगता है कि इस पद्धति से कुछ करना है:

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

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

Solutions Collecting From Web of "मैं इसे कैसे कस्टम ऑब्जेक्ट के साथ एक NSMutableArray सॉर्ट कर सकता हूँ?"

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

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

 - (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 को सेट करना आसान बनाता है ताकि उपयोगकर्ताओं को हेडर पंक्ति पर क्लिक करके एक NSTableView सॉर्ट कर सकें

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

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

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

यह फ़ंक्शन किसी NSComparisonResult रिटर्न देता है: यह रिटर्न NSOrderedAscending अगर PersonB.birthDatePersonA.birthDate < PersonB.birthDate यह NSOrderedDescending वापस आ NSOrderedDescending अगर PersonA.birthDate > PersonB.birthDate अंत में, यह 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 में एक ब्लॉक का उपयोग करते हुए किया। आईडी से मेरे वर्ग के प्रकार के तत्वों को डालने के लिए इस मामले में यह एक वर्ग कहा जाता था जिसे पॉइंट कहा जाता है।

इसके अलावा आपको यह तय करने की ज़रूरत है कि यदि आपके सरणी के तत्व सही प्रकार नहीं हैं, तो इस उदाहरण के लिए मैंने NSOrderedSame लौटा NSOrderedSame , हालांकि मेरे कोड में एक अपवाद है I

 NSArray *sorted = [_scores sortedArrayUsingComparator:^(id obj1, id obj2){ if ([obj1 isKindOfClass:[Score class]] && [obj2 isKindOfClass:[Score class]]) { Score *s1 = obj1; Score *s2 = obj2; if (s1.points > s2.points) { return (NSComparisonResult)NSOrderedAscending; } else if (s1.points < s2.points) { return (NSComparisonResult)NSOrderedDescending; } } // TODO: default is the same? return (NSComparisonResult)NSOrderedSame; }]; return sorted; 

पुनश्च: यह अवरोही क्रम में छंटनी है

आईओएस 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]; 

नोट: "सॉर्ट किए गए" सरणी को ऑटोरेलेज़ किया जाएगा।

मैंने सभी की कोशिश की, लेकिन यह मेरे लिए काम किया एक वर्ग में मुझे " crimeScene " नाम का एक और वर्ग है, और " crimeScene " की संपत्ति द्वारा सॉर्ट करना चाहते हैं

यह एक जादू की तरह काम करता है:

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

जॉर्ज स्कॉली के दूसरे उत्तर में एक अनुपस्थित कदम है, लेकिन यह ठीक काम करता है।

 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 रिटर्न को वापस NSComparisonResult है।

उसके बाद आप sortedArrayUsingSelector: साथ @selector(compare:) और इसे किया जाना चाहिए।

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

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

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

आईओएस 4 ब्लॉक आपको बचाएगा 🙂

 featuresArray = [[unsortedFeaturesArray sortedArrayUsingComparator: ^(id a, id b) { DMSeatFeature *first = ( DMSeatFeature* ) a; DMSeatFeature *second = ( DMSeatFeature* ) b; if ( first.quality == second.quality ) return NSOrderedSame; else { if ( eSeatQualityGreen == m_seatQuality || eSeatQualityYellowGreen == m_seatQuality || eSeatQualityDefault == m_seatQuality ) { if ( first.quality < second.quality ) return NSOrderedAscending; else return NSOrderedDescending; } else // eSeatQualityRed || eSeatQualityYellow { if ( first.quality > second.quality ) return NSOrderedAscending; else return NSOrderedDescending; } } }] retain]; 

http://sokol8.blogspot.com/2011/04/sorting-nsarray-with-blocks.html विवरण का एक सा

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

यदि आप केवल NSNumbers की एक सरणी सॉर्ट कर रहे हैं, तो आप उन्हें 1 कॉल के साथ सॉर्ट कर सकते हैं:

 [arrayToSort sortUsingSelector: @selector(compare:)]; 

यह काम करता है क्योंकि सरणी में ऑब्जेक्ट्स ( NSNumber ऑब्जेक्ट्स) तुलना विधि को लागू करते हैं। आप NSString ऑब्जेक्ट्स के लिए, या यहां तक ​​कि कस्टम डेटा ऑब्जेक्ट की एक सरणी के लिए भी ऐसा कर सकते हैं जो तुलना विधि को लागू करते हैं।

तुलनित्र ब्लॉकों का उपयोग कर यहां कुछ उदाहरण कोड है। यह ऐसे शब्दकोशों की एक सरणी है, जहां प्रत्येक शब्दकोश में एक कुंजी "sort_key" में एक संख्या शामिल है

 #define SORT_KEY @\"sort_key\" [anArray sortUsingComparator: ^(id obj1, id obj2) { NSInteger value1 = [[obj1 objectForKey: SORT_KEY] intValue]; NSInteger value2 = [[obj2 objectForKey: SORT_KEY] intValue]; if (value1 > value2) { return (NSComparisonResult)NSOrderedDescending; } if (value1 < value2) { return (NSComparisonResult)NSOrderedAscending; } return (NSComparisonResult)NSOrderedSame; }]; 

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

  #define SORT_KEY @\"sort_key\" [anArray sortUsingComparator: ^(id obj1, id obj2) { NSNumber* key1 = [obj1 objectForKey: SORT_KEY]; NSNumber* key2 = [obj2 objectForKey: SORT_KEY]; return [key1 compare: key2]; }]; 

या तुलनित्र के शरीर को भी 1 लाइन के लिए आसुत किया जा सकता है:

  return [[obj1 objectForKey: SORT_KEY] compare: [obj2 objectForKey: SORT_KEY]]; 

मैं सरल बयान और बहुत सारे अस्थायी चर को पसंद करता हूं क्योंकि कोड को पढ़ना आसान है और डिबग करना आसान है। संकलक किसी भी तरह अस्थायी चर को दूर करता है, इसलिए सभी-इन-वन-लाइन संस्करण का कोई लाभ नहीं होता है।

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

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

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

// मूल्यों को सॉर्ट करें

  [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

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

 //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]; 

मैंने अपनी कुछ परियोजनाओं में sortUsingFunction :: का उपयोग किया है:

 int SortPlays(id a, id b, void* context) { Play* p1 = a; Play* p2 = b; if (p1.score<p2.score) return NSOrderedDescending; else if (p1.score>p2.score) return NSOrderedAscending; return NSOrderedSame; } ... [validPlays sortUsingFunction:SortPlays context:nil]; 
 -(NSMutableArray*) sortArray:(NSMutableArray *)toBeSorted { NSArray *sortedArray; sortedArray = [toBeSorted sortedArrayUsingComparator:^NSComparisonResult(id a, id b) { return [a compare:b]; }]; return [sortedArray mutableCopy]; } 

सॉर्ट करना 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]; 
 NSSortDescriptor *sort = [[NSSortDescriptor alloc] initWithKey:@"_strPrice" ascending:sortFlag selector:@selector(localizedStandardCompare:)] ; 

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

अगर हम कस्टम ऑब्जेक्ट सॉर्ट करना चाहते हैं तो हमें 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/

स्विफ्ट के प्रोटोकॉल और कार्यात्मक प्रोग्रामिंग आपको बहुत आसान बनाता है कि आप अपने क्लास को तुलनात्मक प्रोटोकॉल के अनुरूप बनाना पड़े, प्रोटोकॉल के लिए आवश्यक तरीकों को लागू करें और फिर सॉर्ट किए गए ऑर्डर फ़ंक्शन को सॉर्ट किए गए सरणी का उपयोग करने के लिए बिना सॉर्ट करें रास्ते से अस्थिर arrays

 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) 

मेरे मामले में, मैं "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 *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(@"===============================");