Java Array Coding Interview Questions (Advanced) — 10 Problems with O(n) Solutions [2026]

Introduction:

If you are preparing for a Java array coding interview, you are in the right place. Java array problems are among the most frequently tested topics at companies like Google, Amazon, Infosys, TCS, and Wipro — making them an essential part of your preparation.

This guide covers 10 advanced Java array interview problems (Q11–Q20), each with a clear problem statement, optimized logic, and a clean Java implementation. Whether you are a fresher or an experienced developer, these Java array patterns will strengthen your problem-solving skills and help you crack top company interviews in 2026.

What You Will Learn in This Guide:

• Advanced Java array coding problems asked in real interviews
• Step-by-step solutions with optimized logic
• Time and space complexity for every Java array solution
• Key patterns — sliding window, two pointers, HashMap, and in-place reversal
• A quick-reference complexity table for all 10 Java array problems

Q11. Rotate a Java Array by K Steps

Problem Statement:

Rotate a Java array to the right by k steps — a classic Java array manipulation problem that tests your ability to solve in-place without extra space.

Logic — In-Place Reversal:

• Step 1: Reverse the entire Java array
• Step 2: Reverse the first k elements
• Step 3: Reverse the remaining n–k elements

Java Code:

import java.util.Arrays;

public class RotateArray {

    public static void reverse(int[] arr, int start, int end) {

        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    public static void rotate(int[] arr, int k) {
        int n = arr.length;
        k = k % n;                  // Handle k > n
        reverse(arr, 0, n - 1);     // Step 1
        reverse(arr, 0, k - 1);     // Step 2
        reverse(arr, k, n - 1);     // Step 3
    }

    public static void main(String[] args) {

        int[] arr = {1, 2, 3, 4, 5};
        rotate(arr, 2);
        System.out.println(Arrays.toString(arr)); // Output: [4, 5, 1, 2, 3]
    }
}

Complexity:

Time: O(n)   |   Space: O(1)   |   Approach: In-place reversal

Q12. Merge Two Sorted Java Arrays

Problem Statement:

Given two sorted Java arrays, merge them into a single sorted Java array. This is a foundational problem in divide-and-conquer algorithms and appears frequently in merge sort implementations.

Logic — Two Pointers:

• Use two pointers (i, j) to compare elements from both Java arrays
• Pick the smaller element and advance that pointer
• Copy remaining elements once one pointer reaches the end

Java Code:

import java.util.Arrays;

public class MergeArrays {

    public static int[] merge(int[] a, int[] b) {
        int[] result = new int[a.length + b.length];
        int i = 0, j = 0, k = 0;
        while (i < a.length && j < b.length) {
            result[k++] = (a[i] < b[j]) ? a[i++] : b[j++];
        }

        while (i < a.length) result[k++] = a[i++];
        while (j < b.length) result[k++] = b[j++];
        return result;

    }

    public static void main(String[] args) {
        int[] a = {1, 3, 5};
        int[] b = {2, 4, 6};
        System.out.println(Arrays.toString(merge(a, b))); // [1, 2, 3, 4, 5, 6]
    }

}

Complexity:

Time: O(m + n)   |   Space: O(m + n)   |   Approach: Two pointers

Q13. Find Intersection of Two Java Arrays

Problem Statement:

Find the common elements shared between two Java arrays. This Java array question tests your understanding of HashSet for O(1) average-time lookups.

Logic — HashSet Lookup:

• Store all elements of the first Java array in a HashSet
• Iterate over the second Java array and check membership in the set
• Add matches to a result set (automatically handles duplicates)

Java Code:

import java.util.HashSet;
import java.util.Set;

public class IntersectionArray {
    public static Set<Integer> findIntersection(int[] a, int[] b) {
        Set<Integer> set = new HashSet<>();
        Set<Integer> result = new HashSet<>();
        for (int num : a) set.add(num);
        for (int num : b) {
            if (set.contains(num)) result.add(num);
        }
        return result;
    }

    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4};
        int[] b = {3, 4, 5, 6};
        System.out.println(findIntersection(a, b)); // [3, 4]
    }
}

Complexity:

Time: O(m + n)   |   Space: O(m)   |   Approach: HashSet

Q14. Find Union of Two Java Arrays

Problem Statement:

Combine two Java arrays and return only the unique elements while preserving insertion order. This Java array problem tests knowledge of set operations.

Logic — LinkedHashSet:

• Use a LinkedHashSet to store elements from both Java arrays
• Duplicates are automatically ignored by the Set contract
• LinkedHashSet preserves insertion order, unlike HashSet

Java Code:

import java.util.LinkedHashSet;
import java.util.Set;

public class UnionArray {
    public static Set<Integer> findUnion(int[] a, int[] b) {
        Set<Integer> set = new LinkedHashSet<>();
        for (int num : a) set.add(num);
        for (int num : b) set.add(num);
        return set;
    }

    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = {3, 4, 5};
        System.out.println(findUnion(a, b)); // [1, 2, 3, 4, 5]
    }
}

Complexity:

Time: O(m + n)   |   Space: O(m + n)   |   Approach: LinkedHashSet

Q15. Frequency Count of Elements in a Java Array

Problem Statement:

Count how many times each element appears in a Java array. This is one of the most commonly asked Java array questions in data-heavy interview rounds.

Logic — HashMap:

• Traverse the Java array and use a HashMap to track element counts
• Use getOrDefault() to avoid null-pointer issues on first occurrence

Java Code:

import java.util.HashMap;
import java.util.Map;

public class FrequencyCount {

    public static Map<Integer, Integer> getFrequency(int[] arr) {
        Map<Integer, Integer> map = new HashMap<>();
        
      for (int num : arr) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        return map;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 2, 3, 3, 3};
        System.out.println(getFrequency(arr)); // {1=1, 2=2, 3=3}
    }
}

Complexity:

Time: O(n)   |   Space: O(n)   |   Approach: HashMap

Q16. Check if a Java Array is Sorted

Problem Statement:

Determine whether a given Java array is sorted in ascending order. A simple but frequently asked Java array warm-up question in screening rounds.

Logic — Single Pass:

• Traverse the Java array once
• Return false immediately if any element is greater than the next

Java Code:

public class CheckSorted {
    public static boolean isSorted(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        System.out.println(isSorted(arr)); // true
    }
}

Complexity:

Time: O(n)   |   Space: O(1)   |   Approach: Single pass

Q17. Find Leaders in a Java Array

Problem Statement:

An element in a Java array is a leader if it is greater than all elements to its right. Find all such leaders. This is a classic Java array right-to-left traversal problem.

Logic — Right-to-Left Scan:

• The rightmost element of the Java array is always a leader
• Scan right to left, tracking the running maximum
• Any element greater than the current max is a leader

Java Code:

public class LeadersArray {

    public static void findLeaders(int[] arr) {
        int maxFromRight = arr[arr.length - 1];
        System.out.print(maxFromRight + " "); // Last element is always a leader

        for (int i = arr.length - 2; i >= 0; i--) {
            if (arr[i] > maxFromRight) {
                maxFromRight = arr[i];
                System.out.print(maxFromRight + " ");
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {16, 17, 4, 3, 5, 2};
        findLeaders(arr); // Output: 2 5 17
    }
}

Complexity:

Time: O(n)   |   Space: O(1)   |   Approach: Right-to-left scan

Q18. Left Rotate a Java Array by One Position

Problem Statement:

Shift every element of a Java array one position to the left. The first element wraps around to the last position. A must-know Java array in-place manipulation question.

Logic — Save and Shift:

• Save the first element of the Java array
• Shift all remaining elements one index to the left
• Place the saved element at the last index

Java Code:

import java.util.Arrays;
public class LeftRotate {
    public static void rotateLeft(int[] arr) {
        int first = arr[0];
        for (int i = 0; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length - 1] = first;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        rotateLeft(arr);
        System.out.println(Arrays.toString(arr)); // [2, 3, 4, 5, 1]
    }

}

Complexity:

Time: O(n)   |   Space: O(1)   |   Approach: In-place shift

Q19. Find a Pair with a Given Difference in a Java Array

Problem Statement:

Check whether any pair of elements in a Java array has a difference equal to a given value. This Java array question tests HashSet-based O(n) lookup patterns.

Logic — HashSet Complement Check:

• For each element in the Java array, check if (num – diff) or (num + diff) already exists in the set
• If yes, a valid pair exists — return true
• Otherwise, add the element to the set and continue

Java Code:

import java.util.HashSet;

import java.util.Set;

public class PairDifference {

    public static boolean findPair(int[] arr, int diff) {
        Set<Integer> set = new HashSet<>();
        for (int num : arr) {
            if (set.contains(num - diff) || set.contains(num + diff)) {
                return true;
            }
            set.add(num);
        }
       return false;
    }

    public static void main(String[] args) {
        int[] arr = {1, 5, 3, 4, 2};
        System.out.println(findPair(arr, 2)); // true
    }
}

Complexity:

Time: O(n)   |   Space: O(n)   |   Approach: HashSet

Q20. Find Subarray with a Given Sum in a Java Array

Problem Statement:

Find a contiguous subarray within a Java array whose elements sum to a given target value. This is a classic sliding window Java array problem asked in FAANG interviews.

Logic — Sliding Window:

• Maintain a running sum over a window of the Java array
• Expand the window by adding arr[end] on each step
• Shrink the window from the left when sum exceeds the target
• Return the window indices when sum equals the target

Java Code:

public class SubarraySum {

    public static void findSubarray(int[] arr, int target) {
        int start = 0, sum = 0;
        for (int end = 0; end < arr.length; end++) {
            sum += arr[end];
            while (sum > target && start < end) {
                sum -= arr[start++];
            }

            if (sum == target) {
                System.out.println("Subarray found from index " + start + " to " + end);
                return;
            }
        }

        System.out.println("No subarray found.");

    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 7, 5};
        findSubarray(arr, 12); // Output: Subarray found from index 2 to 4
    }
}

Complexity:

Time: O(n)   |   Space: O(1)   |   Approach: Sliding window

Java Array Interview Questions — Complexity Quick Reference:

Use this table to review the time and space complexity of all 10 Java array problems before your interview.

Frequently Asked Questions — Java Array Interview Questions

Q: What is the most efficient way to rotate a Java array?

The most efficient approach uses in-place reversal — reverse the full Java array, then reverse the first k elements, then reverse the remaining n–k elements. This runs in O(n) time and O(1) space, with no extra memory needed.

Q: How does the sliding window technique work on a Java array?

The sliding window technique maintains two pointers (start and end) over a Java array to track a contiguous subrange. You expand the window by moving end forward and shrink it from start when a condition (like sum > target) is violated. This turns O(n²) brute-force solutions into O(n).

Q: When should I use a HashMap vs a HashSet for Java array problems?

Use a HashSet when you only need to track existence (e.g., intersection, pair finding). Use a HashMap when you need to store a value associated with each element, such as counting frequency or storing indices for the Two Sum problem.

Q: Are Java array questions asked at FAANG companies?

Yes — Java array questions are consistently among the most tested topics at Google, Amazon, Microsoft, and other top tech companies. Key patterns include two pointers, sliding window, prefix sums, and HashMap-based lookups.

Q: What is the difference between a Java array and ArrayList?

A Java array has a fixed size set at creation time, while an ArrayList is a resizable dynamic data structure. Java arrays offer slightly better performance for index-based access, while ArrayList provides convenient add/remove operations.

Conclusion:

In this second instalment of our Java array coding interview guide, we covered 10 advanced problems (Q11–Q20) that are commonly tested in technical interviews at top companies. Each Java array problem introduced a reusable pattern — in-place reversal, sliding window, two pointers, HashSet, and HashMap — that you can apply across dozens of similar problems.

Understanding why each Java array solution works is more valuable than memorizing code. When you grasp the underlying pattern, you can adapt it to variations you have never seen before — which is exactly what interviewers are testing.

Practice each Java array problem by coding it from scratch, then optimize for time and space. Combining consistent practice with pattern recognition is the fastest path to cracking Java array interview questions at FAANG and product-based companies in 2026.

External Resources for Practice:

Here are some high-quality resources where you can practice and deepen your understanding of Java array coding interviews

• GeeksforGeeks
• HackerRank
• Programiz
• Oracle

Final Tip:

For Java Array coding ,

Don’t just read — code along.
Don’t just code — explain it out loud.
That’s how you crack interviews like a pro.

🔥 Continue Your Learning Journey

Want to go beyond Java Arrays and crack interviews faster? Check these hand-picked guides:

👉 🚀 Master TestNG Framework (Enterprise Level)
Build scalable automation frameworks with CI/CD, parallel execution, and real-world architecture
➡️ Read: TestNG Automation Framework – Complete Architect Guide

👉 🧠 Learn Cucumber (BDD from Scratch to Advanced)
Understand Gherkin, step definitions, and real-world BDD framework design
➡️ Read: Cucumber Automation Framework – Beginner to Advanced Guide

👉 🔐 API Authentication Made Simple
Master JWT, OAuth, Bearer Tokens with real API testing examples
➡️ Read: Ultimate API Authentication Guide

👉 ⚡ Crack Playwright Interviews (2026 Ready)
Top real interview questions with answers and scenarios
➡️ Read: Playwright Interview Questions Guide