8 Java Interview Questions Every Hiring Manager Should Ask

• The array will contain between 2 to 10 elements.
• Each element will be a positive integer, no greater than 10.

    public static int[] transformArray(int[] inputArray) {

        int[] productArray = new int[inputArray.length];

        int leftProduct = 1, rightProduct = 1;

        // Initialize the product array with 1s

        for (int i = 0; i < inputArray.length; i++) {

            productArray[i] = 1;

        }

        // Compute the product of elements to the left of each element

        for (int i = 0; i < inputArray.length; i++) {

            productArray[i] = leftProduct;

            leftProduct *= inputArray[i];

        }

        // Compute the product of elements to the right of each element

        for (int i = inputArray.length – 1; i >= 0; i–) {

            productArray[i] *= rightProduct;

            rightProduct *= inputArray[i];

        }

        return productArray;

    }

    public static void main(String[] args) {

        int[] sampleInput = {1, 2, 3, 4};

        int[] transformedArray = transformArray(sampleInput);

        // Printing the transformed array

        for (int value : transformedArray) {

            System.out.print(value + ” “);

        }

    }

}

• Not handling edge cases, such as arrays with only two elements.
• Inefficient solutions that do not consider time complexity.

• How can you optimize the solution for space complexity?
• Can this problem be solved in a single pass through the array?

• Understanding of array manipulation and basic algorithmic problem-solving.
• Ability to optimize for time and space complexity.
• Consideration for edge cases and input constraints.

This question assesses the candidate’s problem-solving skills, understanding of arrays, and ability to think through the implications of constraints and optimizations.

• The input string will have at least one character and at most 100 characters.
• The string contains only uppercase and lowercase letters (no numbers or special characters).

    public static String compressString(String input) {

        if (input == null || input.isEmpty()) {

            return input;

        }

        StringBuilder compressed = new StringBuilder();

        int count = 1;

        for (int i = 1; i < input.length(); i++) {

            if (input.charAt(i) == input.charAt(i – 1)) {

                count++;

            } else {

                compressed.append(input.charAt(i – 1)).append(count);

                count = 1; // Reset count

            }

        }

        // Append last set of characters

        compressed.append(input.charAt(input.length() – 1)).append(count);

        return compressed.toString();

    }

    public static void main(String[] args) {

        String sampleInput = “aaabbcc”;

        String compressedString = compressString(sampleInput);

        System.out.println(compressedString);

    }

}

• Not handling strings with a single character.
• Forgetting to add the last set of characters to the result.

• How would you handle compression for strings where the compressed version is longer than the original string?
• Can this algorithm be optimized to run in O(n) time complexity?

• Understanding of string manipulation and efficiency in algorithms.
• Ability to write concise and optimized code.
• Consideration for edge cases in string processing.

This question assesses the candidate’s proficiency in handling strings, their efficiency in writing algorithms, and their ability to manage special cases in data.

• The string will have a maximum length of 1000 characters.
• The string may contain characters other than brackets.

public class BracketBalancer {

    public static boolean isBalanced(String str) {

        Stack<Character> stack = new Stack<>();

        for (char ch : str.toCharArray()) {

            if (ch == ‘(‘ || ch == ‘{‘ || ch == ‘[‘) {

                stack.push(ch);

            } else if (ch == ‘)’ || ch == ‘}’ || ch == ‘]’) {

                if (stack.isEmpty()) {

                    return false;

                }

                char last = stack.pop();

                if (!isMatchingPair(last, ch)) {

                    return false;

                }

            }

        }

        return stack.isEmpty();

    }

    private static boolean isMatchingPair(char opening, char closing) {

        return (opening == ‘(‘ && closing == ‘)’) ||

               (opening == ‘{‘ && closing == ‘}’) ||

               (opening == ‘[‘ && closing == ‘]’);

    }

    public static void main(String[] args) {

        String sampleInput = “{[()]} is a balanced string.”;

        System.out.println(isBalanced(sampleInput));

    }

}

• Failing to account for non-bracket characters in the string.
• Not checking if the stack is empty before popping an element.

• How would you modify the algorithm to handle strings with other characters?
• What are the implications of using a stack for this problem?

• Knowledge of stack data structures and their application.
• Ability to process and parse strings effectively.
• Problem-solving skills in handling nested structures and order-dependent problems.

This question evaluates the candidate’s understanding of stacks, their skill in handling complex string manipulations, and logical thinking in maintaining order and structure.

• The string length will be at least 1 and no more than 1000 characters.
• The string will consist of only alphanumeric characters (both uppercase and lowercase).

    public static String longestPalindrome(String s) {

        if (s == null || s.length() < 1) {

            return “”;

        }

        int start = 0, end = 0;

        for (int i = 0; i < s.length(); i++) {

            int len1 = expandFromMiddle(s, i, i);

            int len2 = expandFromMiddle(s, i, i + 1);

            int len = Math.max(len1, len2);

            if (len > end – start) {

                start = i – (len – 1) / 2;

                end = i + len / 2;

            }

        }

        return s.substring(start, end + 1);

    }

    private static int expandFromMiddle(String s, int left, int right) {

        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {

            left–;

            right++;

        }

        return right – left – 1;

    }

    public static void main(String[] args) {

        String sampleInput = “forgeeksskeegfor”;

        System.out.println(longestPalindrome(sampleInput));

    }

}

• Overlooking edge cases like strings with a single character or all characters being the same.
• Inefficient algorithms that do not consider time complexity.

• How would you handle cases with multiple palindromes of the same maximum length?
• Can you optimize the solution to reduce the time complexity further?

• Deep understanding of string algorithms and dynamic programming.
• Efficiency in handling large strings and optimizing for both time and space complexity.
• Attention to detail in identifying palindromes within varied contexts.

This question tests the candidate’s ability to implement advanced string processing algorithms and optimize their solutions for complex problems.

• Assume a maximum of 100 entries in the HashMap.
• Keys and values will be of integer type.

get(1)

remove(1)

get(1)

100 (value associated with key 1)

Key removed

null (since key 1 has been removed)

    private class Entry {

        int key;

        int value;

        Entry(int key, int value) {

            this.key = key;

            this.value = value;

        }

    }

    private Entry[] table;

    private static final int CAPACITY = 100;

    public CustomHashMap() {

        table = new Entry[CAPACITY];

    }

    public void put(int key, int value) {

        int index = key % CAPACITY;

        table[index] = new Entry(key, value);

    }

    public Integer get(int key) {

        int index = key % CAPACITY;

        if (table[index] != null && table[index].key == key) {

            return table[index].value;

        }

        return null;

    }

    public void remove(int key) {

        int index = key % CAPACITY;

        if (table[index] != null && table[index].key == key) {

            table[index] = null;

        }

    }

    public static void main(String[] args) {

        CustomHashMap map = new CustomHashMap();

        map.put(1, 100);

        System.out.println(map.get(1)); // Should print 100

        map.remove(1);

        System.out.println(map.get(1)); // Should print null

    }

}

• Not correctly handling hash collisions.
• Forgetting to check for null values in get and remove operations.

• How would you handle resizing the HashMap when it reaches capacity?
• Can you implement the HashMap to handle generic types instead of just integers?

• Understanding of key data structures like HashMaps.
• Ability to implement basic data structure operations from scratch.
• Insight into handling hashing, collisions, and memory management.

This question examines the candidate’s foundational knowledge of data structures, their implementation skills, and their understanding of hashing mechanisms.

• Use a fixed-size buffer (e.g., an array of size 10).
• The producer should stop producing if the buffer is full.
• The consumer should wait if the buffer is empty.

Consumer consumed: 1

Producer produced: 2

Consumer consumed: 2

…

import java.util.Queue;

public class ProducerConsumerProblem {

    private static final int CAPACITY = 10;

    private final Queue<Integer> queue = new LinkedList<>();

    class Producer implements Runnable {

        public void run() {

            int value = 0;

            while (true) {

                synchronized (queue) {

                    while (queue.size() == CAPACITY) {

                        try {

                            queue.wait();

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                    }

                    queue.add(value);

                    System.out.println(“Producer produced: ” + value);

                    value++;

                    queue.notifyAll();

                }

            }

        }

    }

    class Consumer implements Runnable {

        public void run() {

            while (true) {

                synchronized (queue) {

                    while (queue.isEmpty()) {

                        try {

                            queue.wait();

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                    }

                    int value = queue.remove();

                    System.out.println(“Consumer consumed: ” + value);

                    queue.notifyAll();

                }

            }

        }

    }

    public static void main(String[] args) {

        ProducerConsumerProblem problem = new ProducerConsumerProblem();

        Thread producerThread = new Thread(problem.new Producer());

        Thread consumerThread = new Thread(problem.new Consumer());

        producerThread.start();

        consumerThread.start();

    }

}

• Not handling synchronization properly could lead to race conditions.
• Not managing the producer and consumer conditions correctly leads to deadlock or starvation.

• How would you modify the solution for multiple producers and consumers?
• What strategies can you use to improve throughput in this system?

• Knowledge of multithreading concepts and synchronization in Java.
• Ability to handle inter-thread communication effectively.
• Problem-solving skills in avoiding common concurrency issues like deadlocks and race conditions.

This question assesses the candidate’s expertise in managing multiple threads, ensuring thread safety, and handling synchronization complexities.

• The cache should have a fixed size specified at the start (e.g., capacity of 5).
• Use standard data structures to implement the cache.

put(2, 200)

get(1)

put(3, 300) // Evicts key 2

get(2)       // Returns -1 (not found)

-1  (after get(2))

class LRUCache {

    private static class Node {

        int key, value;

        Node prev, next;

        Node(int key, int value) {

            this.key = key;

            this.value = value;

        }

    }

    private final int capacity;

    private final HashMap<Integer, Node> map;

    private final Node head, tail;

    public LRUCache(int capacity) {

        this.capacity = capacity;

        map = new HashMap<>();

        head = new Node(0, 0);

        tail = new Node(0, 0);

        head.next = tail;

        tail.prev = head;

    }

    public int get(int key) {

        if (map.containsKey(key)) {

            Node node = map.get(key);

            remove(node);

            insert(node);

            return node.value;

        }

        return -1;

    }

    public void put(int key, int value) {

        if (map.containsKey(key)) {

            remove(map.get(key));

        } else if (map.size() == capacity) {

            remove(tail.prev);

        }

        insert(new Node(key, value));

    }

    private void insert(Node node) {

        map.put(node.key, node);

        Node after = head.next;

        head.next = node;

        node.prev = head;

        node.next = after;

        after.prev = node;

    }

    private void remove(Node node) {

        map.remove(node.key);

        node.prev.next = node.next;

        node.next.prev = node.prev;

    }

    public static void main(String[] args) {

        LRUCache cache = new LRUCache(2);

        cache.put(1, 100);

        cache.put(2, 200);

        System.out.println(cache.get(1)); // prints 100

        cache.put(3, 300);                // evicts key 2

        System.out.println(cache.get(2)); // prints -1

    }

}

• Not maintaining the order of usage properly, which is crucial for LRU logic.
• Inefficient data structure usage leads to higher time complexity.

• How can you ensure thread safety in this LRU cache?
• Can you optimize the space complexity of your implementation?

• Understanding of caching mechanisms and design patterns like LRU.
• Proficiency in using data structures to create efficient algorithms.
• Skill in writing code that efficiently manages memory and data retrieval.

This question tests the candidate’s ability to implement complex algorithms, manage data efficiently, and apply design patterns in practical scenarios.

• The input value n will be a non-negative integer.
• Consider the first two Fibonacci numbers as 0 and 1.

    private static long[] memo;

    public static long fibonacci(int n) {

        if (memo == null) {

            memo = new long[n + 1];

        }

        if (n <= 1) {

            return n;

        }

        if (memo[n] != 0) {

            return memo[n];

        }

        memo[n] = fibonacci(n – 1) + fibonacci(n – 2);

        return memo[n];

    }

    public static void main(String[] args) {

        int n = 7;

        System.out.println(“Fibonacci number at position ” + n + ” is: ” + fibonacci(n));

    }

}

• Not implementing memoization, leading to exponential time complexity.
• Incorrect base cases for the Fibonacci sequence.

• How does memoization improve the performance of the Fibonacci calculation?
• Could this problem be solved using an iterative approach? Which approach is more efficient?

• Understanding of recursion and dynamic programming concepts.
• Ability to optimize recursive algorithms using memoization.
• Consideration for computational limitations and optimizing for performance.

This question evaluates the candidate’s skill in writing efficient recursive functions, their knowledge of optimization techniques like memoization, and their ability to handle performance constraints.