Why should a hash code implement the equals method?

The implementation of the equals method is necessary to ensure the correct behavior of objects in collections based on hash tables (e.g., HashSet, HashMap, NSSet, NSDictionary):

1. Violation of hashCode/equals contract: If two objects are considered equal according to equals, their hash codes returned by hashCode must be the same.
2. Search and insertion: Hash collections use hashCode to determine the bucket where an object is located or can be located. Then, equals is used to compare objects within this bucket to find the desired element or to determine uniqueness during insertion.
3. Incorrect behavior: If equals is implemented but hashCode is not (or implemented incorrectly), two equal objects may have different hash codes and end up in different buckets. This will cause collections to be unable to find or identify them as equal correctly, violating the logic of operation.
4. Implementation of == for structs: In Swift, == (and consequently Equatable) is often automatically implemented by the compiler for structs. If a struct is used in hash collections, an implementation of Hashable (which includes Equatable) is also required.

Example in Objective-C:

// Incorrect behavior without overriding hashCode/hash
@interface MyObject : NSObject
@property (nonatomic, strong) NSString *name;
@end

@implementation MyObject

- (BOOL)isEqual:(id)object {
    if (self == object) {
        return YES;
    }
    if (![object isKindOfClass:[MyObject class]]) {
        return NO;
    }
    MyObject *other = (MyObject *)object;
    return [self.name isEqualToString:other.name];
}

// Lack of hash() implementation would lead to problems in NSSet/NSDictionary
// - (NSUInteger)hash { ... }

@end

Example in Swift:

// Correct behavior thanks to Hashable implementation (includes Equatable)
struct MyStruct: Hashable {
    let name: String

    // Equatable is provided automatically
    // public static func == (lhs: MyStruct, rhs: MyStruct) -> Bool {
    //     return lhs.name == rhs.name
    // }

    // hashValue is provided automatically in most cases for structs with Hashable properties
    // public var hashValue: Int {
    //    return name.hashValue
    // }
}