Yapmak istediğim şey oldukça basit görünüyor, ancak web'de herhangi bir cevap bulamıyorum. Bir NSMutableArraynesnem var ve diyelim ki bunlar 'Kişi' nesneleri. Ben NSMutableArraybir olan Person.birthDate göre sıralamak istiyorum NSDate.

Bu yöntemle ilgisi olduğunu düşünüyorum:

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

Java'da nesnemin Karşılaştırılabilir uygulamasını gerçekleştiririm veya Collections.sort'u bir satır içi özel karşılaştırıcıyla kullanırım ... Objective-C'de bunu nasıl yapıyorsunuz?

Karşılaştırma yöntemi

Ya nesneniz için bir karşılaştırma yöntemi uygularsınız:

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

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

NSSortDescriptor (daha iyi)

veya genellikle daha iyi:

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

Diziye birden fazla anahtar ekleyerek kolayca birden çok tuşa göre sıralama yapabilirsiniz. Özel karşılaştırıcı yöntemleri kullanmak da mümkündür. Belgelere bir göz atın .

Bloklar (parlak!)

Ayrıca Mac OS X 10.6 ve iOS 4'ten beri bir blokla sıralama yapma olasılığı da vardır:

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

Verim

-compare:Ve blok temelli yöntemler kullanmak yerine, biraz daha hızlı, genel olarak olacak NSSortDescriptorikincisi KVC dayanır olarak. NSSortDescriptorYöntemin birincil avantajı, kod yerine verileri kullanarak sıralama düzeninizi tanımlamanın bir yolunu sağlamasıdır NSTableView;

NSMutableArrayYönteme bakınızsortUsingFunction:context:

İki nesne ( iki nesneyi karşılaştırdığınız için türden ) ve bir bağlam parametresi alan bir karşılaştırma işlevi ayarlamanız gerekir .PersonPerson

İki nesne sadece örnekleridir Person. Üçüncü nesne bir dizedir, örneğin @ "birthDate".

Bu işlev bir döndürür NSComparisonResult: < NSOrderedAscendingise döndürür . Bu dönecektir eğer > . Son olarak, dönecektir eğer == .PersonA.birthDatePersonB.birthDateNSOrderedDescendingPersonA.birthDatePersonB.birthDateNSOrderedSamePersonA.birthDatePersonB.birthDate

Bu kaba sahte koddur; bir tarihin başka bir tarihe "daha az", "daha fazla" veya "eşit" olmasının ne anlama geldiğini belirlemeniz gerekir (dönemden bu yana geçen saniyeleri karşılaştırma gibi):

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;
}

Daha kompakt bir şey istiyorsanız, üçlü operatörler kullanabilirsiniz:

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

Eğer çok fazla yaparsanız, satırbaşı yapmak bunu biraz hızlandırabilir.

Bunu iOS 4'te bir blok kullanarak yaptım. Kimliğimin sınıf türüne benim dizi unsurları döküm gerekiyordu. Bu durumda, puan adı verilen bir özelliğe sahip Score adında bir sınıftı.

Ayrıca dizi öğeleri doğru tip değilse ne yapacağınıza karar vermeniz gerekir, bu örnek için ben sadece döndüm NSOrderedSame, ancak benim kodda bir istisna olsa.

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;

Not: Bu azalan düzende sıralanıyor.

İOS 4'ten başlayarak sıralama için blokları da kullanabilirsiniz.

Bu özel örnek için dizinizdeki nesnelerin bir 'position' yöntemine sahip olduğunu varsayıyorum 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];

Not: "sıralanmış" dizi otomatik olarak yayınlanır.

Hepsini denedim, ama bu benim için çalıştı. Bir sınıfta " crimeScene" adında başka bir sınıfım var ve " crimeScene" özelliğine göre sıralamak istiyorum .

Bu bir cazibe gibi çalışır:

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

Georg Schölly'nin ikinci cevabında eksik bir adım var , ama o zaman iyi çalışıyor.

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

// kopyaladığım ve yapıştırdığımda zaman kaybolduğu ve sortArrayUsingDescriptors öğesinde 's' olmadan başarısız olduğu için 's' ekledi

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

Teşekkürler, iyi çalışıyor ...

Sizin Personnesneler, bir yöntem uygulamak demek gerekir compare:başka aldığı Personnesneyi ve iade NSComparisonResult2 nesneler arasındaki ilişkiye göre.

Sonra çağırır sortedArrayUsingSelector:ile@selector(compare:) ve yapılmalıdır.

Başka yollar var, ama bildiğim kadarıyla Comparablearayüzün Cocoa-equiv'si yok . Kullanmak sortedArrayUsingSelector:muhtemelen bunu yapmanın en acısız yoludur.

iOS 4 blokları sizi kurtaracak :)

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 biraz açıklama

İçin yöntemi NSMutableArraykullanın sortUsingSelector. Yeni bir örnek oluşturmadan onu sıralar.

Amacınız için aşağıdaki genel yöntemi kullanabilirsiniz. Sorununuzu çözmelidir.

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

Sadece bir diziyi sıralıyorsanız NSNumbers, bunları 1 çağrı ile sıralayabilirsiniz:

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

Bu, dizideki ( NSNumbernesneler) nesneler karşılaştır yöntemini uyguladığı için çalışır. Aynı şeyi NSStringnesneler için, hatta bir karşılaştırma yöntemi uygulayan bir dizi özel veri nesnesi için de yapabilirsiniz.

Karşılaştırma bloklarını kullanan bazı örnek kodlar: Her sözlükte "sort_key" anahtarında bir sayı bulunan bir dizi sözlük sıralar.

#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;
 }];

Yukarıdaki kod, her bir sıralama anahtarı için bir tamsayı değeri elde etme ve bunları nasıl yapacağınızı gösteren bir örnek olarak karşılaştırma işinden geçer. Yana NSNumbernesneleri karşılaştırmak yöntemi uygulamak, çok daha basit yazılabilirdi:

 #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];
 }];

veya karşılaştırıcının gövdesi 1 hatta kadar damıtılabilir:

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

Basit ifadeleri ve çok sayıda geçici değişkeni tercih etme eğilimindeyim çünkü kodun okunması daha kolay ve hata ayıklaması daha kolay. Derleyici zaten geçici değişkenleri optimize eder, bu nedenle hepsi bir arada aygıtın bir avantajı yoktur.

Linq to ObjectiveC adlı kategori yöntemleri küçük bir kütüphane oluşturdum , bu tür bir şey daha kolay hale getirir. KullanmakBir anahtar seçiciyle sıralama yönteminibirthDate aşağıdaki gibi sıralayabilirsiniz :

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

Özel gereksinime göre çok seviyeli sıralama yaptım.

// değerleri sırala

    [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

Bazı projelerimde sortUsingFunction :: kullandım :

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

Özel nesnelerle bir NSMutableArray sıralamak için NSSortDescriptor kullanın

 NSSortDescriptor *sortingDescriptor;
 sortingDescriptor = [[NSSortDescriptor alloc] initWithKey:@"birthDate"
                                       ascending:YES];
 NSArray *sortArray = [drinkDetails sortedArrayUsingDescriptors:@[sortDescriptor]];

-(NSMutableArray*) sortArray:(NSMutableArray *)toBeSorted 
{
  NSArray *sortedArray;
  sortedArray = [toBeSorted sortedArrayUsingComparator:^NSComparisonResult(id a, id b) 
  {
    return [a compare:b];
 }];
 return [sortedArray mutableCopy];
}

Sıralama NSMutableArrayçok basit:

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

NSComparator kullanarak sıralama

Özel nesneleri NSComparatorkarşılaştırmak için kullanılan özel nesneleri sıralamak istiyorsak . Blok NSComparisonResult, iki nesnenin sırasını göstermek için bir değer döndürür . Yani bütün diziyi sıralamak NSComparatoriçin aşağıdaki şekilde kullanılır.

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

NSSortDescriptor Kullanarak Sıralar
Örnek olarak, özel bir sınıfın örneklerini içeren bir dizimiz olduğunu varsayalım, Çalışanın ad, soyad ve yaş özniteliklerine sahip olduğunu varsayalım. Aşağıdaki örnek, dizi içeriğini yaş anahtarına göre artan sırada sıralamak için kullanılabilecek bir NSSortDescriptor oluşturma yöntemini gösterir.

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

Özel Karşılaştırmaları kullanarak sıralama
Adlar dizedir ve kullanıcıya sunmak için dizeleri sıraladığınızda her zaman yerelleştirilmiş bir karşılaştırma kullanmalısınız. Genellikle büyük / küçük harf duyarlı olmayan bir karşılaştırma yapmak istersiniz. Diziyi soyadına ve adına göre sıralamak için (localizedStandardCompare :) ile bir örnek gelir.

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

Referans ve ayrıntılı tartışma için lütfen bakınız: https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/SortDescriptors/Articles/Creating.html
http://www.ios-blog.co.uk/tutorials / nesnel-c / how-to-sort-NSArray-ile-özel nesneler /

Swift'in protokolleri ve fonksiyonel programlama, sınıfınızı Karşılaştırılabilir protokole uygun hale getirmenizi, protokolün gerektirdiği yöntemleri uygulamanızı ve ardından kullanmanıza gerek kalmadan sıralı bir dizi oluşturmak için sort (by:) yüksek dereceli işlevini kullanmanızı çok kolaylaştırır. bu arada değişebilir diziler.

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)

Benim durumumda, bir dizi sıralamak için "sortArrayUsingComparator" kullanın. Aşağıdaki koda bakın.

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

Ayrıca benim amacım,

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

SortDescriptor oluşturmanız ve ardından aşağıdaki gibi sortDescriptor komutunu kullanarak nsmutablearray öğesini sıralayabilirsiniz.

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

İç içe nesneler için böyle kullanın,

NSSortDescriptor * sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"lastRoute.to.lastname" ascending:YES selector:@selector(caseInsensitiveCompare:)];
NSMutableArray *sortedPackages = [[NSMutableArray alloc]initWithArray:[packages sortedArrayUsingDescriptors:@[sortDescriptor]]];

lastRoute bir nesnedir ve bu nesne to nesnesini tutar, bu nesne soyad dizesi değerlerini tutar.

Diziyi Swift'te Sıralama

İçin SwiftyKişiye aşağıda küresel hedefinden yukarıda ulaşmak için çok temiz bir tekniktir. Özel Userözniteliği bazı özniteliklere sahip bir örnek var.

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

Şimdi createdDateartan ve / veya azalan şekilde sıralamamız gereken bir dizimiz var. Tarih karşılaştırması için bir fonksiyon ekleyelim.

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
    }
}

Şimdi bir var sağlar extensionait Arrayiçin User. Basit bir deyişle, sadece içinde Usernesneler bulunan Array'ler için bazı yöntemler ekleyelim .

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
    }
}

Artan Sipariş Kullanımı

let sortedArray = someArray.sortUserByDate(.orderedAscending)

Azalan Sipariş için Kullanım

let sortedArray = someArray.sortUserByDate(.orderedAscending)

Aynı Sipariş İçin Kullanım

let sortedArray = someArray.sortUserByDate(.orderedSame)

Yukarıdaki yönteme extensionyalnızca || Arraytüründe ise erişilebilir olacaktır.[User]Array<User>

Hızlı sürüm: 5.1

Özel bir yapınız veya sınıfınız varsa ve bunları rastgele sıralamak istiyorsanız, belirttiğiniz bir alana göre sıralanan bir kapatma kullanarak sort () öğesini çağırmalısınız. Aşağıda, belirli bir özellikte sıralanan bir dizi özel yapı kullanan bir örnek verilmiştir:

    struct User {
        var firstName: String
    }

    var users = [
        User(firstName: "Jemima"),
        User(firstName: "Peter"),
        User(firstName: "David"),
        User(firstName: "Kelly"),
        User(firstName: "Isabella")
    ]

    users.sort {
        $0.firstName < $1.firstName
    }

Sıralanmış bir diziyi yerine sıralamak yerine döndürmek istiyorsanız, sort () öğesini şu şekilde kullanın:

    let sortedUsers = users.sorted {
        $0.firstName < $1.firstName
    }

  let sortedUsers = users.sorted {
    $0.firstName < $1.firstName
 }

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(@"===============================");