Map 계약과 구현

import java.util.Arrays;

public final class ParallelArrayMapBug {
    public static void main(String[] args) {
        String[] titles = {"thread", "array", "hash"};
        int[] viewCount = {70, 30, 50};
        Arrays.sort(titles);
        for (int i = 0; i < titles.length; i++) {
            System.out.println(titles[i] + "=" + viewCount[i]);
        }
    }
}

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

public final class TitleViewCountMap {
    public static void main(String[] args) {
        Map<String, Integer> viewCount = new HashMap<>();
        add(viewCount, "array", 30);
        add(viewCount, "hash", 50);
        add(viewCount, "array", 20);
        System.out.println("array=" + viewCount.get("array"));
        System.out.println("missing=" + viewCount.getOrDefault("queue", 0));
        for (Map.Entry<String, Integer> entry : viewCount.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

    private static void add(Map<String, Integer> viewCount, String title, int amount) {
        if (title == null || title.isBlank() || amount <= 0) throw new IllegalArgumentException();
        viewCount.merge(title, amount, Integer::sum);
    }
}

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

public final class MapMergeOverflowBoundary {
    public static void main(String[] args) {
        Map<String, Integer> raw = new HashMap<>();
        raw.put("array", Integer.MAX_VALUE);
        raw.merge("array", 1, Integer::sum);
        System.out.println("raw=" + raw.get("array"));

        Map<String, Integer> checked = new HashMap<>();
        checked.put("array", Integer.MAX_VALUE);
        try {
            checked.merge("array", 1, Math::addExact);
        } catch (ArithmeticException expected) {
            System.out.println("overflow rejected");
        }
        System.out.println("kept=" + checked.get("array"));
    }
}

import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public final class BackedMapViewAndSnapshot {
    public static void main(String[] args) {
        Map<String, Integer> counts = new LinkedHashMap<>();
        counts.put("array", 40);
        counts.put("hash", 40);
        Set<String> keys = counts.keySet();
        Collection<Integer> values = counts.values();
        System.out.println("values-before=" + values.size());
        System.out.println("removed=" + keys.remove("array"));
        System.out.println("map=" + counts.size() + ", values=" + values.size());
        Map<String, Integer> snapshot = Map.copyOf(counts);
        counts.put("queue", 55);
        System.out.println("live=" + keys.size() + ", snapshot=" + snapshot.size());
        try {
            snapshot.put("new", 10);
        } catch (UnsupportedOperationException expected) {
            System.out.println("snapshot write rejected");
        }
    }
}

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public final class MapImplementationOrder {
    public static void main(String[] args) {
        compare("hash", new HashMap<>());
        compare("linked", new LinkedHashMap<>());
        compare("tree", new TreeMap<>());
    }

    private static void compare(String name, Map<String, Integer> map) {
        map.put("thread", 70);
        map.put("array", 30);
        map.put("hash", 50);
        map.put("array", 40);
        System.out.println(name + " size=" + map.size() + " keys=" + map.keySet());
        System.out.println(name + " array=" + map.get("array"));
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

public final class PostRepository {
    public static void main(String[] args) {
        Repository repository = new Repository();
        repository.save(new Entry(1, "map", 45));
        repository.save(new Entry(2, "queue", 55));
        System.out.println(repository.find(2));
        System.out.println("snapshot=" + repository.snapshot());
    }

    private static final class Repository {
        private final Map<Integer, Entry> entries = new LinkedHashMap<>();

        void save(Entry entry) {
            if (entries.putIfAbsent(entry.id(), entry) != null)
                throw new IllegalArgumentException("duplicate id");
        }

        Entry find(int id) {
            Entry found = entries.get(id);
            if (found == null) throw new java.util.NoSuchElementException("id=" + id);
            return found;
        }

        Map<Integer, Entry> snapshot() {
            return Map.copyOf(entries);
        }
    }

    private record Entry(int id, String title, int viewCount) {}
}