[Swift]实现Swift的两个协议：Hashable协议和Equatable协议（Type does not conform to protocol 'Hashable'）

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/ ）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10815581.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

【Command 】+【鼠标右键】-> 【Jump to Definition】

Hashable协议：

public protocol Hashable : Equatable {

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    var hashValue: Int { get }

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: Never call `finalize()` on `hasher`. Doing so may become a
    ///   compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    func hash(into hasher: inout Hasher)
}

翻译版本：

public protocol Hashable : Equatable {
    ///散列值。
    //
    ///不能保证哈希值在不同的
    ///你的程序。不要保存哈希值以在将来执行时使用。
    //
    ///-重要提示：“hashvalue”被弃用为“hashable”要求。到
    ///符合“hashable”，改为实现“hash（into:）”要求。

    var hashValue: Int { get }

    ///通过将此值的基本组件放入
    ///给定哈希。
    //
    ///实现此方法以符合“hashable”协议。这个
    ///用于散列的组件必须与比较的组件相同
    ///在类型的`=`运算符实现中。调用'hasher.combine（:）`
    ///每个组件。
    //
    ///-重要提示：不要在“hasher”上调用“finalize（）”。这样做可能会成为
    ///将来出现编译时错误。
    //
    ///-参数散列器：组合组件时要使用的散列器
    ///此实例的。

    func hash(into hasher: inout Hasher)
}

Equatable 协议：

/// A type-erased hashable value.

///

/// The `AnyHashable` type forwards equality comparisons and hashing operations

/// to an underlying hashable value, hiding its specific underlying type.

///

/// You can store mixed-type keys in dictionaries and other collections that

/// require `Hashable` conformance by wrapping mixed-type keys in

/// `AnyHashable` instances:

///

///     let descriptions: [AnyHashable: Any] = [

///         AnyHashable("😄"): "emoji",

///         AnyHashable(42): "an Int",

///         AnyHashable(Int8(43)): "an Int8",

///         AnyHashable(Set(["a", "b"])): "a set of strings"

///     ]

///     print(descriptions[AnyHashable(42)]!)      // prints "an Int"

///     print(descriptions[AnyHashable(43)])       // prints "nil"

///     print(descriptions[AnyHashable(Int8(43))]!) // prints "an Int8"

///     print(descriptions[AnyHashable(Set(["a", "b"]))]!) // prints "a set of strings"

public struct AnyHashable {



​    /// Creates a type-erased hashable value that wraps the given instance.

​    ///

​    /// The following example creates two type-erased hashable values: `x` wraps

​    /// an `Int` with the value 42, while `y` wraps a `UInt8` with the same

​    /// numeric value. Because the underlying types of `x` and `y` are

​    /// different, the two variables do not compare as equal despite having

​    /// equal underlying values.

​    ///

​    ///     let x = AnyHashable(Int(42))

​    ///     let y = AnyHashable(UInt8(42))

​    ///

​    ///     print(x == y)

​    ///     // Prints "false" because `Int` and `UInt8` are different types

​    ///

​    ///     print(x == AnyHashable(Int(42)))

​    ///     // Prints "true"

​    ///

​    /// - Parameter base: A hashable value to wrap.

​    public init<H>(_ base: H) where H : Hashable



​    /// The value wrapped by this instance.

​    ///

​    /// The `base` property can be cast back to its original type using one of

​    /// the casting operators (`as?`, `as!`, or `as`).

​    ///

​    ///     let anyMessage = AnyHashable("Hello world!")

​    ///     if let unwrappedMessage = anyMessage.base as? String {

​    ///         print(unwrappedMessage)

​    ///     }

​    ///     // Prints "Hello world!"

​    public var base: Any { get }



​    public static func != (lhs: AnyHashable, rhs: AnyHashable) -> Bool

}



extension AnyHashable : Equatable {



​    /// Returns a Boolean value indicating whether two type-erased hashable

​    /// instances wrap the same type and value.

​    ///

​    /// Two instances of `AnyHashable` compare as equal if and only if the

​    /// underlying types have the same conformance to the `Equatable` protocol

​    /// and the underlying values compare as equal.

​    ///

​    /// The following example creates two type-erased hashable values: `x` wraps

​    /// an `Int` with the value 42, while `y` wraps a `UInt8` with the same

​    /// numeric value. Because the underlying types of `x` and `y` are

​    /// different, the two variables do not compare as equal despite having

​    /// equal underlying values.

​    ///

​    ///     let x = AnyHashable(Int(42))

​    ///     let y = AnyHashable(UInt8(42))

​    ///

​    ///     print(x == y)

​    ///     // Prints "false" because `Int` and `UInt8` are different types

​    ///

​    ///     print(x == AnyHashable(Int(42)))

​    ///     // Prints "true"

​    ///

​    /// - Parameters:

​    ///   - lhs: A type-erased hashable value.

​    ///   - rhs: Another type-erased hashable value.

​    public static func == (lhs: AnyHashable, rhs: AnyHashable) -> Bool

}



extension AnyHashable : Hashable {



​    /// The hash value.

​    public var hashValue: Int { get }



​    /// Hashes the essential components of this value by feeding them into the

​    /// given hasher.

​    ///

​    /// - Parameter hasher: The hasher to use when combining the components

​    ///   of this instance.

​    public func hash(into hasher: inout Hasher)

}



extension AnyHashable : CustomStringConvertible {



​    /// A textual representation of this instance.

​    ///

​    /// Calling this property directly is discouraged. Instead, convert an

​    /// instance of any type to a string by using the `String(describing:)`

​    /// initializer. This initializer works with any type, and uses the custom

​    /// `description` property for types that conform to

​    /// `CustomStringConvertible`:

​    ///

​    ///     struct Point: CustomStringConvertible {

​    ///         let x: Int, y: Int

​    ///

​    ///         var description: String {

​    ///             return "(\(x), \(y))"

​    ///         }

​    ///     }

​    ///

​    ///     let p = Point(x: 21, y: 30)

​    ///     let s = String(describing: p)

​    ///     print(s)

​    ///     // Prints "(21, 30)"

​    ///

​    /// The conversion of `p` to a string in the assignment to `s` uses the

​    /// `Point` type's `description` property.

​    public var description: String { get }

}



extension AnyHashable : CustomDebugStringConvertible {



​    /// A textual representation of this instance, suitable for debugging.

​    ///

​    /// Calling this property directly is discouraged. Instead, convert an

​    /// instance of any type to a string by using the `String(reflecting:)`

​    /// initializer. This initializer works with any type, and uses the custom

​    /// `debugDescription` property for types that conform to

​    /// `CustomDebugStringConvertible`:

​    ///

​    ///     struct Point: CustomDebugStringConvertible {

​    ///         let x: Int, y: Int

​    ///

​    ///         var debugDescription: String {

​    ///             return "(\(x), \(y))"

​    ///         }

​    ///     }

​    ///

​    ///     let p = Point(x: 21, y: 30)

​    ///     let s = String(reflecting: p)

​    ///     print(s)

​    ///     // Prints "(21, 30)"

​    ///

​    /// The conversion of `p` to a string in the assignment to `s` uses the

​    /// `Point` type's `debugDescription` property.

​    public var debugDescription: String { get }

}



extension AnyHashable : CustomReflectable {



​    /// The custom mirror for this instance.

​    ///

​    /// If this type has value semantics, the mirror should be unaffected by

​    /// subsequent mutations of the instance.

​    public var customMirror: Mirror { get }

}



/// A type that can be hashed into a `Hasher` to produce an integer hash value.

///

/// You can use any type that conforms to the `Hashable` protocol in a set or as

/// a dictionary key. Many types in the standard library conform to `Hashable`:

/// Strings, integers, floating-point and Boolean values, and even sets are

/// hashable by default. Some other types, such as optionals, arrays and ranges

/// automatically become hashable when their type arguments implement the same.

///

/// Your own custom types can be hashable as well. When you define an

/// enumeration without associated values, it gains `Hashable` conformance

/// automatically, and you can add `Hashable` conformance to your other custom

/// types by implementing the `hash(into:)` method. For structs whose stored

/// properties are all `Hashable`, and for enum types that have all-`Hashable`

/// associated values, the compiler is able to provide an implementation of

/// `hash(into:)` automatically.

///

/// Hashing a value means feeding its essential components into a hash function,

/// represented by the `Hasher` type. Essential components are those that

/// contribute to the type's implementation of `Equatable`. Two instances that

/// are equal must feed the same values to `Hasher` in `hash(into:)`, in the

/// same order.

///

/// Conforming to the Hashable Protocol

/// ===================================

///

/// To use your own custom type in a set or as the key type of a dictionary,

/// add `Hashable` conformance to your type. The `Hashable` protocol inherits

/// from the `Equatable` protocol, so you must also satisfy that protocol's

/// requirements.

///

/// The compiler automatically synthesizes your custom type's `Hashable` and

/// requirements when you declare `Hashable` conformance in the type's original

/// declaration and your type meets these criteria:

///

/// - For a `struct`, all its stored properties must conform to `Hashable`.

/// - For an `enum`, all its associated values must conform to `Hashable`. (An

///   `enum` without associated values has `Hashable` conformance even without

///   the declaration.)

///

/// To customize your type's `Hashable` conformance, to adopt `Hashable` in a

/// type that doesn't meet the criteria listed above, or to extend an existing

/// type to conform to `Hashable`, implement the `hash(into:)` method in your

/// custom type.

///

/// In your `hash(into:)` implementation, call `combine(_:)` on the provided

/// `Hasher` instance with the essential components of your type. To ensure

/// that your type meets the semantic requirements of the `Hashable` and

/// `Equatable` protocols, it's a good idea to also customize your type's

/// `Equatable` conformance to match.

///

/// As an example, consider a `GridPoint` type that describes a location in a

/// grid of buttons. Here's the initial declaration of the `GridPoint` type:

///

///     /// A point in an x-y coordinate system.

///     struct GridPoint {

///         var x: Int

///         var y: Int

///     }

///

/// You'd like to create a set of the grid points where a user has already

/// tapped. Because the `GridPoint` type is not hashable yet, it can't be used

/// in a set. To add `Hashable` conformance, provide an `==` operator function

/// and implement the `hash(into:)` method.

///

///     extension GridPoint: Hashable {

///         static func == (lhs: GridPoint, rhs: GridPoint) -> Bool {

///             return lhs.x == rhs.x && lhs.y == rhs.y

///         }

///

///         func hash(into hasher: inout Hasher) {

///             hasher.combine(x)

///             hasher.combine(y)

///         }

///     }

///

/// The `hash(into:)` method in this example feeds the grid point's `x` and `y`

/// properties into the provided hasher. These properties are the same ones

/// used to test for equality in the `==` operator function.

///

/// Now that `GridPoint` conforms to the `Hashable` protocol, you can create a

/// set of previously tapped grid points.

///

///     var tappedPoints: Set = [GridPoint(x: 2, y: 3), GridPoint(x: 4, y: 1)]

///     let nextTap = GridPoint(x: 0, y: 1)

///     if tappedPoints.contains(nextTap) {

///         print("Already tapped at (\(nextTap.x), \(nextTap.y)).")

///     } else {

///         tappedPoints.insert(nextTap)

///         print("New tap detected at (\(nextTap.x), \(nextTap.y)).")

///     }

///     // Prints "New tap detected at (0, 1).")

public protocol Hashable : Equatable {



​    /// The hash value.

​    ///

​    /// Hash values are not guaranteed to be equal across different executions of

​    /// your program. Do not save hash values to use during a future execution.

​    ///

​    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To

​    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.

​    var hashValue: Int { get }



​    /// Hashes the essential components of this value by feeding them into the

​    /// given hasher.

​    ///

​    /// Implement this method to conform to the `Hashable` protocol. The

​    /// components used for hashing must be the same as the components compared

​    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`

​    /// with each of these components.

​    ///

​    /// - Important: Never call `finalize()` on `hasher`. Doing so may become a

​    ///   compile-time error in the future.

​    ///

​    /// - Parameter hasher: The hasher to use when combining the components

​    ///   of this instance.

​    func hash(into hasher: inout Hasher)

}



/// The universal hash function used by `Set` and `Dictionary`.

///

/// `Hasher` can be used to map an arbitrary sequence of bytes to an integer

/// hash value. You can feed data to the hasher using a series of calls to

/// mutating `combine` methods. When you've finished feeding the hasher, the

/// hash value can be retrieved by calling `finalize()`:

///

///     var hasher = Hasher()

///     hasher.combine(23)

///     hasher.combine("Hello")

///     let hashValue = hasher.finalize()

///

/// Within the execution of a Swift program, `Hasher` guarantees that finalizing

/// it will always produce the same hash value as long as it is fed the exact

/// same sequence of bytes. However, the underlying hash algorithm is designed

/// to exhibit avalanche effects: slight changes to the seed or the input byte

/// sequence will typically produce drastic changes in the generated hash value.

///

/// - Note: Do not save or otherwise reuse hash values across executions of your

///   program. `Hasher` is usually randomly seeded, which means it will return

///   different values on every new execution of your program. The hash

///   algorithm implemented by `Hasher` may itself change between any two

///   versions of the standard library.

public struct Hasher {



​    /// Creates a new hasher.

​    ///

​    /// The hasher uses a per-execution seed value that is set during process

​    /// startup, usually from a high-quality random source.

​    public init()



​    /// Adds the given value to this hasher, mixing its essential parts into the

​    /// hasher state.

​    ///

​    /// - Parameter value: A value to add to the hasher.

​    @inlinable public mutating func combine<H>(_ value: H) where H : Hashable



​    /// Adds the contents of the given buffer to this hasher, mixing it into the

​    /// hasher state.

​    ///

​    /// - Parameter bytes: A raw memory buffer.

​    public mutating func combine(bytes: UnsafeRawBufferPointer)



​    /// Finalizes the hasher state and returns the hash value.

​    ///

​    /// Finalizing consumes the hasher: it is illegal to finalize a hasher you

​    /// don't own, or to perform operations on a finalized hasher. (These may

​    /// become compile-time errors in the future.)

​    ///

​    /// Hash values are not guaranteed to be equal across different executions of

​    /// your program. Do not save hash values to use during a future execution.

​    ///

​    /// - Returns: The hash value calculated by the hasher.

​    public __consuming func finalize() -> Int

}

【Command 】+【鼠标右键】-> 【Show Quick Help】

可以散列到散列器中以生成整数散列值的类型。

protocol Hashable : Equatable

您可以在集合中使用任何符合哈希协议的类型，也可以将其用作字典键。标准库中的许多类型都符合hashable：字符串、整数、浮点值和布尔值，默认情况下，偶数集都是可以hashable的。当一些其他类型（如选项、数组和范围）的类型参数实现相同时，它们会自动变为可哈希类型。

您自己的自定义类型也可以是哈希类型。当您定义一个没有关联值的枚举时，它会自动获得哈希一致性，并且您可以通过实现hash（into:）方法将哈希一致性添加到其他自定义类型中。对于其存储属性都是可哈希的结构，以及对于具有所有可哈希关联值的枚举类型，编译器能够自动提供哈希（into:）的实现。

散列值意味着将其基本组件输入散列函数，由散列类型表示。基本组成部分是那些有助于类型的实现等价的部分。两个相等的实例必须以相同的顺序向哈希（in to:）中的哈希器提供相同的值。

符合哈希协议

要在集合中使用您自己的自定义类型或将其用作字典的键类型，请将哈希一致性添加到您的类型中。哈希协议继承自等价协议，因此您还必须满足该协议的要求。

当您在类型的原始声明中声明可哈希一致性并且您的类型满足以下条件时，编译器会自动合成您的自定义类型的可哈希性和要求：

对于结构，其所有存储属性都必须符合哈希表。

对于枚举，其所有关联值都必须符合哈希表。（没有关联值的枚举即使没有声明也具有哈希一致性。）

要自定义类型的哈希一致性，要在不符合上面列出的条件的类型中采用哈希，或者要扩展现有类型以符合哈希，请在自定义类型中实现哈希（in to:）方法。

在散列（into:）实现中，在提供的散列器实例上使用类型的基本组件调用combine（u:）。为了确保您的类型满足哈希和等价协议的语义要求，最好还自定义类型的等价一致性以匹配。

例如，考虑描述按钮网格中位置的网格点类型。以下是网格点类型的初始声明：

//X-Y坐标系中的点。
struct GridPoint {
      var x: Int
      var y: Int
}

您想创建一组用户已经点击的网格点。由于GridPoint类型尚不可哈希，因此不能在集合中使用。要添加哈希一致性，请提供一个==运算符函数并实现哈希（into:）方法。

extension GridPoint: Hashable {
    static func == (lhs: GridPoint, rhs: GridPoint) -> Bool {
        return lhs.x == rhs.x && lhs.y == rhs.y
    }

    func hash(into hasher: inout Hasher) {
        hasher.combine(x)
        hasher.combine(y)
    }
}

本例中的hash（into:）方法将网格点的x和y属性馈送到提供的散列器中。这些属性与在==运算符函数中用于测试相等性的属性相同。

现在，网格点符合哈希协议，您可以创建一组以前点击过的网格点。

var tappedPoints: Set = [GridPoint(x: 2, y: 3), GridPoint(x: 4, y: 1)]
let nextTap = GridPoint(x: 0, y: 1)
if tappedPoints.contains(nextTap) {
    print("Already tapped at (\(nextTap.x), \(nextTap.y)).")
} else {
    tappedPoints.insert(nextTap)
    print("New tap detected at (\(nextTap.x), \(nextTap.y)).")
}
// Prints "New tap detected at (0, 1).")

---

示例：

class Point:Hashable
{
    static func == (lhs: Point, rhs: Point) -> Bool {
        return lhs.X == rhs.X && lhs.Y == rhs.Y
    }
    
    func hash(into hasher: inout Hasher)
    {
        hasher.combine(x)
        hasher.combine(y)
    }
    
    init(_ x:Int,_ y:Int)
    {
        self.x = x
        self.y = y
    }
    
    private var x:Int = 0
    var X:Int
    {
        get{return x}
        set{x = newValue}
    }
    
    private var y:Int = 0
    var Y:Int
    {
        get{return y}
        set{y = newValue}
    }
}

点击：Playground测试

var set:Set<Point> = Set<Point>()
let point1:Point = Point(1,1)
let point2:Point = Point(2,2)
let point3:Point = Point(1,1)
print(point1 == point2)
//Print false
print(point1 == point3)
//Print true
set.insert(point1)
set.insert(point2)
set.insert(point3)
print(set)
//[__lldb_expr_66.Point, __lldb_expr_66.Point]