equals·hashCode 계약

import java.util.HashSet;
import java.util.Set;

public final class IdentityBasedKeyDuplicate {
    public static void main(String[] args) {
        Set<MemberKey> keys = new HashSet<>();
        keys.add(new MemberKey("A-17"));
        keys.add(new MemberKey("A-17"));
        System.out.println("size=" + keys.size());
    }

    private static final class MemberKey {
        private final String id;

        private MemberKey(String id) {
            this.id = id;
        }
    }
}

size=2

import java.util.HashSet;
import java.util.Locale;
import java.util.Set;

public final class PostKeyHashContract {
    public static void main(String[] args) {
        PostKey first = PostKey.of("Java", "Hash Set");
        PostKey same = PostKey.of(" java ", "hash set");
        PostKey other = PostKey.of("Spring", "hash set");
        Set<PostKey> keys = new HashSet<>();
        System.out.println("first=" + keys.add(first));
        System.out.println("same=" + keys.add(same));
        System.out.println("other=" + keys.add(other));
        System.out.println(
                "equal="
                        + first.equals(same)
                        + ", hash="
                        + (first.hashCode() == same.hashCode())
                        + ", size="
                        + keys.size());
    }

    private record PostKey(String category, String title) {
        static PostKey of(String category, String title) {
            return new PostKey(normalize(category), normalize(title));
        }

        private static String normalize(String value) {
            if (value == null) throw new IllegalArgumentException("null key part");
            String normalized = value.strip().toLowerCase(Locale.ROOT);
            if (normalized.isEmpty()) throw new IllegalArgumentException("blank key part");
            return normalized;
        }
    }
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public final class MutableHashKeyLookupBug {
    public static void main(String[] args) {
        MutableKey key = new MutableKey("hash");
        Set<MutableKey> keys = new HashSet<>();
        keys.add(key);
        key.title = "set";
        System.out.println("contains-same-reference=" + keys.contains(key));
        System.out.println("remove=" + keys.remove(key) + ", size=" + keys.size());
    }

    private static final class MutableKey {
        private String title;

        private MutableKey(String title) {
            this.title = title;
        }

        public boolean equals(Object other) {
            return this == other
                    || other instanceof MutableKey key && Objects.equals(title, key.title);
        }

        public int hashCode() {
            return Objects.hash(title);
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public final class StableKeyDetailUpdate {
    public static void main(String[] args) {
        Map<Key, Integer> views = new HashMap<>();
        Key stored = new Key("java", 1);
        views.put(stored, 40);
        Key same = new Key("java", 1);
        System.out.println("old=" + views.put(same, 55));
        System.out.println("size=" + views.size());
        System.out.println("current=" + views.get(stored));
    }

    private record Key(String category, int sequence) {}
}

import java.util.ArrayList;
import java.util.List;

public final class RecordComponentAlias {
    public static void main(String[] args) {
        List<String> tags = new ArrayList<>(List.of("java"));
        TagKey key = new TagKey(tags);
        int before = key.hashCode();
        tags.add("set");
        System.out.println("same-list=" + (key.tags() == tags));
        System.out.println("hash-changed=" + (before != key.hashCode()));
    }

    private record TagKey(List<String> tags) {}
}

import java.time.LocalDate;
import java.util.LinkedHashSet;
import java.util.Set;

public final class PostPublicationKeyCli {
    public static void main(String[] args) {
        Set<PostPublicationKey> seen = new LinkedHashSet<>();
        PostPublicationKey key = new PostPublicationKey("java", LocalDate.of(2026, 7, 14), 1);
        register(seen, key);
        register(seen, new PostPublicationKey("java", LocalDate.of(2026, 7, 14), 1));
        register(seen, new PostPublicationKey("java", LocalDate.of(2026, 7, 14), 2));
        System.out.println("unique=" + seen.size());
    }

    private static void register(Set<PostPublicationKey> seen, PostPublicationKey key) {
        System.out.println(key + "=" + (seen.add(key) ? "accepted" : "duplicate"));
    }

    private record PostPublicationKey(String category, LocalDate publishedOn, int sequence) {
        private PostPublicationKey {
            if (category == null || category.isBlank() || publishedOn == null || sequence <= 0) {
                throw new IllegalArgumentException("invalid key");
            }
        }
    }
}