Objective c 目标C-获取具有最大属性值的对象

我有一节汽车课。它有一个叫做enginePower的属性。另一方面，我有一个NSArray，其中包含50多个汽车对象。如何选择发动机功率最高但同时小于给定值的汽车。更清楚地说：

BMW X5-345 hp
Audi A3-200 hp
BMW 525i -225 hp
VW Passat CC-175 hp
.....

---

现在，从这一系列汽车中，当我要一辆最高发动机功率低于320的汽车时，它应该给我宝马525i。是否有可能实现。我的意思是，有没有一种简单易行的方法，或者它需要很多行代码？

使用engine power属性对数组进行排序，然后在数组中循环，直到找到一个大于指定值的

enginePower

值。然后在

currentArrayIndex-1

中获取对象的值

您可以在

NSMutableArray

上使用

-compareUsingSelector:

或在

NSArray

上使用选择器：（将返回一个新的、已排序的、自动删除的数组）来完成此操作

您可以在

Car

类上创建一个名为

-compareAngingInPower:

的方法，该方法将另一个

Car

对象作为参数

---

然后，您可以比较两个

enginePower

属性，并返回

SensorDeredName

、

SensorDeredAscending

或

SensorDeredAscending

使用engine power属性对阵列进行排序，然后在数组中循环，直到找到大于指定值的

enginePower

值。然后在

currentArrayIndex-1

中获取对象的值

您可以在

NSMutableArray

上使用

-compareUsingSelector:

或在

NSArray

上使用选择器：（将返回一个新的、已排序的、自动删除的数组）来完成此操作

您可以在

Car

类上创建一个名为

-compareAngingInPower:

的方法，该方法将另一个

Car

对象作为参数

---

然后，您可以比较这两个

enginePower

属性，并返回

sensorderedsame

、

sensorderedescing

或

sensorderedescing

中的一个属性，@Jasarien提供的答案可以很好地工作，但如果您想避免编写代码循环，您可以尝试以下方法：

- (Car *)getHighestPowerFromCars:(NSArray *)carArray atLeast:(NSNumber *)minPower {
    NSArray *descriptors = [NSArray arrayWithObject:[NSSortDescriptor sortDescriptorWithKey:@"enginePower" ascending:NO]];
    NSArray *sortedArray = [carArray sortedArrayUsingDescriptors:descriptors];
    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"enginePower >= %@", minPower];
    NSArray *filteredArray = [sortedArray filteredArrayUsingPredicate:predicate];
    return [filteredArray objectAtIndex:0];
}

---

@Jasarien提供的答案很好，但如果您不想编写循环代码，可以尝试以下方法：

- (Car *)getHighestPowerFromCars:(NSArray *)carArray atLeast:(NSNumber *)minPower {
    NSArray *descriptors = [NSArray arrayWithObject:[NSSortDescriptor sortDescriptorWithKey:@"enginePower" ascending:NO]];
    NSArray *sortedArray = [carArray sortedArrayUsingDescriptors:descriptors];
    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"enginePower >= %@", minPower];
    NSArray *filteredArray = [sortedArray filteredArrayUsingPredicate:predicate];
    return [filteredArray objectAtIndex:0];
}

---

通过阵列进行简单迭代，只查看功率限制以下的车辆，并选择功率最高的车辆：

— (Car *)getHighestPowerFromCars:(NSArray *)carArray lessThan:(NSNumber *)maxPower
{
    NSNumber* highest = nil;
    Car* highestCar = nil;

    for (Car* car in carArray)
    {
        NSNumber* power = car.enginePower;
        if ([power compare:maxPower] == NSOrderedAscending])
        {
            if (highest == nil || [power compare:highest] == NSOrderedDescending])
            {
                highest = power;
                highestCar = car;
            }
        }
    }

    return highestCar;
}

但是没有任何理由真正说明enginePower应该是NSNumber，而不是double。假设功率从不为负：

— (Car *)getHighestPowerFromCars:(NSArray *)carArray lessThan:(double)maxPower
{
    double highestPower = -1.0;
    Car* highestCar = nil;

    for (Car* car in carArray)
    {
        double power = car.enginePower;

        if (power < maxPower && power > highestPower))
        {
            highestPower = power;
            highestCar = car;
        }
    }

    return highestCar;
}

-（Car*）从cars获得最大功率：（NSArray*）carArray小于：（double）最大功率
{
双高功率=-1.0；
汽车*最高汽车=零；
适用于（汽车*卡拉里的汽车）
{
双功率=汽车发动机功率；
if（功率<最大功率和最大功率>最高功率））
{
最高权力=权力；
最高汽车=汽车；
}
}
返回最高的汽车；
}

---

但是排序和谓词的速度太快了…

通过数组直接迭代，只查看功率限制以下的车辆，然后选择功率最高的车辆：

— (Car *)getHighestPowerFromCars:(NSArray *)carArray lessThan:(NSNumber *)maxPower
{
    NSNumber* highest = nil;
    Car* highestCar = nil;

    for (Car* car in carArray)
    {
        NSNumber* power = car.enginePower;
        if ([power compare:maxPower] == NSOrderedAscending])
        {
            if (highest == nil || [power compare:highest] == NSOrderedDescending])
            {
                highest = power;
                highestCar = car;
            }
        }
    }

    return highestCar;
}

但是没有任何理由真正说明enginePower应该是NSNumber，而不是double。假设功率从不为负：

— (Car *)getHighestPowerFromCars:(NSArray *)carArray lessThan:(double)maxPower
{
    double highestPower = -1.0;
    Car* highestCar = nil;

    for (Car* car in carArray)
    {
        double power = car.enginePower;

        if (power < maxPower && power > highestPower))
        {
            highestPower = power;
            highestCar = car;
        }
    }

    return highestCar;
}

-（Car*）从cars获得最大功率：（NSArray*）carArray小于：（double）最大功率
{
双高功率=-1.0；
汽车*最高汽车=零；
适用于（汽车*卡拉里的汽车）
{
双功率=汽车发动机功率；
if（功率<最大功率和最大功率>最高功率））
{
最高权力=权力；
最高汽车=汽车；
}
}
返回最高的汽车；
}

---

但是排序和谓词的速度太快了…

看起来它会按幂顺序对所有汽车进行排序，但OP希望从功率小于标称值的汽车子集中选择一辆汽车。看起来它会按幂顺序对所有汽车进行排序，但是OP希望从功率小于标称值的汽车子集中选择一辆汽车。看。看。我会使用提供的工具称为“直接”，而不是微型和过早优化。我会使用提供的工具称为“直接”，而不是微型和过早优化。