Java MCQ Questions – Page 62 of 200

Q: What does this code print to the console?

A) 3. The stream first gets distinct numbers: [1, 2, 3, 4, 5]. Then it filters for odd numbers: [1, 3, 5]. Finally, it counts them, resulting in 3.

Q: What is the output of this code?

B) Compile-time error. A concrete subclass (`SimpleProcessor`) of an abstract class (`Processor`) must implement all inherited abstract methods. Since `processData()` is not implemented, this code will result in a compile-time error.

Q: What is the output of this code?

A) false true. `list.toArray(T[] a)` creates a new array if the provided array `a` is too small to hold all elements. In this case, `result1` will be a new array, so `result1 == smallArray` is `false`. If `a` is large enough, it's filled and returned, so `result2 == exactArray` is `true`.

Q: What is the output of this code?

A) true\nfalse\ntrue. String literals like `"hello"` and `"hello world"` are stored in the String pool. `s1` refers to the `"hello"` literal, so `s1 == "hello"` would be true (though not directly tested here, `s1.equals("hello")` is). `s1.concat(" world")` creates a *new* String object (`s2`) on the heap, even if its content is identical to a pooled literal (`s3`). Thus, `s1 == s3` is false (comparing `"hello"` to `"hello world"`), and `s2 == s3` is false because `s2` is a newly created object outside the pool, while `s3` is a pooled literal. `s1.equals("hello")` is true as it compares content.

Q: What does this code print to the console?

A) Value1: Hello, Value2: null. Fields marked with the `transient` keyword are not serialized. Upon deserialization, `value2` (a `String`) will be initialized to its default value, which is `null`.

Q: What is the output of this code?

A) Hello A10 75 World. The `+` operator has left-to-right associativity. In the first line, `"Hello "` is a `String`, so subsequent `+` operations become string concatenations. `'A'` becomes 'A', then `10` becomes '10'. In the second line, `'A'` and `10` are primitive types. `'A'` (ASCII 65) is promoted to `int`, so `65 + 10 = 75`. Then, `75` is concatenated with `" World"`.

Q: What is the specific compilation error in this Java code example involving method overloading and `throws` clauses?

A) Compile-time error: Method 'executeTask()' is already defined in 'OverloadChecker'.. The `throws` clause is not part of a method's signature for the purpose of overloading. Therefore, two methods with identical names and parameter lists, but different `throws` clauses, constitute a duplicate method definition.

Q: Which of the following statements accurately describes a critical limitation of `BufferedReader`'s `mark()` and `reset()` methods when dealing with large input streams?

C) Exceeding the `readlimit` specified in `mark()` will invalidate the mark, potentially causing `reset()` to throw an `IOException`.. `mark()` requires a `readlimit` parameter, and if more characters are read than this limit before `reset()`, the buffer might discard the marked data, leading to an `IOException` upon `reset()`.

Q: When creating a `FileWriter` directly, it is often recommended to wrap it with a `BufferedWriter` (e.g., `new BufferedWriter(new FileWriter("file.txt"))`). What is the primary reason for this common practice?

C) `FileWriter` is unbuffered, performing a physical disk write operation for almost every small data chunk, while `BufferedWriter` adds an in-memory buffer to optimize I/O performance.. `FileWriter` is an unbuffered character stream that writes directly to the file, which can be inefficient due to frequent disk I/O. `BufferedWriter` adds an in-memory buffer, collecting characters before writing them in larger, more efficient blocks to the underlying `FileWriter`, thus significantly improving performance.

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

A) Compile-time error. A `byte` can only hold values from -128 to 127. Assigning the literal `130` directly to a `byte` variable causes a compile-time error due to possible lossy conversion.

Q1221 medium code output

What does this code print to the console?

java

import java.util.Arrays;
import java.util.List;

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 3, 5, 1);
        long count = numbers.stream()
                            .distinct()
                            .filter(n -> n % 2 == 1)
                            .count();
        System.out.println(count);
    }
}

Q1222 easy code output

What is the output of this code?

java

abstract class Processor {
    abstract void processData();
    void setup() {
        System.out.println("Processor setup.");
    }
}

class SimpleProcessor extends Processor {
    // Missing implementation of processData()
}

public class Main {
    public static void main(String[] args) {
        SimpleProcessor sp = new SimpleProcessor();
        sp.setup();
    }
}

Q1223 hard code output

What is the output of this code?

java

import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("X");
        list.add("Y");
        list.add("Z");

        String[] smallArray = new String[2];
        String[] result1 = list.toArray(smallArray); 

        String[] exactArray = new String[3];
        String[] result2 = list.toArray(exactArray); 

        System.out.println(result1 == smallArray); 
        System.out.println(result2 == exactArray); 
    }
}

Q1224 hard code output

What is the output of this code?

java

public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = s1.concat(" world");
        String s3 = "hello world";
        System.out.println(s1 == s3);
        System.out.println(s2 == s3);
        System.out.println(s1.equals("hello"));
    }
}

Q1225 easy code output

What does this code print to the console?

java

import java.io.*;

class MyData implements Serializable {
    private String value1;
    private transient String value2; 

    public MyData(String v1, String v2) {
        this.value1 = v1;
        this.value2 = v2;
    }

    public String toString() {
        return "Value1: " + value1 + ", Value2: " + value2;
    }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        MyData data = new MyData("Hello", "World");
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(data);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        MyData deserializedData = (MyData) ois.readObject();
        ois.close();

        System.out.println(deserializedData);
    }
}

Q1226 hard code output

What is the output of this code?

java

public class DataTypeChallenge {
    public static void main(String[] args) {
        System.out.println("Hello " + 'A' + 10);
        System.out.println('A' + 10 + " World");
    }
}

Q1227 medium code error

What is the specific compilation error in this Java code example involving method overloading and `throws` clauses?

java

import java.io.IOException;

public class OverloadChecker {
    public void executeTask() {
        System.out.println("Task without exception");
    }

    public void executeTask() throws IOException { // This line causes the error
        System.out.println("Task with IOException");
    }

    public static void main(String[] args) {
        OverloadChecker oc = new OverloadChecker();
        oc.executeTask();
    }
}

Q1228 hard

Which of the following statements accurately describes a critical limitation of `BufferedReader`'s `mark()` and `reset()` methods when dealing with large input streams?

Q1229 hard

When creating a `FileWriter` directly, it is often recommended to wrap it with a `BufferedWriter` (e.g., `new BufferedWriter(new FileWriter("file.txt"))`). What is the primary reason for this common practice?

Q1230 medium code error

What type of error will occur when compiling the following Java code?

java

public class Main {
    public static void main(String[] args) {
        byte b = 130;
        System.out.println(b);
    }
}

Q1231 medium code output

What does this code print?

java

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

Q1232 easy code error

What is the error in this Java code?

java

class Parent {
    public void process(int x) {
        System.out.println("Parent int: " + x);
    }
}

class Child extends Parent {
    @Override // Line 7
    public void process(double x) {
        System.out.println("Child double: " + x);
    }
}

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

Q1233 medium

What is the primary purpose of the `trimToSize()` method in `ArrayList`?

Q1234 hard

In a situation of classic deadlock where Thread A holds Lock X and waits for Lock Y, and Thread B holds Lock Y and waits for Lock X, what specific Java Thread state would both Thread A and Thread B be in?

Q1235 easy code output

What is the output of this Java code?

java

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

Q1236 medium code error

What is the output of this Java code?

java

import java.io.*;

public class DeserializationError6 {
    public static void main(String[] args) {
        byte[] data = null;
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject("Hello"); // Writes an object
            oos.writeInt(123);      // Writes a primitive
            data = bos.toByteArray();
        } catch (IOException e) { e.printStackTrace(); }

        try (ByteArrayInputStream bis = new ByteArrayInputStream(data);
             ObjectInputStream ois = new ObjectInputStream(bis)) {
            int number = ois.readInt(); // Attempts to read a primitive first
            String text = (String) ois.readObject();
            System.out.println("Number: " + number + ", Text: " + text);
        } catch (Exception e) {
            System.out.println("Error: " + e.getClass().getName() + ": " + e.getMessage());
        }
    }
}

Q1237 easy code output

What does this code print?

java

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

public class Test {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("Pen");
        items.add("Book");
        items.add("Pencil");
        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            String item = it.next();
            if (item.startsWith("P")) {
                it.remove();
            }
        }
        System.out.println(items);
    }
}

Q1238 hard

Which of the following scenarios is NOT a valid use case for the `var` keyword (local variable type inference) in Java?

Q1239 hard code output

What is the output of this code?

java

public class Test {
    public static void main(String[] args) {
        String result = "";
        for (int i = 0; i < 3; i++) {
            switch (i) {
                case 0: result += "A"; break;
                case 1: result += "B"; break;
                case 2: result += "C"; break;
            }
            result += i;
            if (i == 1) {
                break;
            }
        }
        System.out.print(result);
    }
}

Q1240 medium code error

What kind of error will occur when compiling and running the following Java code, assuming 'input.txt' exists?

java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TestClass {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new FileReader("input.txt"));
        String line = br.readLine();
        System.out.println(line);
        br.close();
    }
}

☕ Java MCQ Questions – Page 62