Java MCQ Questions – Page 44 of 200

Q: What is a primary benefit of using functional interfaces in conjunction with lambda expressions?

B) To enable more concise and readable code for implementing single-method interfaces.. Functional interfaces allow lambda expressions to be used as a compact way to pass behavior, resulting in more concise and often more readable code compared to anonymous inner classes.

Q: In which scenario is a `do-while` loop *semantically mandatory* over a standard `while` loop to guarantee correct behavior, assuming the loop body must execute at least once, and the initial condition for loop continuation is derived from an operation performed *within* the first iteration of the loop body itself?

A) Reading user input for a menu, where the first input is needed to determine if the loop should continue.. A `do-while` loop guarantees at least one execution of its body before evaluating the condition. This is crucial when the condition itself depends on actions performed within the first iteration, such as prompting for and receiving initial user input.

Q: What is the output of this code?

A) it1: 2, it2: 3. Each `Iterator` maintains its own independent state (current position). `it1` moves once to element 2. `it2` moves twice, first to element 2 then to element 3. The subsequent `it1.next()` gets 2, and `it2.next()` gets 3.

Q: What is the error in this Java code?

A) Compile-time error: display() in Child cannot override display() in Parent; overridden method is final. A `final` method in a superclass cannot be overridden by a subclass. This will result in a compile-time error.

Q: Consider an `if-else` structure in Java. If the `if` condition evaluates to `false`, what is guaranteed to happen next?

B) The code within the `else` block will execute.. In an `if-else` construct, if the `if` condition is `false`, control flow automatically transfers to the `else` block, and its code is executed.

Q: Which of the following statements about Java daemon threads is true?

C) Daemon threads are automatically stopped by the JVM when all non-daemon threads finish.. Daemon threads are background threads that do not prevent the JVM from exiting. When all non-daemon (user) threads complete, the JVM terminates, abandoning any running daemon threads.

Q: What error will occur when this code is executed?

C) StringIndexOutOfBoundsException. The `StringBuffer` "World" has a length of 5. The `end` index (exclusive) for `delete()` cannot be greater than the length of the sequence. Here, 6 is out of bounds, causing a `StringIndexOutOfBoundsException`.

Q: What does this Java code print?

B) Hello. Strings in Java are immutable. The `concat()` method creates a *new* string but does not change the original string `s`. Since the new string created by `s.concat(" World")` is not assigned back to `s` or any other variable, `s` retains its original value of "Hello".

Q: A junior developer argues that wrapping a `FileReader` with a `BufferedReader` is only necessary for improving performance on extremely large files. A senior developer corrects them, stating it's beneficial for files of all sizes. What is the most compelling reason for the senior developer's stance beyond just raw performance for large files?

B) BufferedReader provides the `readLine()` method, which greatly simplifies reading text files line by line, regardless of file size.. While buffering improves performance, a primary practical benefit of BufferedReader, even for small files, is the convenience of the `readLine()` method, which reads text one line at a time, simplifying common text processing tasks.

Q: Which of the following method call resolution rules has the highest precedence when Java's compiler tries to match an overloaded method?

D) An exact match by parameter type.. The Java compiler prioritizes an exact match of parameter types. If no exact match is found, it then considers widening primitive conversions, followed by autoboxing/unboxing, and finally varargs.

Q861 easy

What is a primary benefit of using functional interfaces in conjunction with lambda expressions?

Q862 hard

In which scenario is a `do-while` loop *semantically mandatory* over a standard `while` loop to guarantee correct behavior, assuming the loop body must execute at least once, and the initial condition for loop continuation is derived from an operation performed *within* the first iteration of the loop body itself?

Q863 medium code output

What is the output of this code?

java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3));
        Iterator<Integer> it1 = nums.iterator();
        Iterator<Integer> it2 = nums.iterator();
        it1.next(); // it1 advances to 2
        it2.next(); // it2 advances to 2
        it2.next(); // it2 advances to 3
        System.out.println("it1: " + it1.next() + ", it2: " + it2.next());
    }
}

Q864 easy code error

What is the error in this Java code?

java

class Parent {
    public final void display() {
        System.out.println("Parent display");
    }
}

class Child extends Parent {
    public void display() { // Line 7
        System.out.println("Child display");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        c.display();
    }
}

Q865 medium

Consider an `if-else` structure in Java. If the `if` condition evaluates to `false`, what is guaranteed to happen next?

Q866 medium

Which of the following statements about Java daemon threads is true?

Q867 easy code error

What error will occur when this code is executed?

java

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("World");
        sb.delete(0, 6);
        System.out.println(sb);
    }
}

Q868 medium code output

What does this Java code print?

java

public class StringTest {
    public static void main(String[] args) {
        String s = "Hello";
        s.concat(" World");
        System.out.println(s);
    }
}

Q869 hard

A junior developer argues that wrapping a `FileReader` with a `BufferedReader` is only necessary for improving performance on extremely large files. A senior developer corrects them, stating it's beneficial for files of all sizes. What is the most compelling reason for the senior developer's stance beyond just raw performance for large files?

Q870 medium

Which of the following method call resolution rules has the highest precedence when Java's compiler tries to match an overloaded method?

Q871 hard code error

What is the compilation error in the following Java code snippet?

java

import java.util.concurrent.Callable;

public class Main {
    public static void main(String[] args) throws Exception {
        int counter = 0;
        Callable<Integer> incrementer = () -> {
            return counter + 1;
        };
        counter = 10; // This line is added after the lambda declaration
        System.out.println(incrementer.call());
    }
}

Q872 medium code output

What is the output of this code?

java

class CustomRuntimeException extends RuntimeException {
    public CustomRuntimeException(String message) {
        super(message);
    }
}

public class Main {
    public static void executeTask() {
        throw new CustomRuntimeException("Task failed!");
    }

    public static void main(String[] args) {
        try {
            executeTask();
            System.out.println("Task completed.");
        } catch (RuntimeException e) {
            System.out.println("Handling runtime exception: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Handling general exception: " + e.getMessage());
        }
    }
}

Q873 hard code output

What is the output of this code?

java

public class Main {
    private static String modify(String s) {
        s = s + " modified"; // Reassigns local 's'
        return s;
    }

    public static void main(String[] args) {
        String original = "initial";
        String result = modify(original);
        System.out.println(original + "|" + result);
    }
}

Q874 hard code output

What is the output of this code?

java

import java.util.TreeSet;

public class App {
    public static void main(String[] args) {
        TreeSet set = new TreeSet(); // Raw type TreeSet
        set.add(10);
        set.add(new Object()); // Incompatible type
        System.out.println(set.size());
    }
}

Q875 medium code output

What is the output of this code?

java

import java.util.HashMap;

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("A", 100);
        map.put("B", 200);
        boolean checkKey = map.containsKey("A");
        boolean checkValue = map.containsValue(300);
        System.out.println(checkKey + ", " + checkValue);
    }
}

Q876 medium code output

What is the most likely output of this code?

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class CounterLock {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CounterLock counter = new CounterLock();
        Runnable task = () -> {
            for (int i = 0; i < 5000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(counter.getCount());
    }
}

Q877 medium code output

What is the content of 'combined_ops.txt' after this code executes?

java

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileObjectCombinedWrite {
    public static void main(String[] args) {
        File file = new File("combined_ops.txt");
        try {
            FileWriter writer1 = new FileWriter(file); // Overwrite mode
            writer1.write("Initial content.\n");
            writer1.close();
            FileWriter writer2 = new FileWriter(file, true); // Append mode
            writer2.write("Appended content.\n");
            writer2.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Q878 easy

Is it permissible to have an `if` statement in Java without an accompanying `else` clause?

Q879 medium code output

What is the output of this Java code snippet?

java

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

public class Main {
    public static void main(String[] args) {
        Set<String> letters = new HashSet<>();
        letters.add("X");
        letters.add("Y");
        letters.remove("X");
        letters.add("Z");
        letters.add("X");
        System.out.println(letters.size());
    }
}

Q880 hard code error

What type of runtime error will occur when executing this Java code?

java

import java.util.ArrayList;
import java.util.List;

public class ClassCastLoop {
    public static void main(String[] args) {
        List<Object> mixedList = new ArrayList<>();
        mixedList.add("Hello");
        mixedList.add(123); // Integer object
        mixedList.add("World");

        int i = 0;
        while (i < mixedList.size()) {
            String s = (String) mixedList.get(i); // Potential ClassCastException
            System.out.println(s.toUpperCase());
            i++;
        }
    }
}

☕ Java MCQ Questions – Page 44