Arrays

An array's length is set when you create it and can never change. To grow, you either create a bigger array and copy the elements over, or use a class like ArrayList that does that copying for you.

You can write the brackets after the type, like int[] a, or after the variable name, like int a[]. Both declare an array of ints and behave identically. The first style is preferred in Java.

You read the public length field, like a.length (no parentheses). It tells you how many elements the array has. It is fixed for the array's lifetime and you cannot change it.

Use new with the element type and a length, like new int[5]. This allocates an array of 5 ints on the heap. The length is fixed for the array's lifetime, and you fill the slots by index afterwards.

java.util.Arrays is a helper class full of static methods for arrays: it can sort, search, fill, copy, compare, print, and turn an array into a list or stream. You call them like Arrays.sort(a) without creating an Arrays object.

An array has a fixed size set when you create it and can hold primitives or objects. An ArrayList grows and shrinks automatically and only holds objects. Use an array for a known fixed count; use an ArrayList when the size changes.

A Java 2D array is an array whose elements are themselves arrays (an array of arrays). Java has no single block of rows-by-columns; each row is a separate array object, so rows can even have different lengths.

System.arraycopy copies a range of elements from one array to another. You pass the source array, where to start reading, the destination array, where to start writing, and how many elements to copy.

ArrayStoreException is a runtime error thrown when you try to store an element into an array whose real component type can't hold it — for example storing an Integer into a String[] that you accessed through an Object[] reference.

Every element is automatically set to a default: 0 for numbers, false for boolean, the null character for char, and null for objects. So new int[3] is [0,0,0] and new String[3] is three nulls.

Arrays.binarySearch quickly finds a value in a sorted array. The array MUST already be sorted, or results are wrong. If found, it returns the index. If not found, it returns a negative number: -(insertionPoint) - 1.

Generics are invariant: List<String> is not a List<Object>, so a bad store is caught at compile time. Arrays are covariant, so the same kind of bad store compiles and only fails at runtime with ArrayStoreException.

Arrays.asList wraps an array as a List, but it's a fixed-size view backed by the array: you can't add or remove (those throw), and changes write through to the array. Also, asList(int[]) gives a List<int[]> with one element, not a List<Integer>; use a boxed Integer[] or a stream.

Covariance means that if String is a subtype of Object, then String[] is treated as a subtype of Object[]. So you can assign a String[] to an Object[] variable and Java accepts it at compile time.

new int[3][4] allocates every level and fills all cells with 0. new int[3][] allocates only the outer array, leaving each row null until you assign it. You may leave trailing dimensions empty but not skip an earlier one.

An out-of-bounds exception almost always means a bug in your index logic, not a normal situation. So instead of catching it, fix the loop or validate the index up front so the bad access never happens.

You can create and fill an array in one step with braces, like int[] a = {1, 2, 3};. The length comes from the number of values. The bare {1,2,3} form only works at declaration; elsewhere you must write new int[]{1,2,3}.

Arrays.copyOf makes a new array of a chosen length, copying the original and padding with defaults (0/null/false) if longer, or cutting off if shorter. copyOfRange copies a slice [from, to). Both make a shallow copy: object elements are shared, not cloned.

Arrays.equals compares two arrays one element at a time, but for arrays of arrays it only checks if the inner arrays are the same object. Arrays.deepEquals goes inside nested arrays and compares their contents too. Same idea for toString (one level) vs deepToString (nested).

Arrays.asList gives a fixed-size list backed by the array, so add/remove throws and changes write through to the array. Passing a primitive array like int[] to asList makes a one-element List of the array, not a list of ints. To get a real resizable list, wrap it: new ArrayList<>(Arrays.asList(...)).

Both give O(1) access by index. Appending to an ArrayList is usually O(1) but occasionally has to grow and copy everything, which is slow; averaged out it's still cheap ('amortized O(1)'). Inserting or removing in the middle is O(n) for both because elements must shift. Searching by value (contains) is O(n).

An int[] stores raw numbers packed together. An ArrayList<Integer> must wrap each int in an Integer object, which adds object overhead and an extra pointer per element, and costs CPU for boxing and unboxing. So it uses several times more memory and is slower.

Loop the outer array with a.length, and for each row loop with that row's own a[i].length. Using a single fixed width or assuming rows are non-null causes out-of-bounds errors or NullPointerExceptions.

A jagged array is a 2D array whose rows have different lengths. Because Java's 2D arrays are arrays of arrays, you just create the outer array first, then assign each row its own length.

Arrays.copyOf allocates a brand-new array of the size you ask for and uses System.arraycopy internally to fill it. Use copyOf when you want a fresh array; use arraycopy when you already have the destination and want to copy into a specific spot.

Each array access includes a tiny check that the index is valid, which costs a compare-and-branch. The JIT compiler often proves the index is always safe (for example in a normal for loop) and removes the check, so well-written loops pay almost nothing.

Arrays.sort orders an array ascending in place. For objects it's a stable merge-style sort and you can pass a Comparator for custom order; for primitives it's an unstable quicksort and there's no comparator. Arrays.stream turns an array into a stream for map/filter/reduce; parallelSort sorts using multiple threads.

Arrays are covariant: a String[] can be used as an Object[], so storing the wrong type compiles but fails at runtime with ArrayStoreException. Generics are invariant: a List<String> is not a List<Object>, so the bad assignment is caught by the compiler instead.

Java's 2D array scatters each row as a separate heap object, so reaching an element needs an extra pointer hop and gives worse cache locality. For hot numeric code you can flatten to one 1D array and index as data[i*cols+j] for contiguous, cache-friendly access.