Java MCQ Questions – Page 4 of 200

Q: What does this code print to the console?

A) Model: Sedan, Year: 2023. An instance of the `Car` class is created, and its `model` and `year` instance variables are explicitly assigned values. The `System.out.print` statement then accesses and prints these assigned values.

Q: What error will occur when compiling the following Java code?

A) incompatible types: int cannot be converted to java.lang.String. The HashSet is declared to hold String objects. Attempting to add an Integer (123) to a HashSet of Strings results in a compile-time type mismatch error.

Q: What error will occur when `MyRecursiveTask` is executed with a very deep recursion level?

B) java.lang.StackOverflowError. While `synchronized` methods are reentrant (a thread can re-acquire a lock it already holds), each recursive call still consumes stack frames. Calling a method recursively for an extremely large number of times, even if it's synchronized, will eventually exhaust the thread's stack space, leading to a `java.lang.StackOverflowError`.

Q: Consider the Java code. What will be the outcome of its compilation?

A) Compile-time error: Method 'processData(byte[])' is already defined in 'DataProcessor'.. The 'final' modifier is not part of a method's signature for overloading purposes. Since both methods have the exact same name and parameter list, the compiler will report that the method 'processData(byte[])' is already defined.

Q: What is the output of this Java code snippet?

A) 012. The loop starts with `i=0` and continues as long as `i` is less than 3. It prints `i` (0, then 1, then 2) and increments `i` in each iteration. When `i` becomes 3, the condition `i < 3` is false, and the loop terminates.

Q: Given an object `myString` of type `String`, which method reference syntax correctly refers to its `length()` method?

B) `myString::length`. To refer to an instance method of a specific object, the syntax `object::instanceMethodName` is used. `myString::length` correctly references the `length()` method of the `myString` object.

Q: Which of the following is a primary advantage of implementing the `Externalizable` interface over `Serializable` for a complex object with many fields?

B) It provides complete control over the serialization and deserialization process, potentially leading to better performance and smaller serialized forms.. `Externalizable` gives full control over the serialization format and process, allowing developers to optimize for performance, size, or specific versioning requirements, unlike `Serializable` which uses default serialization.

Q: What compile-time error will occur when compiling this Java code?

A) error: incompatible types: MyCustomException cannot be converted to java.lang.Throwable. To be thrown, a class must directly or indirectly extend `java.lang.Throwable`. Since `MyCustomException` does not extend `Throwable` (or `Exception`/`RuntimeException`), it cannot be thrown, leading to a type incompatibility error.

Q: `String` objects are commonly used as keys in `HashMap`. Which statement accurately describes `String`'s `hashCode()` implementation and its implication for `HashMap` performance?

D) `String`'s `hashCode()` uses a prime multiplier (typically 31) for polynomial hashing, and while generally good, it can still lead to collisions, especially for many similar strings, impacting `HashMap` performance.. `String.hashCode()` uses a polynomial hashing algorithm with a multiplier of 31 and is cached for performance. However, it's still possible to craft distinct strings that produce the same hash code, leading to increased collision resolution overhead in the HashMap.

Q: What kind of error will occur when executing this Java code?

B) NullPointerException. When null is added to the TreeSet, the customComparator will be invoked to compare it with existing elements. Inside the lambda expression, s1.toLowerCase() will be called with s1 being null, leading to a NullPointerException.

Q61 easy code output

What does this code print to the console?

java

class Car {
    String model;
    int year;
}
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.model = "Sedan";
        myCar.year = 2023;
        System.out.print("Model: " + myCar.model + ", Year: " + myCar.year);
    }
}

Q62 easy code error

What error will occur when compiling the following Java code?

java

import java.util.HashSet;

public class MyClass {
    public static void main(String[] args) {
        HashSet<String> names = new HashSet<>();
        names.add("Alice");
        names.add(123); // This line will cause an error
        System.out.println(names.size());
    }
}

Q63 hard code error

What error will occur when `MyRecursiveTask` is executed with a very deep recursion level?

java

public class MyRecursiveTask {
    private static final Object lock = new Object();
    private int counter = 0;

    public synchronized void recursiveCall(int depth) {
        if (depth == 0) {
            return;
        }
        counter++;
        recursiveCall(depth - 1);
    }

    public static void main(String[] args) {
        MyRecursiveTask task = new MyRecursiveTask();
        task.recursiveCall(100000); // A very deep recursion
    }
}

Q64 easy code error

Consider the Java code. What will be the outcome of its compilation?

java

class DataProcessor {
    final void processData(byte[] data) {
        System.out.println("Final processing...");
    }

    void processData(byte[] data) {
        System.out.println("General processing...");
    }
}

Q65 easy code output

What is the output of this Java code snippet?

java

public class WhileLoopDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 3) {
            System.out.print(i);
            i++;
        }
    }
}

Q66 medium

Given an object `myString` of type `String`, which method reference syntax correctly refers to its `length()` method?

Q67 hard

Which of the following is a primary advantage of implementing the `Externalizable` interface over `Serializable` for a complex object with many fields?

Q68 easy code error

What compile-time error will occur when compiling this Java code?

java

class MyCustomException {
    public MyCustomException(String message) {
        // This class does not extend Throwable
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("Something went wrong");
        } catch (MyCustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

Q69 hard

`String` objects are commonly used as keys in `HashMap`. Which statement accurately describes `String`'s `hashCode()` implementation and its implication for `HashMap` performance?

Q70 medium code error

What kind of error will occur when executing this Java code?

java

import java.util.Comparator;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Comparator<String> caseInsensitiveComparator = (s1, s2) -> s1.toLowerCase().compareTo(s2.toLowerCase());
        TreeSet<String> set = new TreeSet<>(caseInsensitiveComparator);
        set.add("Apple");
        set.add("Banana");
        set.add(null);
        System.out.println(set.size());
    }
}

Q71 hard

Given `int x = 0; int y = 5;`, what is the final value of `x` after `boolean condition = (x++ > 0 && y++ < 10);`?

Q72 hard

Which of the following statements correctly initializes a jagged multi-dimensional array in Java?

Q73 medium

Besides implementing the `List` interface, `java.util.LinkedList` also implements which other primary interface, making it suitable for queue and stack operations?

Q74 hard code error

What is the output of this code?

java

import java.util.LinkedList;

public class MyClass {
    public static void main(String[] args) {
        LinkedList<Integer> stack = new LinkedList<>();
        stack.push(10);
        stack.pop(); // Removes 10
        stack.pop(); // Attempt to pop from empty stack
        System.out.println(stack);
    }
}

Q75 hard code error

What kind of runtime error or unexpected behavior will occur when running this Java code, primarily related to thread lifecycle?

java

public class MyTask implements Runnable {
    public void run() {
        try {
            this.wait(); // Problem line
        } catch (InterruptedException | IllegalMonitorStateException e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
        }
    }
    public static void main(String[] args) {
        Thread t = new Thread(new MyTask());
        t.start();
    }
}

Q76 easy code output

What does this code print?

java

public class Main {
    public static String testMethod() {
        try {
            int x = 1 / 0; // Throws ArithmeticException
            System.out.print("Try ");
        } catch (ArithmeticException e) {
            System.out.print("Catch ");
            return "Return from catch";
        } finally {
            System.out.print("Finally ");
        }
        return "End of method";
    }
    public static void main(String[] args) {
        System.out.println(testMethod());
    }
}

Q77 medium code error

What will this Java code snippet print to the console?

java

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

public class Test {
    public static void main(String[] args) {
        try {
            Map<String, String> myMap = new HashMap<>(-5); // Negative initial capacity
            myMap.put("test", "value");
            System.out.println("Map created successfully.");
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}

Q78 medium code error

Examine the Java code. What error will occur when it runs?

java

import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(10, "Ten");
        map.put(20, "Twenty");
        map.remove(null);
        System.out.println(map.size());
    }
}

Q79 medium code output

What is the output of this code snippet?

java

interface MathOperation {
    int operate(int a, int b);
}

public class LambdaWithReturn {
    public static void main(String[] args) {
        MathOperation addition = (a, b) -> a + b;
        MathOperation subtraction = (a, b) -> a - b;

        System.out.println(addition.operate(5, 3));
        System.out.println(subtraction.operate(5, 3));
    }
}

Q80 hard code error

What is the most likely error when executing this Java code snippet?

java

import java.io.BufferedWriter;
import java.io.StringWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        StringWriter sw = new StringWriter();
        BufferedWriter bw = new BufferedWriter(sw);
        try (bw) { // Using try-with-resources on an existing variable
            bw.write("First line.");
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
        try {
            bw.write("Attempt to write after close."); // This will throw
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

☕ Java MCQ Questions – Page 4