☕ Java MCQ Questions – Page 106

import java.util.LinkedList;

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        list.add(4);
        list.removeFirstOccurrence(2); // Removes the first '2'
        list.add(5);
        list.removeLastOccurrence(2); // Removes the remaining '2'
        System.out.println(list);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorShutdown {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        executor.submit(() -> {
            System.out.println("Task 1 Started");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Task 1 Finished");
        });
        executor.submit(() -> {
            System.out.println("Task 2 Started");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Task 2 Finished");
        });

        Thread.sleep(50); // Give Task 1 a chance to start
        executor.shutdownNow();
        System.out.println("Executor Shutdown Called");
    }
}

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class NonExistentFilePermissions {
    public static void main(String[] args) throws IOException {
        Path tempDir = Files.createTempDirectory("perm_test");
        File nonExistentFile = new File(tempDir.toFile(), "nonexistent.txt");
        
        System.out.println("exists: " + nonExistentFile.exists());
        System.out.println("canRead: " + nonExistentFile.canRead());
        System.out.println("canWrite: " + nonExistentFile.canWrite());
        System.out.println("canExecute: " + nonExistentFile.canExecute());
        
        Files.delete(tempDir);
    }
}

import java.io.*;
import java.util.HashSet;
import java.util.Set;

class NonSerializableItem { // Does not implement Serializable
    String data;
    public NonSerializableItem(String data) {
        this.data = data;
    }
}

public class HashSetError10 {
    public static void main(String[] args) {
        Set<NonSerializableItem> items = new HashSet<>();
        items.add(new NonSerializableItem("Test"));

        try {
            FileOutputStream fos = new FileOutputStream("set.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(items); // ERROR line
            oos.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Logger {
    public static void logMessage(String msg) {
        System.out.println("Log: " + msg);
    }
}

class FileLogger extends Logger {
    @Override
    public void logMessage(String msg) {
        System.out.println("File Log: " + msg);
    }
}

class ReentrantLockTest {
    public synchronized void methodA() {
        System.out.print("A");
        methodB();
    }
    public synchronized void methodB() {
        System.out.print("B");
    }
}

public class MyProgram {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLockTest obj = new ReentrantLockTest();
        Thread t1 = new Thread(() -> obj.methodA());
        Thread t2 = new Thread(() -> obj.methodB());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

public class ThreadBomb {
    public static void main(String[] args) {
        int i = 0;
        while (true) {
            new Thread(() -> {
                try {
                    Thread.sleep(Long.MAX_VALUE); // Keep threads alive indefinitely
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, "Thread-" + i++).start();
            System.out.println("Created thread: " + (i-1));
        }
    }
}

class Parent {
    public static void greet() {
        System.out.println("Hello from Parent");
    }
}
class Child extends Parent {
    public static void greet() {
        super.greet(); // Problematic line
        System.out.println("Hello from Child");
    }
    public static void main(String[] args) {
        Child.greet();
    }
}

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        boolean removed = numbers.remove(Integer.valueOf(2));
        System.out.println(removed + " " + numbers);
    }
}

public class Q8_DaemonThreadTermination {
    public static void main(String[] args) throws InterruptedException {
        Thread daemonThread = new Thread(() -> {
            try {
                int count = 0;
                while (true) {
                    System.out.println("Daemon running: " + count++);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                System.out.println("Daemon interrupted.");
            } finally {
                System.out.println("Daemon finally block.");
            }
        });
        daemonThread.setDaemon(true);
        daemonThread.start();
        
        Thread.sleep(250);
        System.out.println("Main thread exiting.");
    }
}