使用围绕NSUUID的包装类作为密钥的散列问题

Question

**重写**

好吧，原来我问的是另一个问题。我了解hashValue和==，所以这与此无关。

我希望我的包装类BUUID“做正确的事情”，就像NSUUID在字典中的行为一样。

看下面，他们不在的地方。

import Foundation
class BUUID: NSObject {
    init?(str: String) {
        if let uuid = NSUUID(UUIDString: str) {
            _realUUID = uuid
        }
        else {
            return nil
        }
    }

    override init() {
        _realUUID = NSUUID()
    }

    private var _realUUID: NSUUID

    override var description: String { get { return _realUUID.UUIDString } }
    override var hashValue: Int { get { return _realUUID.hashValue } }
    var UUIDString: String { get { print("WARNING Use description or .str instead"); return _realUUID.UUIDString } }
    var str: String { get { return _realUUID.UUIDString } }
}
func ==(lhs: BUUID, rhs: BUUID) -> Bool { return lhs._realUUID == rhs._realUUID }

let a = BUUID()
let b = BUUID(str: a.str)!
print("a: \(a)\nb: \(b)")
print("a === b: \(a === b)")
print("a == b: \(a == b)")

var d = [a: "Hi"]
print("\(d[a]) \(d[b])")


let nA = NSUUID()
let nB = NSUUID(UUIDString: nA.UUIDString)!
print("na: \(nA)\nnB: \(nB)")
print("nA === nB: \(nA === nB)")
print("nA == nB: \(nA == nB)")

var nD = [nA: "Hi"]
print("\(nD[nA]) \(nD[nB])")

结果。请注意，我可以使用NSUUID nB查找并取回我在nA下所放的内容。我的BUUID就不是这样了。

a: 9DE6FE91-D4B5-4A6B-B912-5AAF34DB41C8
b: 9DE6FE91-D4B5-4A6B-B912-5AAF34DB41C8
a === b: false
a == b: true
Optional("Hi") nil

nA: <__NSConcreteUUID 0x7fa193c39500> BB9F9851-93CF-4263-B98A-5015810E4286
nB: <__NSConcreteUUID 0x7fa193c37dd0> BB9F9851-93CF-4263-B98A-5015810E4286
nA === nB: false 
nA == nB: true
Optional("Hi") Optional("Hi")

Answer 1

从NSObject继承还假定isEqual(object: AnyObject?) -> Bool方法重载：

import Foundation
class BUUID: NSObject {
    init?(str: String) {
        if let uuid = NSUUID(UUIDString: str) {
            _realUUID = uuid
        }
        else {
            return nil
        }
    }

    override init() {
        _realUUID = NSUUID()
    }

    private var _realUUID: NSUUID

    override func isEqual(object: AnyObject?) -> Bool {
        guard let buuid = object as? BUUID else {
            return false
        }

        return buuid._realUUID == _realUUID
    }
    override var description: String { get { return _realUUID.UUIDString } }
    override var hashValue: Int { get { return _realUUID.hashValue } }
    var UUIDString: String { get { print("WARNING Use description or .str instead"); return _realUUID.UUIDString } }
    var str: String { get { return _realUUID.UUIDString } }
}
func ==(lhs: BUUID, rhs: BUUID) -> Bool { return lhs._realUUID == rhs._realUUID }

let a = BUUID()
let b = BUUID(str: a.str)!
print("a: \(a)\nb: \(b)")
print("a === b: \(a === b)")
print("a == b: \(a == b)")

var d = [a: "Hi"]
print("\(d[a]) \(d[b])")


let nA = NSUUID()
let nB = NSUUID(UUIDString: nA.UUIDString)!
print("na: \(nA)\nnB: \(nB)")
print("nA === nB: \(nA === nB)")
print("nA == nB: \(nA == nB)")

var nD = [nA: "Hi"]
print("\(nD[nA]) \(nD[nB])")

Answer 2

因此，答案是不要让BUUID继承NSObject，这削弱了重写==的快速性。

所以：

extension BUUID: Hashable {}
class BUUID: CustomStringConvertible {
    // take away all 'override' keywords, nothing to override
    // otherwise same as above
}

有意思的!

Answer 3

这个答案与最初提出的问题相关:为什么可以在字典中获得两个具有相同关键字的哈希的键值对

此示例说明Dictionary中的键可以具有相同的散列，但是对于不同的键，相等操作应该返回false：

func ==(lhs: FooKey, rhs: FooKey) -> Bool {

    return unsafeAddressOf(lhs) == unsafeAddressOf(rhs)
}

class FooKey: Hashable, Equatable {

    var hashValue: Int {

        get {
            return 123
        }
    }
}

var d = Dictionary<FooKey, String>()

let key1 = FooKey()
let key2 = FooKey()

d[key1] = "value1"
d[key2] = "value2"

输出

[FooKey: "value1", FooKey: "value2"]

如果所有的键都有相同的哈希，那绝对不是好事。在这种情况下，当搜索元素复杂度降到O(n) (穷尽搜索)时，我们得到了最坏的情况。但它会成功的。