Collections

List<String> list = List.of("A", "B", "C", "D");
Spliterator<String> split1 = list.spliterator();
Spliterator<String> split2 = split1.trySplit(); // Splits half elements into split2

split1.forEachRemaining(System.out::println); // Processes remainder
split2.forEachRemaining(System.out::println); // Processes first partition

List<String> items = List.of("One", "Two", "Three");
// Direct collection iteration:
items.forEach(System.out:println);
// Stream pipeline iteration:
items.stream().filter(s -> s.startsWith("T")).forEach(System.out::println);

BlockingQueue<String> syncQueue = new SynchronousQueue<>();
// Producer thread will block on put() until Consumer thread calls take()
new Thread(() -> {
    try { syncQueue.put("Data Handoff"); } catch (InterruptedException e) {}
}).start();

public class DelayedTask implements Delayed {
    private final long executeTime;
    public DelayedTask(long delayInMs) {
        this.executeTime = System.currentTimeMillis() + delayInMs;
    }
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(executeTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.executeTime, ((DelayedTask) o).executeTime);
    }
}

Queue<String> queue = new LinkedList<>();
System.out.println(queue.peek()); // Returns null
System.out.println(queue.poll()); // Returns null
// queue.remove();  // Throws NoSuchElementException
// queue.element(); // Throws NoSuchElementException

String[] arr = {"A", "B"};
List<String> list1 = Arrays.asList(arr); // Fixed size, backed by arr
List<String> list2 = List.of("A", "B");     // Immutable, no nulls allowed
List<String> list3 = new ArrayList<>(List.of(arr)); // Fully mutable copy

NavigableSet<Integer> set = new TreeSet<>(List.of(10, 20, 30, 40));
System.out.println(set.lower(20));   // 10 (greatest < 20)
System.out.println(set.floor(20));   // 20 (greatest <= 20)
System.out.println(set.ceiling(25)); // 30 (smallest >= 25)
System.out.println(set.higher(30));  // 40 (smallest > 30)

public class LruCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxCapacity;
    public LruCache(int maxCapacity) {
        super(maxCapacity, 0.75f, true); // accessOrder = true
        this.maxCapacity = maxCapacity;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxCapacity; // Evicts LRU entry
    }
}

// Custom initial capacity and load factor
Map<String, String> map = new HashMap<>(32, 0.8f);

// Threshold for resizing = 32 * 0.8 = 25 entries
map.put("Key", "Value");

// Quick decision rule:
// Need key-value + Fast lookup -> HashMap
// Need Unique + Fast lookup -> HashSet
// Need Ordered sequence + Indexed access -> ArrayList
// Need FIFO queue -> ArrayDeque / LinkedList

List<Integer> numbers = new ArrayList<>(List.of(5, 2, 8, 1));
Collections.sort(numbers);
Collections.reverse(numbers);
int index = Collections.binarySearch(numbers, 5);

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

// Producer thread
queue.put("Task"); // Blocks if full

// Consumer thread
String task = queue.take(); // Blocks if empty

List<String> parent = new ArrayList<>(List.of("A", "B", "C", "D"));
List<String> sub = parent.subList(1, 3); // View containing ["B", "C"]
sub.clear(); // Removes "B" and "C" from parent list!
System.out.println(parent); // Prints ["A", "D"]

Map<Object, String> map = new WeakHashMap<>();
Object key = new Object();
map.put(key, "Cache Data");

key = null; // Key becomes eligible for GC
System.gc(); // Triggers garbage collection
// Entry will automatically disappear from WeakHashMap

enum Status { DRAFT, PENDING, PUBLISHED, ARCHIVED }

Set<Status> activeStatuses = EnumSet.of(Status.DRAFT, Status.PENDING);
Set<Status> allStatuses = EnumSet.allOf(Status.class);

Map<String, String> map = new IdentityHashMap<>();
String key1 = new String("key");
String key2 = new String("key");

map.put(key1, "Val1");
map.put(key2, "Val2");
System.out.println(map.size()); // Prints 2 because key1 != key2 by reference

List<String> immutable = List.of("A", "B", "C");
// immutable.add("D"); // Throws UnsupportedOperationException

List<String> mutable = new ArrayList<>(List.of("X", "Y"));
List<String> view = Collections.unmodifiableList(mutable);
mutable.add("Z"); // Allowed on backing collection! Modifies view too.

Deque<String> stack = new ArrayDeque<>();
stack.push("First");
stack.push("Second");

System.out.println(stack.pop()); // Returns "Second"

// Min-heap by default
Queue<Integer> pq = new PriorityQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);

System.out.println(pq.poll()); // Prints 10 (smallest element first)

List<String> list = new ArrayList<>(List.of("A", "B"));
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String val = it.next();
    // list.add("C"); // Throws ConcurrentModificationException
    it.remove(); // Valid safe removal via Iterator
}

List<String> safeList = new CopyOnWriteArrayList<>();
safeList.add("Alpha");

// Iteration never throws ConcurrentModificationException even if modified concurrently
for (String s : safeList) {
    safeList.add("Beta"); // Modifies underlying array snapshot copy
}

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// Explicit synchronization block needed when iterating
synchronized (syncList) {
    for (String item : syncList) {
        System.out.println(item);
    }
}

ConcurrentMap<String, Integer> stock = new ConcurrentHashMap<>();
// Atomic compute operation
stock.compute("Widget", (key, val) -> (val == null) ? 1 : val + 1);

List<User> users = getUsers();
// Natural order defined inside User implementing Comparable
Collections.sort(users);

// Custom order using Comparator lambda
users.sort(Comparator.comparing(User::getAge).reversed());

Set<String> hashSet = new HashSet<>(List.of("C", "A", "B")); // Order unpredictable
Set<String> linkedHashSet = new LinkedHashSet<>(List.of("C", "A", "B")); // Keeps "C", "A", "B"
Set<String> treeSet = new TreeSet<>(List.of("C", "A", "B")); // Automatically sorted: "A", "B", "C"

public class Employee {
    private int id;
    private String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee e)) return false;
        return id == e.id && Objects.equals(name, e.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

Map<String, Integer> scores = new HashMap<>();
// Internally calls String.hashCode(), calculates bucket index
scores.put("Alice", 95);
scores.put("Bob", 88);
int score = scores.get("Alice"); // O(1) average lookup

List<String> arrayList = new ArrayList<>();
arrayList.add("Item 1"); // Fast append, O(1) indexed get

List<String> linkedList = new LinkedList<>();
linkedList.add("Item 1"); // Fast head/tail operations

Collection<String> list = new ArrayList<>();
Set<String> set = new HashSet<>();
Map<String, Integer> map = new HashMap<>();

list.add("Java");
set.add("Java");
map.put("Java", 17);

// Legacy approach:
Stack<String> legacyStack = new Stack<>();

// Modern approach:
Deque<String> modernStack = new ArrayDeque<>();