HashSet에 넣을 객체의 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.Set;

public final class ConstantHashCodeCheck {
    public static void main(String[] args) {
        Set<ZeroHashKey> keys = new HashSet<>();
        for (int id = 0; id < 5; id++) {
            keys.add(new ZeroHashKey(id));
        }
        System.out.println("duplicate=" + keys.add(new ZeroHashKey(3)));
        System.out.println("size=" + keys.size());
        System.out.println("contains(4)=" + keys.contains(new ZeroHashKey(4))
                + ", contains(9)=" + keys.contains(new ZeroHashKey(9)));
    }

    private record ZeroHashKey(int id) {
        @Override
        public int hashCode() {
            return 0;
        }
    }
}

duplicate=false
size=5
contains(4)=true, contains(9)=false

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

public final class OverrideBothOrNeither {
    public static void main(String[] args) {
        Set<EqualsOnlyKey> equalsOnly = new HashSet<>();
        equalsOnly.add(new EqualsOnlyKey("A-17"));
        equalsOnly.add(new EqualsOnlyKey("A-17"));
        System.out.println("equals-only: size=" + equalsOnly.size()
                + ", contains=" + equalsOnly.contains(new EqualsOnlyKey("A-17")));

        Set<HashOnlyKey> hashOnly = new HashSet<>();
        hashOnly.add(new HashOnlyKey("A-17"));
        hashOnly.add(new HashOnlyKey("A-17"));
        System.out.println("hashCode-only: size=" + hashOnly.size()
                + ", contains=" + hashOnly.contains(new HashOnlyKey("A-17")));

        Set<MemberKey> both = new HashSet<>();
        both.add(new MemberKey("A-17"));
        both.add(new MemberKey("A-17"));
        System.out.println("both: size=" + both.size()
                + ", contains=" + both.contains(new MemberKey("A-17")));
    }

    private static final class EqualsOnlyKey {
        private final String id;

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

        @Override
        public boolean equals(Object other) {
            return other instanceof EqualsOnlyKey key && id.equals(key.id);
        }
    }

    private static final class HashOnlyKey {
        private final String id;

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

        @Override
        public int hashCode() {
            return id.hashCode();
        }
    }

    private static final class MemberKey {
        private final String id;

        private MemberKey(String id) {
            this.id = Objects.requireNonNull(id, "id");
        }

        @Override
        public boolean equals(Object other) {
            if (this == other) return true;
            return other instanceof MemberKey key && id.equals(key.id);
        }

        @Override
        public int hashCode() {
            return id.hashCode();
        }
    }
}

equals-only: size=2, contains=false
hashCode-only: size=2, contains=false
both: size=1, contains=true

lab/OverrideBothOrNeither.java:26: warning: [overrides] Class EqualsOnlyKey overrides equals, but neither it nor any superclass overrides hashCode method
    private static final class EqualsOnlyKey {
                         ^
1 warning

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;
        }
    }
}

first=true
same=false
other=true
equal=true, hash=true, size=2

private record PostKey(String category, String title) {
    PostKey {
        category = normalize(category);
        title = normalize(title);
    }

    // normalize 메서드는 앞의 코드와 같습니다.
}

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

public final class SymmetryBreakInHashSet {
    public static void main(String[] args) {
        Post post = new Post("object", 40);
        PinnedPost pinned = new PinnedPost("object", 40, 1);

        Set<Post> postFirst = new HashSet<>();
        postFirst.add(post);
        postFirst.add(pinned);

        Set<Post> pinnedFirst = new HashSet<>();
        pinnedFirst.add(pinned);
        pinnedFirst.add(post);

        System.out.println("post-first=" + postFirst.size() + ", pinned-first=" + pinnedFirst.size());
    }

    private static class Post {
        final String title;
        final int viewCount;

        Post(String title, int viewCount) {
            this.title = title;
            this.viewCount = viewCount;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof Post that)) return false;
            return viewCount == that.viewCount && title.equals(that.title);
        }

        @Override
        public int hashCode() {
            return 31 * title.hashCode() + viewCount;
        }
    }

    private static final class PinnedPost extends Post {
        final int rank;

        PinnedPost(String title, int viewCount, int rank) {
            super(title, viewCount);
            this.rank = rank;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof PinnedPost that)) return false;
            return super.equals(that) && rank == that.rank;
        }
    }
}

post-first=2, pinned-first=1

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;
        }

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

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

contains-same-reference=false
remove=false, size=1

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) {}
}

old=40
size=1
current=55

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");
            }
        }
    }
}

PostPublicationKey[category=java, publishedOn=2026-07-14, sequence=1]=accepted
PostPublicationKey[category=java, publishedOn=2026-07-14, sequence=1]=duplicate
PostPublicationKey[category=java, publishedOn=2026-07-14, sequence=2]=accepted
unique=2

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) {}
}

same-list=true
hash-changed=true

private record TagKey(List<String> tags) {
    TagKey {
        tags = List.copyOf(tags);
    }
}

same-list=false
hash-changed=false
tags=[java]

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

public final class TagLengthHash {
    public static void main(String[] args) {
        Set<Tag> tags = new HashSet<>();
        System.out.println(tags.add(new Tag("hash")));
        System.out.println(tags.add(new Tag("tree")));
        System.out.println(tags.add(new Tag("hash")));
        System.out.println("size=" + tags.size());
    }

    private static final class Tag {
        private final String name;

        Tag(String name) {
            this.name = name;
        }

        @Override
        public boolean equals(Object other) {
            return other instanceof Tag tag && name.equals(tag.name);
        }

        @Override
        public int hashCode() {
            return name.length();
        }
    }
}

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

public final class MutablePostKey {
    public static void main(String[] args) {
        Post post = new Post("hash", 10);
        Set<Post> posts = new HashSet<>();
        posts.add(post);
        post.viewCount++;
        System.out.println("contains=" + posts.contains(post));
        System.out.println("add-again=" + posts.add(post));
        System.out.println("size=" + posts.size());
    }

    private static final class Post {
        private final String title;
        private int viewCount;

        Post(String title, int viewCount) {
            this.title = title;
            this.viewCount = viewCount;
        }

        @Override
        public boolean equals(Object other) {
            return other instanceof Post that
                    && viewCount == that.viewCount
                    && title.equals(that.title);
        }

        @Override
        public int hashCode() {
            return Objects.hash(title, viewCount);
        }
    }
}