Java Collections: interface, implementation và cách chọn

Ví dụ chạy được · SequencedCheck.java

Quan sát reverse view của một ArrayList: đổi phần tử đầu của view làm đổi phần tử cuối list gốc. Kết quả cần thấy: PASS: reversed view.

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

public class SequencedCheck {
    public static void main(String[] args) {
        List<String> original = new ArrayList<>(List.of("A", "B", "C"));
        List<String> reversed = original.reversed(); // Java 21
        if (!reversed.equals(List.of("C", "B", "A"))) {
            throw new AssertionError("Unexpected encounter order");
        }
        reversed.set(0, "Z"); // View writes through to this ArrayList
        if (!original.equals(List.of("A", "B", "Z"))) {
            throw new AssertionError("Expected a backed view");
        }
        System.out.println("PASS: reversed view");
    }
}

Chạy với JDK 21: javac --release 21 SequencedCheck.java rồi java SequencedCheck.

Ví dụ chạy được · SetEqualityCheck.java

BigDecimal minh họa hai định nghĩa equality: equals xét cả scale, còn compareTo so giá trị số. Kết quả: PASS: HashSet=2, TreeSet=1; đây là khác biệt semantics, không phải mất dữ liệu ngẫu nhiên. [R15]

import java.math.BigDecimal;
import java.util.HashSet;
import java.util.List;
import java.util.TreeSet;

public class SetEqualityCheck {
    public static void main(String[] args) {
        var a = new BigDecimal("1.0");
        var b = new BigDecimal("1.00");
        var input = List.of(a, b);
        int byEquals = new HashSet<>(input).size();
        int byComparison = new TreeSet<>(input).size();
        if (a.equals(b) || a.compareTo(b) != 0
                || byEquals != 2 || byComparison != 1) {
            throw new AssertionError("Unexpected equality semantics");
        }
        System.out.println("PASS: HashSet=2, TreeSet=1");
    }
}

Chạy với JDK 21: javac --release 21 SetEqualityCheck.java rồi java SetEqualityCheck.

Ví dụ chạy được · ConcurrentCounterCheck.java

Bốn worker cùng tăng một key bằng merge. Future.get() đợi hoàn tất và đưa lỗi worker về main. Kết quả 4000 là số increment được lập trình, không phải benchmark throughput.

import java.util.ArrayList;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ConcurrentCounterCheck {
    public static void main(String[] args) throws Exception {
        var counts = new ConcurrentHashMap<String, Integer>();
        var tasks = new ArrayList<Future<?>>();
        try (var pool = Executors.newFixedThreadPool(4)) {
            for (int worker = 0; worker < 4; worker++) {
                tasks.add(pool.submit(() -> {
                    for (int i = 0; i < 1_000; i++) {
                        counts.merge("events", 1, Integer::sum);
                    }
                }));
            }
            for (var task : tasks) {
                task.get(); // Wait, and propagate worker failures
            }
        }
        if (!Integer.valueOf(4_000).equals(counts.get("events"))) {
            throw new AssertionError("Lost updates");
        }
        System.out.println("PASS: per-key merge=4000");
    }
}

Chạy với JDK 21: javac --release 21 ConcurrentCounterCheck.java rồi java ConcurrentCounterCheck.

Ví dụ chạy được · QueuePolicyCheck.java

Queue capacity 2 được làm đầy khi chưa chạy consumer. Phần tử thứ ba phải bị từ chối sau timed offer; sau đó FIFO và priority-drain được kiểm tra riêng. Không kiểm chứng elapsed time đúng 10 ms vì scheduler có thể làm thời gian thực dài hơn.

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class QueuePolicyCheck {
    public static void main(String[] args) throws InterruptedException {
        var inbox = new ArrayBlockingQueue<String>(2);
        if (!inbox.offer("A") || !inbox.offer("B")) {
            throw new AssertionError("Expected two accepted elements");
        }
        // No consumer is running: the queue stays full.
        if (inbox.offer("C", 10, TimeUnit.MILLISECONDS)) {
            throw new AssertionError("Expected explicit overload rejection");
        }
        if (!"A".equals(inbox.take()) || !"B".equals(inbox.take())
                || inbox.poll() != null) {
            throw new AssertionError("Unexpected FIFO / empty behavior");
        }

        var priority = new PriorityQueue<>(List.of(3, 1, 2));
        var drained = new ArrayList<Integer>();
        while (!priority.isEmpty()) {
            drained.add(priority.remove()); // Not iterator traversal
        }
        if (!drained.equals(List.of(1, 2, 3))) {
            throw new AssertionError("Unexpected priority order");
        }
        System.out.println("PASS: bounded rejection, FIFO, priority drain");
    }
}

Chạy với JDK 21: javac --release 21 QueuePolicyCheck.java rồi java QueuePolicyCheck.

Ví dụ chạy được · ViewCopyCheck.java

So sánh một read-only view với shallow copy, sau đó quan sát mutable element, subList, keySet và fixed-size array view. Kết quả cần thấy: PASS: backed views and shallow copy.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

public class ViewCopyCheck {
    public static void main(String[] args) {
        var backing = new ArrayList<>(List.of("A", "B"));
        var view = Collections.unmodifiableList(backing);
        var copy = List.copyOf(backing);
        backing.set(0, "Z");
        if (!view.get(0).equals("Z") || !copy.get(0).equals("A")) {
            throw new AssertionError("View and copy must differ");
        }

        var mutableElement = new StringBuilder("A");
        var shallow = List.copyOf(List.of(mutableElement));
        mutableElement.append("!");
        if (!shallow.get(0).toString().equals("A!")) {
            throw new AssertionError("Copy is shallow, not a deep clone");
        }

        var range = backing.subList(0, 1);
        range.clear(); // Structural edit through the view is supported here
        if (!backing.equals(List.of("B"))) {
            throw new AssertionError("subList must affect the backing list");
        }

        var map = new HashMap<>(java.util.Map.of("A", 1, "B", 2));
        map.keySet().remove("A");
        if (map.containsKey("A")) {
            throw new AssertionError("keySet is backed by the map");
        }

        String[] array = {"A", "B"};
        var fixedSize = Arrays.asList(array);
        fixedSize.set(0, "Z");
        if (!array[0].equals("Z")) {
            throw new AssertionError("Arrays.asList must write through");
        }
        System.out.println("PASS: backed views and shallow copy");
    }
}

Chạy với JDK 21: javac --release 21 ViewCopyCheck.java rồi java ViewCopyCheck.

Ví dụ chạy được · IteratorModesCheck.java

Kiểm tra xóa bằng iterator hợp lệ, snapshot của COW và weak iteration. Cố ý không assert key B có xuất hiện trong weak iterator; việc chạy ra một kết quả không biến nó thành guarantee.

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

public class IteratorModesCheck {
    public static void main(String[] args) {
        var ordinary = new ArrayList<>(List.of(1, 2, 3));
        var editable = ordinary.iterator();
        while (editable.hasNext()) {
            if (editable.next() == 2) {
                editable.remove(); // Mutate via this iterator
            }
        }
        if (!ordinary.equals(List.of(1, 3))) {
            throw new AssertionError("Iterator removal failed");
        }

        var listeners = new CopyOnWriteArrayList<>(List.of("A", "B"));
        var snapshot = listeners.iterator();
        listeners.add("C");
        var seen = new ArrayList<String>();
        snapshot.forEachRemaining(seen::add);
        if (!seen.equals(List.of("A", "B"))) {
            throw new AssertionError("Expected the old snapshot");
        }

        var shared = new ConcurrentHashMap<String, Integer>();
        shared.put("A", 1);
        var weak = shared.keySet().iterator();
        shared.put("B", 2);
        weak.forEachRemaining(key -> {
            if (!key.equals("A") && !key.equals("B")) {
                throw new AssertionError("Unknown key");
            }
        });
        // Deliberately do not assert whether B was observed.
        System.out.println("PASS: iterator removal, snapshot, weak iteration");
    }
}

Chạy với JDK 21: javac --release 21 IteratorModesCheck.java rồi java IteratorModesCheck.