Collections

List<Integer> list = List.of(1, 2, 3, 4, 5);
List<Integer> evenSquares = list.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .collect(Collectors.toList());

SequencedCollection<String> seq = new ArrayList<>(List.of("A", "B", "C"));
System.out.println(seq.getFirst()); // "A"
System.out.println(seq.getLast());  // "C"
SequencedCollection<String> rev = seq.reversed(); // Reversed view

Map<Object, String> weakMap = new WeakHashMap<>();
Object keyObj = new Object();
weakMap.put(keyObj, "Cached Metadata");

keyObj = null; // Key is now weakly reachable
System.gc();   // GC will clear the entry from weakMap

Map<String, String> map = new IdentityHashMap<>();
String s1 = new String("key");
String s2 = new String("key");
map.put(s1, "Val1");
map.put(s2, "Val2");
System.out.println(map.size()); // Prints 2 because s1 != s2 by reference

Map<String, List<String>> map = new HashMap<>();
// Efficient lazy initialization:
map.computeIfAbsent("Java", k -> new ArrayList<>()).add("Spring");

BlockingQueue<String> syncQ = new SynchronousQueue<>();
// Producer thread put() blocks until Consumer thread calls take()

PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder()); // Max-heap
pq.offer(10);
pq.offer(30);
pq.offer(20);
System.out.println(pq.poll()); // Retrieves 30 (highest value first)

List<String> mutable = new ArrayList<>(Arrays.asList("A", null));
List<String> view = Collections.unmodifiableList(mutable);
mutable.add("B"); // Modifies backing list and view!

// List<String> immutable = List.of("A", null); // Throws NullPointerException

Deque<String> stack = new ArrayDeque<>();
stack.push("A");
stack.push("B");
System.out.println(stack.pop()); // Returns "B"

Set<String> set1 = new HashSet<>(List.of("B", "A", "C"));      // Unordered
Set<String> set2 = new LinkedHashSet<>(List.of("B", "A", "C"));// Insertion order: B, A, C
Set<String> set3 = new TreeSet<>(List.of("B", "A", "C"));      // Sorted order: A, B, C

List<String> listeners = new CopyOnWriteArrayList<>();
listeners.add("Listener1");

// Safe concurrent traversal without ConcurrentModificationException
for (String l : listeners) {
    System.out.println(l);
}

// Simplified JDK HashSet implementation concept:
public class SimpleHashSet<E> {
    private transient HashMap<E, Object> map = new HashMap<>();
    private static final Object PRESENT = new Object();

    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }
}

List<Emp> emps = getEmployees();
// Natural order (Comparable):
Collections.sort(emps);

// Custom order (Comparator lambda):
emps.sort(Comparator.comparing(Emp::getSalary).reversed());

List<String> arrayList = new ArrayList<>(); // Fast lookup & iteration
List<String> linkedList = new LinkedList<>(); // Doubly-linked nodes

ConcurrentMap<String, Integer> map = new ConcurrentHashMap<>();
// Thread-safe atomic update operation
map.compute("counter", (k, v) -> (v == null) ? 1 : v + 1);

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

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

class MutableKey {
    int val;
    MutableKey(int val) { this.val = val; }
    public int hashCode() { return val; }
}

MutableKey key = new MutableKey(10);
Map<MutableKey, String> map = new HashMap<>();
map.put(key, "Data");
key.val = 20; // Mutates hash code!
System.out.println(map.get(key)); // Returns null (lost entry)

Map<BadHashKey, String> map = new HashMap<>();
// When 8 keys result in the exact same bucket index, the bucket treeifies
for (int i = 0; i < 10; i++) {
    map.put(new BadHashKey(i), "Value" + i);
}

List<String> list = new ArrayList<>(List.of("A", "B"));
// Triggers ConcurrentModificationException:
for (String item : list) {
    if (item.equals("A")) list.remove(item);
}

// Safe approach using Iterator:
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("A")) it.remove();
}