Java Arrays Interview Questions Answers

A jagged array is a two-dimensional array where each row can have a different length. It is useful when data is not evenly distributed across rows, such as storing variable-length records. Jagged arrays help save memory and provide flexibility compared to fixed-size matrices.

A two-dimensional array in Java is declared by specifying two sets of square brackets. It can be initialized by defining the number of rows and columns, or by directly providing values. When values are known in advance, initializing the array with data makes the code easier to read and understand.

To iterate safely through a 2D or jagged array, each row’s length should be checked individually. Instead of assuming all rows have the same size, loops should rely on the length of the current row. This approach prevents index errors and works correctly for both regular and jagged arrays.

Row-wise sums are calculated by iterating through each row and adding its elements. Column-wise sums are computed by fixing a column index and iterating through all rows that contain that column. Interviewers expect awareness that column-wise operations require careful bounds checking, especially with jagged arrays.

Transposing a matrix involves converting rows into columns and columns into rows. This is done by swapping indices while copying elements into a new matrix. A key constraint is that transposition works cleanly only for rectangular matrices. For jagged arrays, transposition is not straightforward and often requires additional validation or restructuring.

Arrays are typically used when the size of the data is fixed, and performance is critical. They are simple, fast, and work well with primitive data types. ArrayLists are preferred when the size of the data is expected to change, as they handle resizing automatically and provide more flexibility for adding or removing elements.

Arrays have a fixed size that cannot be changed after creation. If more space is needed, a new array must be created, and elements must be copied. ArrayLists, on the other hand, grow dynamically. When they reach capacity, they internally create a larger array and copy elements, which makes resizing easier but adds some overhead.

Primitive arrays store values directly in memory, making them more efficient and faster. “ArrayList<Integer>” stores wrapper objects instead of raw values, which increases memory usage and adds extra processing. This difference becomes noticeable in performance-critical or large-scale operations.

An “ArrayList” can be converted to an array using built-in methods that copy its elements into a new array. Similarly, an array can be converted into an “ArrayList” by using utility methods that wrap the array into a list. Interviewers usually expect familiarity with these standard conversion approaches from the candidates.

Autoboxing is the automatic conversion of primitive values into their wrapper classes, while unboxing is the reverse process. In large loops, frequent boxing and unboxing can create unnecessary objects and slow down execution. 

The two-pointer approach is preferred when the data is sorted or can be sorted, and when constant extra space is required. Unlike hashing, it avoids additional memory usage and often results in cleaner and more efficient solutions, especially for problems involving pairs, duplicates, or comparisons from both ends.

Duplicates are removed by maintaining one pointer for the position of the next unique element and another for scanning the array. When a new value is encountered, it is placed at the next available position. This approach modifies the array directly without using extra space.

This is done by shifting non-zero elements forward as they are encountered and keeping track of the next position to fill. Once all non-zero values are placed in order, the remaining positions are filled with zeros. This preserves order and runs in linear time.

Also Read: Algorithm Interview Questions

A sliding window of size “K” is used to calculate the initial sum. As the window moves forward, the element leaving the window is subtracted, and the new element entering is added. This avoids recomputing sums repeatedly and keeps the solution efficient.

The window expands by adding elements until the condition is violated. When that happens, the window is shrunk from the left until the condition is satisfied again. This dynamic adjustment helps find the longest valid subarray without checking every possibility.

A prefix sum array is created where each index stores the sum of elements up to that point. Using this, the sum of any range can be calculated in constant time by subtracting two prefix values, making it highly efficient for repeated queries.

As the array is traversed, the current prefix sum is tracked. A hash map stores how often each prefix sum has occurred. If the difference between the current prefix sum and K exists in the map, it indicates a valid subarray. This method avoids nested loops and works in linear time.

Kadane’s Algorithm works by keeping track of the maximum sum ending at the current position and the overall maximum found so far. At each step, it decides whether to extend the existing subarray or start a new one from the current element.

The key idea is that if the running sum becomes negative, it cannot contribute positively to any future subarray. Dropping it and starting fresh always leads to a better outcome. This decision at every step ensures the correct result while keeping the solution linear and space-efficient.

You can also read: Data Structure Interview Questions

A 1D array in Java can be declared and initialized in more than one way. One approach is to define the size first and let Java assign default values. Another approach is to declare the array along with the values at the same time. The second method is often preferred when the values are already known, as it is shorter and more readable.

When an array is created using the new keyword, Java automatically assigns default values to its elements. Integer arrays are filled with zero, double arrays with 0.0, boolean arrays with false, and String arrays with null. This ensures that every element has a defined value even before manual initialization.

The length of an array is accessed using a variable called “length”, while the length of a String is obtained using the “length()” method. There is a difference between them because arrays are built-in language structures, whereas Strings are objects. Another key distinction is that an array’s length remains fixed once created, while a String’s length depends on its content.

Accessing “arr[arr.length]” results in an “ArrayIndexOutOfBoundsException”. This happens because array indexing in Java starts from zero, meaning the last valid index is always one less than the array’s length. Attempting to access an index equal to the length goes beyond the array’s valid range.

In Java, arrays are passed to methods by value, but the value passed is a reference to the array. This means that any changes made to the elements of the array inside a method are reflected outside the method as well. However, if the array reference itself is reassigned inside the method, the original array remains unchanged.

Using “new int[5]” creates an array of fixed size with all elements initialized to their default values. On the other hand, “int[ ] a = {1, 2, 3}” creates an array whose size is determined by the number of values provided and initializes it with those values. The first approach is useful when the size is known, but the values will be assigned later, while the second is ideal when the values are known at the time of creation.

An array in Java is a data structure used to store multiple values of the same data type in a single variable. It is commonly chosen when the number of elements is known in advance, and fast access to data is required. Arrays are simple to use, memory-efficient, and allow direct access to elements using an index, which makes them suitable for performance-sensitive operations.

You can also read more at: Java Interview Questions

Arrays in Java are stored in the heap memory because they are objects. The array variable itself is stored in the stack when it is a local variable, but it only holds a reference to the actual array in the heap. This separation allows arrays to be shared across methods while still being efficiently managed by Java’s memory system.

Accessing an element using “arr[i]” has a time complexity of “O(1)”. This is because arrays store elements in contiguous memory locations, allowing Java to directly calculate the memory address of any index. As a result, the time taken does not depend on the size of the array.

Inserting an element in the middle of an array takes “O(n)” time. This is because all elements after the insertion point must be shifted one position to make space for the new element. Since arrays have a fixed size, this operation becomes increasingly expensive as the array grows.

Java provides multiple ways to copy arrays, each suited for different use cases.

• The “clone()” method is simple and works well when a quick, shallow copy of the entire array is needed.
• “System.arraycopy()” is faster and more flexible, making it ideal for partial copies or performance-critical code.
• “Arrays.copyOf()” is often preferred for readability and when resizing an array, as it creates a new array with the desired length.

Arrays can lead to performance issues if they are resized frequently, as resizing requires creating a new array and copying elements. Excessive copying of large arrays can also impact memory and execution time. Another common pitfall is unnecessary boxing and unboxing when using wrapper types instead of primitive arrays, which adds overhead and reduces performance.

Common mistakes include incorrect calculation of the middle index, which can cause overflow in large arrays, and improper handling of start and end boundaries. Another frequent error is applying binary search on an unsorted array, leading to incorrect results.

Binary search is an efficient searching technique that repeatedly divides the search space in half. Arrays.binarySearch() can only be used when the array is already sorted in ascending order. If the array is unsorted, the result is unreliable, which is a common point interviewers look for.

Conceptually, “Arrays.sort()” arranges elements in a defined order using optimized sorting algorithms provided by Java. For primitive arrays, it uses a highly efficient algorithm designed for speed and low memory usage, with an average time complexity of “O(n log n)”. For object arrays, a stable sorting approach is used to maintain the order of equal elements.

To sort an array in descending order, the data is first sorted in ascending order and then reversed, or a custom comparison rule is applied when working with objects. Interviewers usually expect awareness that direct descending sorting is not supported for primitive arrays without additional steps.

Sorting a 2D array by a specific column involves comparing rows based on the values in that column. This is typically done by applying a custom comparison logic while sorting the array of rows. Care must be taken to ensure the column index exists for all rows, especially when working with irregular data.

The missing number is found by comparing the expected sum of numbers from 1 to N with the actual sum of the array. The difference gives the missing value. This method is simple and runs in linear time.

This can be done by keeping track of two variables while scanning the array once. As each element is checked, the largest and second-largest values are updated accordingly. This avoids sorting and keeps the solution efficient.

The array can be reversed by swapping elements from the start and end, moving inward until all elements are exchanged. This approach uses constant extra space and runs in linear time.

Rotation is handled by adjusting “K” using the array length and then rearranging elements. A common approach is to reverse parts of the array in steps. Interviewers look for solutions that avoid repeated shifting.

Here,

• “K” should always be reduced using modulo with array length to avoid unnecessary rotations.
• Left and right rotations are mirror problems; one can be converted into the other.
• Reversal-based rotation works in-place and avoids extra memory.

This prevents timeouts caused by repeated shifting.

With extra space, a hash-based structure is used to track seen elements. Without extra space, sorting or index-based marking techniques are applied. Interviewers often check whether the candidate understands the space-time trade-off.

So basically,

• Hashing works for any value range but uses extra memory.
• In-place approaches depend on constraints like values being in a fixed range or the array being mutable.
• Sorting changes the original order, which may or may not be allowed.

The approach must match the problem constraints.

The array is traversed while tracking elements that have already appeared. The first element whose value is seen again is identified, along with its index. The emphasis is on detecting repetition early.

The majority element is found using a voting-based approach that cancels out different elements. If a majority exists, it remains at the end. Interviewers often follow up by asking why this method works.

Hence,

• The voting method only guarantees a candidate, not verification.
• A second pass may be required to confirm the candidate actually appears more than “n/2 times”.
• If no majority exists, the result should be handled explicitly.

This avoids incorrect assumptions.

Two pointers are used, one for each array. The smaller element is added to the result, and the corresponding pointer moves forward. This continues until all elements are merged in sorted order.

The union includes all unique elements from both arrays, while the intersection includes only common elements. This is commonly solved using hashing or pointer-based techniques if the arrays are sorted.

A hash-based approach is used to store visited elements and check whether the required complement exists. This allows the problem to be solved in linear time. Interviewers may ask whether indices or just existence is required.

Here,

• Hashing gives “O(n) time” but uses extra space.
• If the array is sorted, a two-pointer approach can solve it without extra memory.
• When returning indices, care must be taken to store original positions.

This clarifies solution choices.

Both the maximum and minimum product ending at each index are tracked. This is necessary because a negative number can turn a small product into a large one. This problem tests careful handling of edge cases.

In this,

• Tracking both max and min products is mandatory due to negative numbers.
• Zero resets the running product.
• Initial values should be set carefully to handle all-negative arrays.

These details prevent wrong results.

The idea is to track the minimum price seen so far and calculate profit at each step. The maximum profit is updated whenever a better selling opportunity appears. Only one transaction is allowed.

Here,

• The buy must happen before the sell.
• Only one transaction is allowed in this version.
• Profit is zero if prices always decrease.

This avoids overcomplicating the logic.

Binary search is used to locate the point where the sorted order breaks. This reduces the search space efficiently and runs faster than a linear scan.

In this, 

• If the array is already sorted, the first element is the minimum.
• Binary search works because at least one half is always sorted.
• Mid comparison logic must avoid infinite loops.

Kadane’s Algorithm is used to find the maximum sum. To print the subarray, start and end indices are tracked whenever the running sum is reset or updated. Interviewers expect clarity on index handling here.

Here,

• Reset the running sum when it becomes negative.
• Track start index when resetting the sum.
• Update result indices only when a new maximum is found.
• Works even when all elements are negative if initialized correctly.

The solution depends on constraints such as order preservation and count balance. Typically, elements are separated first and then placed alternately. Interviewers often test how constraints affect the final approach.

You can click on Coding Interview Questions for more practice through topic-wise questions!