☕ Java MCQ Questions – Page 185

public class WaitNoNotify {
    private static final Object monitor = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitingThread = new Thread(() -> {
            synchronized (monitor) {
                try {
                    System.out.println("Waiting thread: Waiting...");
                    monitor.wait(); // Will wait indefinitely unless interrupted or notified
                    System.out.println("Waiting thread: Woke up.");
                } catch (InterruptedException e) {
                    System.out.println("Waiting thread: Interrupted!");
                }
            }
        });
        waitingThread.start();
        Thread.sleep(200);
        System.out.println("Main thread: Waiting thread state: " + waitingThread.getState());
        System.out.println("Main thread: Exiting.");
    }
}

public class SwitchError {
    public static void main(String[] args) {
        double value = 1.0;
        switch (value) {
            case 1.0:
                System.out.println("One");
                break;
            default:
                System.out.println("Other");
        }
    }
}

public class AutoboxingTest {
    void display(int i) {
        System.out.println("Primitive int: " + i);
    }
    void display(Integer i) {
        System.out.println("Wrapper Integer: " + i);
    }
    public static void main(String[] args) {
        AutoboxingTest abt = new AutoboxingTest();
        abt.display(50);
    }
}

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

public class Test {
    public static void main(String[] args) {
        Map<String, String> originalMap = new HashMap<>();
        originalMap.put("key1", "value1");
        originalMap.put("key2", "value2");

        Map<String, String> unmodifiableMap = Collections.unmodifiableMap(originalMap);
        
        System.out.println(unmodifiableMap.get("key1"));
        unmodifiableMap.put("key3", "value3"); // Attempt to modify
        System.out.println(unmodifiableMap.size());
    }
}

public class ArrayCopyOverlap {
    public static void main(String[] args) {
        int[] source = {1, 2, 3, 4, 5};
        System.arraycopy(source, 0, source, 2, 3);
        for (int i : source) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MethodRefTest {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("alice", "bob", "charlie");
        List<String> upperNames = names.stream()
                                     .map(String::toUpperCase)
                                     .collect(Collectors.toList());
        System.out.println(String.join(", ", upperNames));
    }
}

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        File file = new File("nonExistentFile.txt");
        System.out.println(file.exists() + " " + file.isFile());
    }
}

import java.util.ArrayDeque;
import java.util.Deque;

public class QueueTest {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        String result = "";
        try {
            deque.add("First");
            deque.add(null);
            deque.offer("Second");
            result += deque.poll();
        } catch (NullPointerException e) {
            result += "NPE caught. Queue size: " + deque.size();
        } catch (Exception e) {
            result += "Other exception: " + e.getClass().getSimpleName();
        }
        System.out.println(result);
    }
}

import java.util.List;

public class ListOfTest {
    public static void main(String[] args) {
        List<String> immutableList = List.of("Red", "Green", "Blue");
        try {
            immutableList.add("Yellow");
        } catch (UnsupportedOperationException e) {
            System.out.println("Modification not allowed.");
        }
        System.out.println(immutableList.size());
    }
}

import java.io.*;

class Outer implements Serializable {
    private String name = "Outer";
    // Inner class is not explicitly Serializable
    private Inner inner = new Inner(); 

    class Inner { // Non-static inner class
        String value = "InnerValue";
    }
}

public class SerializationQuestion3 {
    public static void main(String[] args) throws IOException {
        Outer outer = new Outer();
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("outer.ser"))) {
            oos.writeObject(outer);
        }
    }
}

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

public class StreamReduceHard {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        Optional<Integer> result = numbers.stream()
                                        .reduce((acc, x) -> acc + x + 1);

        System.out.println(result.orElse(-1));
    }
}

class MyClass {
    static MyClass() {
        System.out.println("Static constructor");
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
    }
}

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

public class FileReaderTest {
    public static void main(String[] args) {
        // Assume test.txt exists and contains "OK"
        try (FileReader reader = new FileReader("test.txt")) {
            int c;
            while ((c = reader.read()) != -1) {
                System.out.print((char) c);
            }
        } catch (IOException e) {
            System.out.print("Error");
        }
    }
}

import java.util.TreeMap;
import java.util.NavigableMap;

public class TreeMapError8 {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(10, "Ten");
        map.put(20, "Twenty");
        map.put(30, "Thirty");

        NavigableMap<Integer, String> navMap = map;
        System.out.println(navMap.floorEntry(null)); 
    }
}

class Shape {
    public abstract double calculateArea(); 
}

public class Main {
    public static void main(String[] args) {
        // Code won't reach here due to compile error
    }
}