Expert level java quiz

What is the purpose of the `volatile` keyword in Java?

To ensure that a variable is always accessed from the main memory and not from the thread cache

To prevent the method from being overridden

To mark a variable for garbage collection

To guarantee atomicity of a variable in multithreading

Which of the following statements is true about `hashCode()` and `equals()` methods in Java?

If two objects are equal according to `equals()`, their `hashCode()` values must be equal

If two objects are equal according to `equals()`, their `hashCode()` values may or may not be equal

If two objects have the same `hashCode()`, they are considered equal according to `equals()`

The `hashCode()` method should return a unique value for each object

Which method must be implemented in a Java class for it to be considered a valid comparator for sorting?

compareTo()

compare()

sort()

equals()

Which of the following statements is true about `Java's` reflection API?

Reflection allows you to examine and modify the behavior of classes, methods, and fields at runtime

Reflection can only be used with classes from the `java.lang` package

Reflection can only be used for private methods

Reflection allows you to directly modify the bytecode of classes

What will be the output of the following code? public class Test { public static void main(String[] args) { Integer i1 = 1000; Integer i2 = 1000; System.out.println(i1 == i2); } }

true

false

Compilation error

Runtime exception

In a `ConcurrentHashMap`, what happens when multiple threads attempt to update the same key simultaneously?

The last thread to update the key wins, and no other threads can update the key until it is unlocked

All threads' updates are merged and applied together atomically

Each thread updates the key independently, and the final value depends on the thread timing

The `ConcurrentHashMap` will throw a `ConcurrentModificationException`

What is the result of invoking `System.gc()` in Java?

It forces the JVM to immediately perform garbage collection

It requests that the JVM attempts garbage collection, but it is not guaranteed to execute immediately

It forces the JVM to stop all application threads for garbage collection

It guarantees that all unreachable objects will be cleaned up

What is the purpose of the `fork()` method in Java's `ForkJoinPool`?

It creates a new task that runs asynchronously in the thread pool

It splits the task into sub-tasks and executes them in parallel

It stops the execution of all other tasks in the pool

It creates a new thread that performs a specific task

What is the primary difference between `ArrayList` and `LinkedList` in Java?

ArrayList is faster for adding/removing elements from the middle of the list, while LinkedList is slower

LinkedList uses an array internally, while ArrayList uses a linked list

ArrayList allows random access to elements, while LinkedList does not

ArrayList uses a dynamic array, while LinkedList uses a doubly linked list

What will happen if a `finally` block contains a `return` statement in Java?

The return statement in the `finally` block will execute after the `try` or `catch` block's return

The return statement in the `finally` block will override the return statement from `try` or `catch`

The `finally` block will not execute if a return statement is present

A compilation error will occur