Model Answer: "O(1) — constant time. Arrays provide true random access because elements are stored in contiguous memory blocks. The memory address of any element can be computed directly as `baseAddress + (index * elementSize)`. No search is needed; the calculation is a single multiplication and addition. This is the fundamental advantage arrays have over linked data structures."

Model Answer: "In Java, accessing a negative index in an array produces an `ArrayIndexOutOfBoundsException` at runtime. The JVM calculates the address as `baseAddress + (index * elementSize)`, which with a negative index produces an address before the array's memory block. The JVM detects this invalid address and throws the exception. Unlike C, Java does not allow negative indices to wrap around — bounds checking is enforced."

Model Answer: "`arr.length` is a public field (not a method) that returns the array's size — it is a property of the array itself, not a method call. `arr.length()` would be a method call, but arrays do not have a `length()` method. Strings have `length()` (a method). Collections have `size()` (a method). The asymmetry is an historical artifact of Java's design — arrays inherit their `length` field from the JVM, while the other types were designed later with proper methods."

Model Answer: "No — an `Object[]` can only hold references to objects, not primitives. Primitives are automatically boxed to their wrapper types when stored in `Object[]`. For example, `new Object[]{ 42 }` stores an `Integer`, not an `int`. Accessing the element returns a reference to the boxed `Integer`, which must then be unboxed if you need the primitive value. This boxing/unboxing has performance cost and should be avoided in tight loops."

Model Answer: "All elements of a newly created primitive array are default-initialized to zero-equivalent values: `byte`, `short`, `int`, and `long` default to `0`; `float` and `double` default to `0.0`; `char` defaults to the null character `'�'`; `boolean` defaults to `false`. This applies to instance arrays and local arrays that are created with `new` — immediately after `new int[5]`, all five slots are `0`. Local primitive variables (non-array) have no default and must be explicitly initialized."

Model Answer: "`new int[3]` creates an array of size 3 with all elements default-initialized to `0`. The `{1, 2, 3}` syntax is a compile-time array initializer — it creates a size-3 array with the specified values. Both produce `int[]` arrays, but the initializer can only be used at the point of declaration (as part of a variable declaration statement), not as a standalone expression. Java 16+ allows the form `int[] arr = new int[] {1, 2, 3}` as an expression."

Model Answer: "`Arrays.copyOf()` uses `System.arraycopy()` or equivalent native intrinsics under the hood, which copy memory in optimized native blocks — significantly faster than a Java-level loop with individual element assignments. For large arrays, the difference is substantial. Additionally, `copyOf()` handles resizing in a single call, creating a new array of the specified length and copying the minimum of old and new lengths. Always prefer `Arrays.copyOf()` for array duplication rather than writing manual copy loops."

Model Answer: "A ragged array (jagged array) is a two-dimensional array where each row has a different length — essentially an array of arrays. Create it with `int[][] ragged = new int[3][]` where each inner array is independently allocated: `ragged[0] = new int[2]; ragged[1] = new int[5]; ragged[2] = new int[3];`. This differs from a rectangular array `int[3][5]` where all rows have exactly 5 columns. Ragged arrays are useful for representing triangular matrices, sparse structures, or variable-length records."

Model Answer: "It is thrown when accessing an array with an index that is either negative or greater than or equal to the array's length. Prevention strategies: use `arr.length` in loop bounds (not hardcoded values), check index bounds before access (`if (index >= 0 && index < arr.length)`), use enhanced for-each loops when you do not need the index, and when accessing user-provided indices, always validate against `[0, arr.length)` before the access. Tools like IDE static analysis and `Arrays.rangeCheck()` (used internally) help catch these."

Model Answer: "All array types implement `Cloneable` and the `clone()` method produces a shallow copy — a new array with the same elements copied by reference for object types or copied by value for primitives. For a primitive array, `clone()` produces a completely independent copy. For an `Object[]` containing references, the new array holds the same references pointing to the same objects — modifying the objects through one array is visible through the other. Use `Arrays.copyOf()` for explicit control or deep clone logic for nested object contents."

Model Answer: "The maximum array size in Java is `Integer.MAX_VALUE` (approximately 2.1 billion elements), but practically you cannot allocate an array of that size due to heap limitations. The JVM stores arrays in heap memory and each element requires space — a `byte[Integer.MAX_VALUE]` alone needs 2GB. Attempting `new int[Integer.MAX_VALUE]` throws `OutOfMemoryError: Requested array size exceeds VM limit`. In practice, arrays larger than a few hundred million elements are rarely feasible on typical JVM configurations."

Model Answer: "`System.arraycopy()` handles overlapping regions correctly by copying elements in the appropriate direction — if the source and destination overlap and the destination is lower, it copies from high to low indices; otherwise low to high. This makes it safe to use for in-place shifts like `System.arraycopy(arr, 3, arr, 4, 5)` which moves elements at indices 3-7 to indices 4-8 without data loss. The method throws `ArrayStoreException` if source/destination types are incompatible and `IndexOutOfBoundsException` if ranges are invalid."

Model Answer: "`ByteBuffer` provides buffer-oriented IO with features arrays lack: flip (setting read/write limits), mark and reset for checkpointing, direct memory allocation (avoiding heap copy) via `ByteBuffer.allocateDirect()`, and clear/compact semantics for buffer reuse. Direct buffers can be transferred to native IO operations without JVM heap copying, improving performance for high-throughput IO channels like `FileChannel`. For standard byte arrays, you must manage index tracking and bounds manually — `ByteBuffer` encapsulates this state."

Model Answer: "A varargs parameter `String... args` is internally an array `String[]`, so `method()` can be called with zero or more `String` arguments. When you have an overload like `method(Object o)` and `method(String... args)`, passing `null` or a single `String` creates ambiguity — the compiler cannot determine whether `null` should be `String` or `Object`. This can be resolved by explicitly casting `null` to the desired type, using array syntax `method(new String[]{...})`, or redesigning the API to avoid the ambiguity."

Model Answer: "A 1D array is a contiguous memory block holding elements. A 2D array in Java is an array of arrays — the outer array holds references to inner arrays, each of which is a separate contiguous memory block. For `int[3][4]`, there are 4 separate inner arrays plus the outer array header, totaling 4+1 allocation points. This structure enables ragged arrays where inner arrays have different lengths. In C, a 2D array is a single contiguous block — Java's representation is more flexible but has indirection overhead for each inner array access."

Model Answer: "`final int[] arr = new int[5]` makes the `arr` reference immutable — `arr` cannot be reassigned to a different array after declaration. However, the contents of the array are mutable — `arr[0] = 42` is perfectly legal and modifies the element. This is the distinction between reference immutability (`final`) and data immutability (immutable array). To make the contents immutable, you would need an immutable wrapper like `Collections.unmodifiableList()` or use Java 16+ `List.of()` with array conversion, though these create new collection objects rather than protecting the array itself."

Model Answer: "`Arrays.stream(arr)` creates a `Stream` from the array — useful for functional-style pipeline operations (`filter`, `map`, `collect`). `arr.length` is a property used in traditional index-based iteration (`for i = 0; i < arr.length; i++`). The stream API provides cleaner, more declarative code for transformations and aggregations, but a simple indexed loop or enhanced for-each loop (`for (int x : arr)`) has lower overhead and is often clearer for straightforward iteration. Streams add allocation overhead for the stream object itself."

Model Answer: "No — Java arrays have fixed size determined at creation. You cannot add or remove elements. Options: (1) Create a new larger array and copy elements with `Arrays.copyOf()`, (2) Use `ArrayList` which manages resizing internally, (3) Use `java.util.stream.Stream` for functional pipelines that produce new collections. `ArrayList` internally uses an array that it reallocates when needed (typically 1.5x growth factor). If you know the approximate final size, pre-allocate with `new ArrayList<>(initialCapacity)` to avoid multiple reallocations."

Model Answer: "`Object.equals()` compares object references, not contents — two arrays with identical contents but different object references are not equal via `Object.equals()`. `Arrays.equals()` compares array contents element-by-element using each element's `equals()` method. For example, `int[] a = {1,2}; int[] b = {1,2}; Arrays.equals(a, b)` returns `true`. For multi-dimensional arrays, use `Arrays.deepEquals()` which handles nested arrays. When implementing `equals()` for a class containing an array field, use `Arrays.equals()` to compare the array contents rather than relying on the inherited `Object.equals()` reference comparison."

Model Answer: "When you store a primitive like `42` in an `Object[]`, Java automatically wraps it in an `Integer` object — autoboxing. This means `objectArray[0] = 42` stores a reference to an `Integer` object, not a primitive. The boxing overhead adds allocation and GC cost. When you retrieve and unbox (`int x = (int) objectArray[0]`), unboxing occurs. For large arrays of primitives in object collections, consider `TIntArrayList` from Trove or ` FastDoubleArrayList` to avoid boxing overhead entirely."