Java Core Classes and Threads

Calling run directly on a Thread executes the method synchronously in the current thread instead of starting a new thread of execution. Therefore, pm1 completes its loop printing one twice before pm2 starts its loop printing two twice.

Implementing the Runnable interface is preferred over extending the Thread class in Java because Java does not support multiple inheritance. By implementing an interface, the class remains free to inherit from another class. This approach also promotes better separation of concerns between the task execution logic and the thread mechanism.

Implementing Runnable interface is preferred over extending Thread class because Java supports only single inheritance - by implementing Runnable, your class can still extend another class if needed. It also separates the task logic from the thread execution mechanism, following better object-oriented design principles. Extending Thread should only be used when you need to override Thread methods other than run().

public, static, and void are reserved keywords in Java used for access control, modifiers, and return types. String is a class name (identifier) and main is a method name (identifier), not keywords.

Since thread foo is executing bar.wait(), it's waiting on bar's monitor. To wake it, you must call notify() or notifyAll() on the SAME object (bar). bar.notifyAll() is the most reliable as it wakes all waiting threads, ensuring foo stops waiting.

HashMap keys are unordered. Wrapping the keySet in a TreeSet (new TreeSet(s)) automatically sorts elements because TreeSet maintains natural ordering. Arrays.sort() requires arrays, Collections.sort() requires Lists, and SortedSet is an interface.

Serialization is the process of converting an object's state into a byte stream for storage or transmission. Deserialization is the reverse process - reconstructing the object from the byte stream. Option B correctly identifies that writing object state to a byte stream is called serialization.

java.util.LinkedList implements the List interface and stores elements in a doubly-linked list, allowing O(1) time complexity when adding elements to the beginning via add(0, object). However, it does not support quick random access (O(N)), meeting all requirements. ArrayList has O(N) insertion at index 0.

Boolean.valueOf("True") returns a Boolean object wrapping true. When used in an if condition, any non-null Boolean evaluates to true, so the if block executes and prints "True". The method parses the string "True" as truthy.

Five String objects are created: the literal "Fred" (1), "47" (2), concatenation "Fred47" (3), substring "ed4" (4), and uppercase "ED4" (5). The toString() call on line 16 doesn't create a new String since it just returns the object itself.

In Java, variables and declarations do not need to appear at the start of a method body. They can be declared anywhere within a method as long as they are declared before they are used. This makes the statement false, which is the correct choice.

File.createNewFile() creates the file ONLY if it does not already exist. If the file exists (like test.txt in this case), the method returns false and does nothing - it does NOT overwrite. This method only throws IOException if there's a directory issue or permission problem, not if the file exists. Option A is wrong because existing files are not overwritten.

The volatile keyword tells the JVM that a variable may be modified by multiple threads asynchronously. This prevents threads from caching the variable's value in CPU registers, ensuring all reads and writes go directly to main memory where all threads can see the latest value.

A Set in Java automatically removes duplicates because it only stores unique elements. By adding all elements from a List to a Set (like HashSet), duplicates are automatically eliminated. You can then convert back to a List if needed.