Collections

// ArrayList: Single array object holding references
List<Integer> aList = new ArrayList<>(1000);

// LinkedList: 1000 individual Node objects on Heap!
List<Integer> lList = new LinkedList<>();

List rawList = new ArrayList<String>();
List<String> checkedList = Collections.checkedList(rawList, String.class);

// Raw reference insertion attempt throws ClassCastException immediately:
// rawList.add(123);
// checkedList.add(123); // Throws ClassCastException at insertion point!

List<String> list = List.of("A", "B");
// Modern type-safe conversion:
String[] arr = list.toArray(String[]::new);

List<String> list = List.of("apple", "banana", "apricot");
Map<Character, String> map = list.stream()
    .collect(Collectors.toMap(
        s -> s.charAt(0),
        s -> s,
        (existing, replacement) -> existing + "," + replacement // Merge function
    ));

Map<String, List<String>> multiMap = new HashMap<>();
// MultiMap insertion using computeIfAbsent:
multiMap.computeIfAbsent("CategoryA", k -> new ArrayList<>()).add("Item1");
multiMap.computeIfAbsent("CategoryA", k -> new ArrayList<>()).add("Item2");

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.replaceAll((k, v) -> v * 10); // Values become 10 and 20

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
Collections.swap(list, 0, 3); // Swaps A and D -> ["D", "B", "C", "A"]
Collections.rotate(list, 1);  // Rotates right -> ["A", "D", "B", "C"]

List<Integer> list = new ArrayList<>(List.of(10, 20, 30, 40));
Collections.sort(list); // Prerequisite
int index = Collections.binarySearch(list, 30); // Returns 2

Properties props = new Properties();
props.setProperty("db.url", "jdbc:mysql://localhost:3306/db");
props.setProperty("db.user", "admin");
String url = props.getProperty("db.url");

Hashtable<String, String> ht = new Hashtable<>();
// ht.put(null, "value"); // Throws NullPointerException!

HashMap<String, String> hm = new HashMap<>();
hm.put(null, "value"); // Allowed

Set<String> singleSet = Collections.singleton("ONLY_ITEM");
// singleSet.add("ANOTHER"); // Throws UnsupportedOperationException

public List<String> getUserRoles(User user) {
    if (user == null) {
        return Collections.emptyList(); // Avoids returning null
    }
    return user.getRoles();
}

Map<String, String> map = new HashMap<>();
map.put("a", "apple");

String val1 = map.getOrDefault("b", "banana"); // Returns "banana", map unchanged
map.putIfAbsent("b", "banana");                 // Inserts key "b" into map

Map<Integer, String> map = Map.ofEntries(
    Map.entry(1, "One"),
    Map.entry(2, "Two"),
    Map.entry(3, "Three")
);

List<String> list = List.of("A", "B", "A", "C");
int count = Collections.frequency(list, "A"); // Returns 2

boolean noCommon = Collections.disjoint(List.of("A"), List.of("X", "Y")); // Returns true

BlockingQueue<Integer> pbq = new PriorityBlockingQueue<>();
pbq.offer(50);
pq.offer(10);
System.out.println(pbq.take()); // Retrieves 10 (lowest priority value first)

ArrayList<Integer> list = new ArrayList<>();
list.ensureCapacity(10000); // Pre-allocates memory for 10k items

for (int i = 0; i < 100; i++) list.add(i);
list.trimToSize(); // Trims capacity down to 100

ArrayList<Integer> list = new ArrayList<>(10);
// When 11th element is added, capacity expands to 10 + (10 >> 1) = 15
for (int i = 0; i < 11; i++) {
    list.add(i);
}

List<String> list = new ArrayList<>(List.of("A", "B", "C"));
ListIterator<String> lit = list.listIterator();

while (lit.hasNext()) {
    if (lit.next().equals("B")) {
        lit.set("Beta"); // Replaces element at current position
    }
}

List<String> list = List.of("A", "B");
// Using Iterable interface via for-each loop:
for (String item : list) {
    System.out.println(item);
}

// Using Iterator directly:
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// Legacy Vector usage:
Vector<String> v = new Vector<>();
v.add("Legacy"); // Method is synchronized internally

// Modern replacement:
List<String> list = new ArrayList<>();

SequencedCollection<String> list = new ArrayList<>(List.of("A", "B", "C"));
System.out.println(list.getFirst()); // "A"
System.out.println(list.getLast());  // "C"
SequencedCollection<String> reversed = list.reversed(); // View in reverse order

TransferQueue<String> tQueue = new LinkedTransferQueue<>();
// In a worker thread:
// tQueue.transfer("Message"); // Blocks until another thread consumes it!

BlockingQueue<String> arrayQ = new ArrayBlockingQueue<>(100); // Fixed size array
BlockingQueue<String> linkedQ = new LinkedBlockingQueue<>(100); // Separate lock concurrency

Map<String, Integer> counts = new HashMap<>();
// Increments count if key exists, otherwise inserts 1
counts.merge("Word", 1, (oldVal, newVal) -> oldVal + newVal);

List<String> list = Stream.of("Apple", "Banana", "Cherry")
    .filter(s -> s.startsWith("B"))
    .collect(Collectors.toUnmodifiableList());
// list.add("Date"); // Throws UnsupportedOperationException

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

MutableKey key = new MutableKey(1);
Map<MutableKey, String> map = new HashMap<>();
map.put(key, "Value");
key.id = 2; // Mutates hash code!
System.out.println(map.get(key)); // Returns null!

Set<String> set1 = new HashSet<>(List.of("A", "B", "C"));
Set<String> set2 = List.of("B", "C", "D");

set1.retainAll(set2); // Intersection: set1 now contains ["B", "C"]

ConcurrentNavigableMap<Integer, String> map = new ConcurrentSkipListMap<>();
map.put(3, "Three");
map.put(1, "One");
map.put(2, "Two");
// Maintained in sorted order concurrently: 1, 2, 3

enum Day { MON, TUE, WED }
Map<Day, String> schedule = new EnumMap<>(Day.class);
schedule.put(Day.MON, "Work");
schedule.put(Day.TUE, "Training");