제네릭 Set과 재해시

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

public final class RawSetHeapPollutionFailure {
    public static void main(String[] args) {
        Set<String> typed = new HashSet<>();
        typed.add("hash");
        Set raw = typed;
        raw.add(100);
        for (String value : typed) {
            System.out.println(value.toUpperCase());
        }
    }
}

java.lang.ClassCastException

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;

public final class GenericMyHashSet {
    public static void main(String[] args) {
        MySet<String> set = new HashMySet<>(4);
        System.out.println(set.add("hash"));
        System.out.println(set.add(new String("hash")));
        System.out.println(set.add("set"));
        System.out.println(set.add("bucket"));
        System.out.println("contains=" + set.contains("set") + ", size=" + set.size());
        for (String value : set) {
            System.out.println(value);
        }
    }

    private interface MySet<E> extends Iterable<E> {
        boolean add(E value);

        boolean contains(E value);

        boolean remove(E value);

        int size();
    }

    private static final class HashMySet<E> implements MySet<E> {
        private static final double MAX_LOAD = 0.75;
        private List<E>[] buckets;
        private int size;

        @SuppressWarnings("unchecked")
        HashMySet(int capacity) {
            if (capacity <= 0) throw new IllegalArgumentException("capacity");
            buckets = (List<E>[]) new List<?>[capacity];
            initialize(buckets);
        }

        public boolean add(E value) {
            Objects.requireNonNull(value, "value");
            if (contains(value)) return false;
            if ((size + 1.0) / buckets.length > MAX_LOAD) resize(buckets.length * 2);
            bucket(value).add(value);
            size++;
            return true;
        }

        public boolean contains(E value) {
            Objects.requireNonNull(value, "value");
            return bucket(value).contains(value);
        }

        public boolean remove(E value) {
            Objects.requireNonNull(value, "value");
            boolean removed = bucket(value).remove(value);
            if (removed) size--;
            return removed;
        }

        public int size() {
            return size;
        }

        private List<E> bucket(E value) {
            return buckets[Math.floorMod(value.hashCode(), buckets.length)];
        }

        @SuppressWarnings("unchecked")
        private void resize(int capacity) {
            List<E>[] old = buckets;
            buckets = (List<E>[]) new List<?>[capacity];
            initialize(buckets);
            for (List<E> bucket : old) {
                for (E value : bucket) {
                    bucket(value).add(value);
                }
            }
        }

        private static <E> void initialize(List<E>[] target) {
            for (int i = 0; i < target.length; i++) {
                target[i] = new ArrayList<>();
            }
        }

        public Iterator<E> iterator() {
            return new Iterator<>() {
                private int bucketIndex;
                private int elementIndex;

                public boolean hasNext() {
                    advanceEmptyBuckets();
                    return bucketIndex < buckets.length;
                }

                public E next() {
                    if (!hasNext()) throw new NoSuchElementException();
                    return buckets[bucketIndex].get(elementIndex++);
                }

                private void advanceEmptyBuckets() {
                    while (bucketIndex < buckets.length
                            && elementIndex >= buckets[bucketIndex].size()) {
                        bucketIndex++;
                        elementIndex = 0;
                    }
                }
            };
        }
    }
}

HashMySet<String> set = new HashMySet<>(4);
set.add("hash");
set.add("set");
set.add("bucket");
System.out.println("before=" + set.size() + "/" + set.buckets.length);
System.out.println("fourth=" + set.add("key"));
System.out.println("after=" + set.size() + "/" + set.buckets.length);
System.out.println("kept=" + (set.contains("hash") && set.contains("set")
        && set.contains("bucket") && set.contains("key")));

record CollisionKey(int id) {
    public int hashCode() { return -7; }
}
HashMySet<CollisionKey> set = new HashMySet<>(4);
for (int id = 1; id <= 4; id++) set.add(new CollisionKey(id));
System.out.println("capacity=" + set.buckets.length + ", size=" + set.size());
System.out.println("duplicate=" + set.add(new CollisionKey(1)) + ", size=" + set.size());
System.out.println("missing=" + set.remove(new CollisionKey(9)) + ", size=" + set.size());
System.out.println("removed=" + set.remove(new CollisionKey(2)) + ", size=" + set.size());
System.out.println("kept=" + (set.contains(new CollisionKey(1))
        && set.contains(new CollisionKey(3)) && set.contains(new CollisionKey(4))));

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

public final class PublicationSetService {
    public static void main(String[] args) {
        PublicationService service = new PublicationService(new HashSet<>());
        System.out.println(service.publish(new PostKey("java", "hash")));
        System.out.println(service.publish(new PostKey("java", "hash")));
        System.out.println(service.publish(new PostKey("java", "set")));
        System.out.println("count=" + service.count());
    }

    private static final class PublicationService {
        private final Set<PostKey> published;

        private PublicationService(Set<PostKey> published) {
            this.published = Set.copyOf(published);
        }

        String publish(PostKey key) {
            Set<PostKey> mutable = new HashSet<>(published);
            return mutable.add(key) ? "new" : "already";
        }

        int count() {
            return published.size();
        }
    }

    private record PostKey(String category, String title) {}
}