[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":86,"_72":87,"_35":88},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":62,"_64":65,"_66":67,"_68":69,"_70":71},"id",101,"title","Arrays, BitSet, and Primitives","slug","java-collections-part-5-arrays-bitset-primitives","excerpt","Explore Arrays utility class, Arrays.asList() gotchas, BitSet for memory-efficient flags, and boxing/unboxing performance considerations with primitive collections.","# Java Collections Compendium Part 5: Arrays, BitSet & Primitive Collections\n\nDiscover the performance foundations that power many Java collections. From the Arrays utility class with its essential methods to BitSet for memory-efficient boolean storage, understand when primitives outperform objects and how to leverage them effectively.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | Arrays class, primitive arrays, BitSet, memory optimization |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 1 (Framework Architecture) |\n| **Time to Master** | 3-4 hours |\n| **Interview Frequency** | High (Arrays.asList trap, primitive vs wrapper performance) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Understand Arrays.asList() gotchas and fixed-size list behavior\n2. Choose between primitive arrays and wrapper collections for performance\n3. Use BitSet for memory-efficient flag storage\n4. Leverage parallel array operations effectively\n5. Avoid common boxing/unboxing performance traps\n\n---\n\n## Production Story: The Fixed-Size List Disaster\n\n### The Incident\n\nOur recommendation engine was working perfectly in development. Then it hit production and started throwing `UnsupportedOperationException` left and right.\n\nThe error logs pointed to what seemed like innocent code:\n\n```java\n// RecommendationService.java - The problematic code\npublic List getRecommendations(User user) {\n String[] defaults = {\"popular\", \"trending\", \"new\"};\n List recommendations = Arrays.asList(defaults);\n\n // Get personalized recommendations\n List personalized = recommendationEngine.getFor(user);\n\n if (!personalized.isEmpty()) {\n recommendations.clear(); // 💥 UnsupportedOperationException!\n recommendations.addAll(personalized);\n }\n\n return recommendations;\n}\n```\n\n### Why Arrays.asList() Isn't What You Think\n\n`Arrays.asList()` doesn't return a regular `ArrayList`. It returns `java.util.Arrays$ArrayList` - a **fixed-size list backed by the original array**.\n\n```java\n// What most developers think:\nList list = Arrays.asList(\"A\", \"B\", \"C\");\n// \"This is a regular ArrayList I can modify freely\"\n\n// What actually happens:\n// Returns Arrays$ArrayList which:\n// - Does NOT support add() - throws UnsupportedOperationException\n// - Does NOT support remove() - throws UnsupportedOperationException\n// - DOES support set() - modifies underlying array!\n// - DOES reflect changes to underlying array\n```\n\nLet me show you the actual implementation:\n\n```java\n// From java.util.Arrays (simplified)\nprivate static class ArrayList extends AbstractList\n implements RandomAccess, java.io.Serializable {\n\n private final E[] a; // Backed by this array\n\n ArrayList(E[] array) {\n a = Objects.requireNonNull(array);\n }\n\n @Override\n public int size() {\n return a.length; // Fixed size!\n }\n\n @Override\n public E set(int index, E element) {\n E oldValue = a[index];\n a[index] = element; // Modifies array\n return oldValue;\n }\n\n // add() and remove() not overridden\n // AbstractList throws UnsupportedOperationException!\n}\n```\n\n### The Traps\n\n```java\nString[] array = {\"A\", \"B\", \"C\"};\nList list = Arrays.asList(array);\n\n// Trap 1: Can't add elements\nlist.add(\"D\"); // 💥 UnsupportedOperationException\n\n// Trap 2: Can't remove elements\nlist.remove(0); // 💥 UnsupportedOperationException\n\n// Trap 3: Changes to array affect list\narray[0] = \"Z\";\nSystem.out.println(list.get(0)); // Z (not A!)\n\n// Trap 4: Changes to list affect array\nlist.set(1, \"Y\");\nSystem.out.println(array[1]); // Y (not B!)\n\n// Trap 5: Primitive arrays don't work as expected\nint[] ints = {1, 2, 3};\nList wrong = Arrays.asList(ints); // List of ONE int[]!\nSystem.out.println(wrong.size()); // 1 (not 3!)\n```\n\n### The Fix\n\n```java\n// Fix 1: Create a real ArrayList (Java 8-)\nList list = new ArrayList<>(Arrays.asList(\"A\", \"B\", \"C\"));\nlist.add(\"D\"); // ✅ Works\n\n// Fix 2: Use List.of() for immutable list (Java 9+)\nList immutable = List.of(\"A\", \"B\", \"C\");\n// Clear intent: this list won't be modified\n\n// Fix 3: Use Stream for mutable list (Java 8+)\nList mutable = Stream.of(\"A\", \"B\", \"C\")\n .collect(Collectors.toCollection(ArrayList::new));\n\n// Fix 4: For primitives, use IntStream\nint[] ints = {1, 2, 3};\nList integers = IntStream.of(ints)\n .boxed()\n .collect(Collectors.toList());\n```\n\n### Impact and Lessons\n\n**Impact:**\n- 2,847 failed recommendation requests in 15 minutes\n- Users saw empty recommendation panels\n- SEO impact from error responses\n\n**Lessons Learned:**\n1. `Arrays.asList()` returns a fixed-size view, not a copy\n2. Always wrap in `new ArrayList<>()` if you need mutability\n3. Unit tests should cover add/remove operations\n4. Consider `List.of()` when immutability is acceptable\n\n---\n\n## Mental Model: Arrays as Building Blocks\n\nThink of arrays as the concrete foundation of a building:\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ JAVA COLLECTIONS BUILDING │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ 🏠 High-Level (Friendly, Feature-Rich) │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ ArrayList HashMap HashSet TreeMap LinkedList │ │\n│ │ (Resizable) (K-V) (Unique) (Sorted) (Linked) │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ ↑ │\n│ │ Built on top of │\n│ ↓ │\n│ 🧱 Low-Level (Fast, Raw, Fixed-Size) │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ Object[] int[] long[] BitSet char[] │ │\n│ │ (Objects) (Ints) (Longs) (Bits) (Chars) │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ 💾 Memory Layout: │\n│ │\n│ int[] numbers = {1, 2, 3, 4}; │\n│ ┌────┬────┬────┬────┐ │\n│ │ 1 │ 2 │ 3 │ 4 │ ← Contiguous, cache-friendly │\n│ └────┴────┴────┴────┘ │\n│ Total: 16 bytes (header) + 16 bytes (4 × 4) = 32 bytes │\n│ │\n│ Integer[] boxed = {1, 2, 3, 4}; │\n│ ┌────┬────┬────┬────┐ │\n│ │ → │ → │ → │ → │ ← References (8 bytes each) │\n│ └─┬──┴─┬──┴─┬──┴─┬──┘ │\n│ ↓ ↓ ↓ ↓ │\n│ ┌───┐┌───┐┌───┐┌───┐ ← Integer objects (~16 bytes each) │\n│ │ 1 ││ 2 ││ 3 ││ 4 │ │\n│ └───┘└───┘└───┘└───┘ │\n│ Total: 16 + 32 + (4 × 16) = ~112 bytes (3.5x more!) │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n### BitSet as Compact Boolean Storage\n\n```text\nTraditional boolean[] approach:\n┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐\n│ T │ F │ T │ T │ F │ T │ F │ F │ 8 booleans = 8 bytes\n└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘\n\nBitSet approach:\n┌─────────────────────────────────────────────────┐\n│ 1 0 1 1 0 1 0 0 │ 8 bits = 1 byte\n└─────────────────────────────────────────────────┘\n(Actually stored in long[], so minimum 8 bytes, but scales 8x better)\n```\n\n---\n\n## Deep Dive: Arrays Utility Class\n\n### Arrays.asList() - The View Pattern\n\n```java\n// Creates a fixed-size list backed by the array\nString[] array = {\"A\", \"B\", \"C\"};\nList view = Arrays.asList(array);\n\n// Changes are bidirectional\narray[0] = \"X\";\nSystem.out.println(view.get(0)); // X\n\nview.set(1, \"Y\");\nSystem.out.println(array[1]); // Y\n\n// But size is fixed\nview.add(\"Z\"); // UnsupportedOperationException\nview.remove(0); // UnsupportedOperationException\nview.clear(); // UnsupportedOperationException\n```\n\n### Arrays.copyOf() and copyOfRange()\n\n```java\nint[] original = {1, 2, 3, 4, 5};\n\n// Copy entire array\nint[] copy1 = Arrays.copyOf(original, original.length);\n\n// Copy with new size (truncate or pad with zeros)\nint[] shorter = Arrays.copyOf(original, 3); // {1, 2, 3}\nint[] longer = Arrays.copyOf(original, 8); // {1, 2, 3, 4, 5, 0, 0, 0}\n\n// Copy range (start inclusive, end exclusive)\nint[] range = Arrays.copyOfRange(original, 1, 4); // {2, 3, 4}\n\n// How ArrayList grows internally:\n// elementData = Arrays.copyOf(elementData, newCapacity);\n```\n\n### Arrays.fill() and setAll()\n\n```java\n// Fill with single value\nint[] array = new int[5];\nArrays.fill(array, 42); // {42, 42, 42, 42, 42}\n\n// Fill range\nArrays.fill(array, 1, 4, 0); // {42, 0, 0, 0, 42}\n\n// Set each element based on index (Java 8+)\nint[] sequential = new int[5];\nArrays.setAll(sequential, i -> i * 2); // {0, 2, 4, 6, 8}\n\n// Parallel version for large arrays\nint[] large = new int[1_000_000];\nArrays.parallelSetAll(large, i -> computeExpensive(i));\n```\n\n### Arrays.sort() vs parallelSort()\n\n```java\nint[] data = generateRandomArray(1_000_000);\n\n// Sequential sort (Dual-Pivot Quicksort for primitives)\nArrays.sort(data);\n\n// Parallel sort (uses ForkJoinPool, merge sort)\nArrays.parallelSort(data);\n\n// When to use parallelSort:\n// - Array size > 8192 elements (threshold in JDK)\n// - CPU-bound (not waiting on I/O)\n// - Multiple cores available\n\n// Custom comparator for objects\nString[] words = {\"banana\", \"Apple\", \"cherry\"};\nArrays.sort(words, String.CASE_INSENSITIVE_ORDER);\nArrays.parallelSort(words, String.CASE_INSENSITIVE_ORDER);\n```\n\n### Arrays.binarySearch()\n\n```java\nint[] sorted = {1, 3, 5, 7, 9, 11, 13};\n\n// Array MUST be sorted first!\nint index = Arrays.binarySearch(sorted, 7); // 3\n\n// If not found, returns (-(insertion point) - 1)\nint notFound = Arrays.binarySearch(sorted, 6); // -4\n// Insertion point would be index 3 (between 5 and 7)\n// So result is -(3) - 1 = -4\n\n// To get insertion point from negative result:\nint insertionPoint = -notFound - 1; // 3\n```\n\n### Arrays.mismatch() and compare() (Java 9+)\n\n```java\nint[] a = {1, 2, 3, 4, 5};\nint[] b = {1, 2, 3, 9, 5};\nint[] c = {1, 2, 3, 4, 5};\n\n// mismatch returns first differing index, or -1 if equal\nint mismatch = Arrays.mismatch(a, b); // 3 (differ at index 3)\nint noMismatch = Arrays.mismatch(a, c); // -1 (arrays are equal)\n\n// compare returns lexicographic comparison result\nint cmp = Arrays.compare(a, b); // negative (a < b at index 3)\n// 4 < 9, so a comes before b\n\n// Useful for implementing Comparable\n@Override\npublic int compareTo(MyClass other) {\n return Arrays.compare(this.data, other.data);\n}\n```\n\n---\n\n## Deep Dive: Primitive Arrays vs Wrapper Collections\n\n### Memory Comparison\n\n```java\n// Storing 1 million integers\n\n// Option 1: int[] - Primitive array\nint[] primitive = new int[1_000_000];\n// Memory: 16 (header) + 4 * 1,000,000 = ~4 MB\n\n// Option 2: Integer[] - Wrapper array\nInteger[] wrapper = new Integer[1_000_000];\n// Memory: 16 (header) + 8 * 1,000,000 (references) = ~8 MB\n// + 16 * 1,000,000 (Integer objects) = ~24 MB total\n\n// Option 3: ArrayList\nList list = new ArrayList<>(1_000_000);\n// Memory: ArrayList object + Object[] + Integer objects\n// Similar to Integer[] but with ArrayList overhead\n\n// Summary:\n// int[] ~4 MB (baseline)\n// Integer[] ~24 MB (6x more)\n// ArrayList ~24 MB (6x more, plus ArrayList object)\n```\n\n### Performance Comparison\n\n```java\npublic class PrimitiveVsWrapperBenchmark {\n\n static final int SIZE = 10_000_000;\n\n // Primitive array sum: ~5ms\n public long sumPrimitive(int[] array) {\n long sum = 0;\n for (int value : array) {\n sum += value;\n }\n return sum;\n }\n\n // Wrapper array sum: ~50ms (10x slower due to unboxing)\n public long sumWrapper(Integer[] array) {\n long sum = 0;\n for (Integer value : array) {\n sum += value; // Auto-unboxing on every iteration\n }\n return sum;\n }\n\n // ArrayList sum: ~60ms (slightly slower than wrapper array)\n public long sumList(List list) {\n long sum = 0;\n for (Integer value : list) {\n sum += value;\n }\n return sum;\n }\n\n // Stream primitive: ~10ms (optimized)\n public long sumStream(int[] array) {\n return IntStream.of(array).sum();\n }\n}\n```\n\n### Boxing/Unboxing Traps\n\n```java\n// Trap 1: Boxing in loops\nList list = new ArrayList<>();\nfor (int i = 0; i < 1000000; i++) {\n list.add(i); // Boxing: int -> Integer (1 million allocations!)\n}\n\n// Fix: Use IntStream and collect\nList list = IntStream.range(0, 1000000)\n .boxed()\n .collect(Collectors.toList());\n\n// Trap 2: Unnecessary unboxing\nInteger a = 100;\nInteger b = 100;\nif (a == b) { // Works due to Integer cache (-128 to 127)\n System.out.println(\"Equal\");\n}\n\nInteger c = 200;\nInteger d = 200;\nif (c == d) { // FALSE! Different objects\n System.out.println(\"Never printed\");\n}\n// Fix: Use .equals() or unbox explicitly\nif (c.equals(d)) { ... } // Or: if ((int) c == (int) d)\n\n// Trap 3: NullPointerException on unboxing\nInteger nullable = null;\nint primitive = nullable; // 💥 NullPointerException!\n```\n\n### When to Use What\n\n```text\nUse int[] / primitive arrays when:\n├── Performance is critical\n├── Memory is constrained\n├── No null values needed\n├── Simple iteration/computation\n└── Fixed size is acceptable\n\nUse List / collections when:\n├── Need dynamic sizing (add/remove)\n├── Need collection operations (stream, sort, filter)\n├── Working with APIs that require List\n├── Null values are meaningful\n└── Code readability > raw performance\n```\n\n---\n\n## Deep Dive: BitSet\n\n### BitSet Basics\n\n```java\n// BitSet uses long[] internally for storage\nBitSet bits = new BitSet();\n\n// Set individual bits\nbits.set(0); // Set bit 0 to true\nbits.set(5); // Set bit 5 to true\nbits.set(10); // Set bit 10 to true\n\nSystem.out.println(bits); // {0, 5, 10}\n\n// Clear bits\nbits.clear(5); // Set bit 5 to false\n\n// Check bits\nboolean isSet = bits.get(0); // true\nboolean notSet = bits.get(5); // false (was cleared)\n\n// Set range\nbits.set(20, 25); // Set bits 20, 21, 22, 23, 24 to true\n```\n\n### BitSet Memory Efficiency\n\n```java\n// Tracking 10,000 boolean flags\n\n// Option 1: boolean[]\nboolean[] flags = new boolean[10_000];\n// Memory: 16 (header) + 10,000 bytes = ~10 KB\n\n// Option 2: HashSet\nSet set = new HashSet<>();\n// If 50% set (5000 flags): ~200 KB (Integer objects + HashSet overhead)\n\n// Option 3: BitSet\nBitSet bitSet = new BitSet(10_000);\n// Memory: 16 (header) + ceil(10000/64) * 8 = ~1.3 KB\n\n// BitSet is 8x more memory-efficient than boolean[]\n// and ~150x more efficient than HashSet!\n```\n\n### BitSet Operations\n\n```java\nBitSet a = new BitSet();\na.set(0, 1, 2, 3); // Error - set takes int, int or single int\n\n// Set multiple bits correctly:\nBitSet a = new BitSet();\na.set(0);\na.set(1);\na.set(2);\na.set(3); // a = {0, 1, 2, 3}\n\nBitSet b = new BitSet();\nb.set(2);\nb.set(3);\nb.set(4);\nb.set(5); // b = {2, 3, 4, 5}\n\n// Union (OR)\nBitSet union = (BitSet) a.clone();\nunion.or(b); // {0, 1, 2, 3, 4, 5}\n\n// Intersection (AND)\nBitSet intersection = (BitSet) a.clone();\nintersection.and(b); // {2, 3}\n\n// Difference (AND NOT)\nBitSet difference = (BitSet) a.clone();\ndifference.andNot(b); // {0, 1}\n\n// XOR (symmetric difference)\nBitSet xor = (BitSet) a.clone();\nxor.xor(b); // {0, 1, 4, 5}\n\n// Check overlap\nboolean overlaps = a.intersects(b); // true\n```\n\n### BitSet Iteration\n\n```java\nBitSet bits = new BitSet();\nbits.set(1);\nbits.set(5);\nbits.set(10);\nbits.set(100);\n\n// Method 1: Using nextSetBit()\nfor (int i = bits.nextSetBit(0); i >= 0; i = bits.nextSetBit(i + 1)) {\n System.out.println(i); // 1, 5, 10, 100\n}\n\n// Method 2: Using stream() (Java 8+)\nbits.stream().forEach(System.out::println); // 1, 5, 10, 100\n\n// Method 3: Using nextClearBit() for unset bits\nfor (int i = bits.nextClearBit(0); i < bits.length(); i = bits.nextClearBit(i + 1)) {\n System.out.println(i); // 0, 2, 3, 4, 6, 7, 8, 9, 11, 12, ...\n}\n\n// Count set bits\nint cardinality = bits.cardinality(); // 4\n```\n\n### BitSet Use Cases\n\n```java\n// Use Case 1: Feature flags\nBitSet features = new BitSet();\nfinal int DARK_MODE = 0;\nfinal int NOTIFICATIONS = 1;\nfinal int ANALYTICS = 2;\n\nfeatures.set(DARK_MODE);\nfeatures.set(ANALYTICS);\n\nif (features.get(DARK_MODE)) {\n enableDarkMode();\n}\n\n// Use Case 2: Bloom filter (simplified)\nclass SimpleBloomFilter {\n private final BitSet bits;\n private final int size;\n\n public SimpleBloomFilter(int size) {\n this.bits = new BitSet(size);\n this.size = size;\n }\n\n public void add(String item) {\n int hash1 = Math.abs(item.hashCode()) % size;\n int hash2 = Math.abs(item.hashCode() * 31) % size;\n bits.set(hash1);\n bits.set(hash2);\n }\n\n public boolean mightContain(String item) {\n int hash1 = Math.abs(item.hashCode()) % size;\n int hash2 = Math.abs(item.hashCode() * 31) % size;\n return bits.get(hash1) && bits.get(hash2);\n }\n}\n\n// Use Case 3: Sieve of Eratosthenes\npublic static BitSet sieveOfEratosthenes(int max) {\n BitSet primes = new BitSet(max + 1);\n primes.set(2, max + 1); // Assume all prime\n\n for (int i = 2; i * i <= max; i++) {\n if (primes.get(i)) {\n for (int j = i * i; j <= max; j += i) {\n primes.clear(j); // Not prime\n }\n }\n }\n return primes; // primes.stream() gives all primes up to max\n}\n```\n\n---\n\n## Deep Dive: Parallel Array Operations\n\n### When Parallel Helps\n\n```java\nint[] data = new int[10_000_000];\nArrays.setAll(data, i -> ThreadLocalRandom.current().nextInt());\n\n// Sequential sort: ~800ms\nlong start = System.currentTimeMillis();\nint[] copy1 = Arrays.copyOf(data, data.length);\nArrays.sort(copy1);\nSystem.out.println(\"Sequential: \" + (System.currentTimeMillis() - start) + \"ms\");\n\n// Parallel sort: ~200ms (4x faster on 8 cores)\nstart = System.currentTimeMillis();\nint[] copy2 = Arrays.copyOf(data, data.length);\nArrays.parallelSort(copy2);\nSystem.out.println(\"Parallel: \" + (System.currentTimeMillis() - start) + \"ms\");\n```\n\n### parallelPrefix() - Cumulative Operations\n\n```java\nint[] numbers = {1, 2, 3, 4, 5};\n\n// Cumulative sum\nArrays.parallelPrefix(numbers, Integer::sum);\n// Result: {1, 3, 6, 10, 15}\n// Each element becomes sum of all previous elements\n\n// Reset\nnumbers = new int[]{1, 2, 3, 4, 5};\n\n// Cumulative product\nArrays.parallelPrefix(numbers, (a, b) -> a * b);\n// Result: {1, 2, 6, 24, 120} (factorials!)\n\n// Use case: Running totals, moving averages\nlong[] sales = {100, 200, 150, 300, 250};\nArrays.parallelPrefix(sales, Long::sum);\n// sales now contains running totals: {100, 300, 450, 750, 1000}\n```\n\n### Parallel Stream from Arrays\n\n```java\nint[] data = new int[10_000_000];\nArrays.fill(data, 1);\n\n// Sequential: ~50ms\nlong sum1 = Arrays.stream(data).sum();\n\n// Parallel: ~15ms\nlong sum2 = Arrays.stream(data).parallel().sum();\n\n// IntStream is more efficient than boxing to Stream\n// This creates unnecessary Integer objects:\nlong sum3 = Arrays.stream(boxedData).parallel()\n .mapToInt(Integer::intValue) // Unboxing\n .sum();\n\n// Better: Use primitive stream from start\nint[] primitiveData = ...;\nlong sum4 = IntStream.of(primitiveData).parallel().sum();\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Modifying Arrays.asList() Result\n\n```java\n// ❌ WRONG: Trying to add to fixed-size list\nList list = Arrays.asList(\"A\", \"B\", \"C\");\nlist.add(\"D\"); // 💥 UnsupportedOperationException\n\n// ✅ CORRECT: Wrap in ArrayList\nList list = new ArrayList<>(Arrays.asList(\"A\", \"B\", \"C\"));\nlist.add(\"D\"); // Works\n\n// ✅ CORRECT: Use List.of() and create new list if needed (Java 9+)\nList immutable = List.of(\"A\", \"B\", \"C\");\nList mutable = new ArrayList<>(immutable);\n```\n\n### Mistake 2: Arrays.asList() with Primitives\n\n```java\n// ❌ WRONG: Primitives don't work as expected\nint[] ints = {1, 2, 3};\nList wrong = Arrays.asList(ints);\nSystem.out.println(wrong.size()); // 1 (not 3!)\n// The list contains ONE element: the int[] itself\n\n// ✅ CORRECT: Use IntStream for boxing\nList correct = IntStream.of(ints)\n .boxed()\n .collect(Collectors.toList());\n\n// ✅ CORRECT: Use wrapper array\nInteger[] integers = {1, 2, 3};\nList works = Arrays.asList(integers); // Size 3\n```\n\n### Mistake 3: Forgetting to Sort Before binarySearch\n\n```java\nint[] data = {5, 2, 8, 1, 9};\n\n// ❌ WRONG: Array not sorted\nint index = Arrays.binarySearch(data, 8); // Undefined behavior!\n// Might return wrong index or not find the element\n\n// ✅ CORRECT: Sort first\nArrays.sort(data);\nint index = Arrays.binarySearch(data, 8); // Correct result: 3\n```\n\n### Mistake 4: Integer Comparison with ==\n\n```java\nInteger a = 127;\nInteger b = 127;\nSystem.out.println(a == b); // true (cached)\n\nInteger c = 128;\nInteger d = 128;\nSystem.out.println(c == d); // ❌ false! Different objects\n\n// ✅ CORRECT: Use equals() or unbox\nSystem.out.println(c.equals(d)); // true\nSystem.out.println((int) c == (int) d); // true\nSystem.out.println(c.intValue() == d.intValue()); // true\n```\n\n### Mistake 5: BitSet Size Confusion\n\n```java\nBitSet bits = new BitSet(100); // Initial capacity, not max value!\n\n// ❌ WRONG assumption: Can only set bits 0-99\nbits.set(200); // Works! BitSet grows automatically\nSystem.out.println(bits.size()); // 256 (rounds up to next long boundary)\n\n// size() vs length():\n// - size(): Capacity in bits (always multiple of 64)\n// - length(): Logical size (index of highest set bit + 1)\nbits.clear();\nbits.set(5);\nSystem.out.println(bits.size()); // 64 (or larger)\nSystem.out.println(bits.length()); // 6 (bit 5 is highest set)\n```\n\n---\n\n## 🐛 Debug This\n\n### Challenge 1: The Disappearing Elements\n\n```java\nString[] array = {\"A\", \"B\", \"C\"};\nList list = Arrays.asList(array);\n\nlist.set(0, \"X\");\narray[1] = \"Y\";\n\nlist.forEach(System.out::println);\nArrays.stream(array).forEach(System.out::println);\n\n// What's printed?\n```\n\n**✅ Answer:**\n\nBoth print: `X, Y, C`\n\nThe list is backed by the array, so:\n- `list.set(0, \"X\")` changes `array[0]` to \"X\"\n- `array[1] = \"Y\"` changes `list.get(1)` to \"Y\"\n\nBoth the list and array reflect all changes.\n\n### Challenge 2: The Unexpected Size\n\n```java\nint[] ints = {1, 2, 3, 4, 5};\nObject[] objects = {1, 2, 3, 4, 5};\n\nList list1 = Arrays.asList(ints);\nList list2 = Arrays.asList(objects);\n\nSystem.out.println(list1.size() + \", \" + list2.size());\n```\n\n**✅ Answer:**\n\nOutput: `1, 5`\n\n- `ints` is an `int[]` (primitive array). `Arrays.asList(ints)` treats it as a single object, creating `List` with size 1.\n- `objects` is an `Object[]`. `Arrays.asList(objects)` creates `List