对数组中的对象使用过滤器来查找最大值？ [迅速]

Question

我有一堆对象存储在一个数组中。

他们都有属性：

distanceInSeconds: Int

我想知道是否有一种方法可以使用过滤器或其他数组方法在数组中的所有对象之间找到此属性的最大值？

例如：

var distances: [Distance] = []
var maxDistance = distances.filter(find max)

Answer 1

这将是 Swifty 方式（通过实现 Comparable）：

class Route : Comparable {
    let distance: Int

    init(distance: Int) {
        self.distance = distance
    }
}

func ==(lhs: Route, rhs: Route) -> Bool {
    return lhs.distance == rhs.distance
}

func <(lhs: Route, rhs: Route) -> Bool {
    return lhs.distance < rhs.distance
}

let routes = [
    Route(distance: 4),
    Route(distance: 8),
    Route(distance: 2),
    Route(distance: 7)
]

print(routes.maxElement()?.distance)

输出：

"8"

这适用于 Swift 2。如果您使用的是 Swift 1.2，maxElement(routes) 应该可以工作

Answer 2

在 Swift 2.0 中，minElement 和 maxElement 现在在空序列的情况下返回可选项，并且现在还有采用 isOrderedBefore 闭包的版本。

    let maxDistance = distances.maxElement { (a, b) -> Bool in
        a.distanceInSeconds < b.distanceInSeconds
    }

Answer 3

#1。序列中的元素类型符合Comparable 协议

在 Swift 4 中，如果您的序列中的元素类型符合 Comparable 协议，您将能够使用具有以下声明的 max() 方法：

func max() -> Self.Element?

返回序列中的最大元素。

用法：

class Distance: Comparable, CustomStringConvertible {

    let distanceInSeconds: Int
    var description: String { return "Distance in Int: \(distanceInSeconds)" }

    init(distanceInSeconds: Int) {
        self.distanceInSeconds = distanceInSeconds
    }

    static func ==(lhs: Distance, rhs: Distance) -> Bool {
        return lhs.distanceInSeconds == rhs.distanceInSeconds
    }

    static func <(lhs: Distance, rhs: Distance) -> Bool {
        return lhs.distanceInSeconds < rhs.distanceInSeconds
    }

}

let distances = [
    Distance(distanceInSeconds: 20),
    Distance(distanceInSeconds: 30),
    Distance(distanceInSeconds: 10)
]

let maxDistance = distances.max()
print(String(describing: maxDistance)) // prints: Optional(Distance in Int: 30)

---

#2。您的序列中的元素类型不符合Comparable 协议

在 Swift 4 中，如果序列中的元素类型不符合 Comparable 协议，则必须使用具有以下声明的 max(by:) 方法：

func max(by areInIncreasingOrder: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Element)?

返回序列中的最大元素，使用给定的谓词作为元素之间的比较。

用法：

class Distance: CustomStringConvertible {

    let distanceInSeconds: Int
    var description: String { return "Distance in Int: \(distanceInSeconds)" }

    init(distanceInSeconds: Int) {
        self.distanceInSeconds = distanceInSeconds
    }

}

let distances = [
    Distance(distanceInSeconds: 20),
    Distance(distanceInSeconds: 30),
    Distance(distanceInSeconds: 10)
]

let maxDistance = distances.max (by: { (a, b) -> Bool in
    return a.distanceInSeconds < b.distanceInSeconds
})

print(String(describing: maxDistance)) // prints: Optional(Distance in Int: 30)

Answer 4

我想你想减少：

设置：

struct Distance {
    var distanceInSeconds: Int
}

var distances: [Distance] = []
for _ in 1...10 {
    distances += [Distance(distanceInSeconds: Int(arc4random_uniform(100)))]
}

实施：

let max = distances.reduce(distances.first) {
    if let left = $0 where left.distanceInSeconds > $1.distanceInSeconds {
        return $0
    } else {
        return $1
    }
}