What will be the output of the code?

❌ A. The code will print nothing
❌ B. The code will print "NULL"
❌ C. NullPointerException will be thrown
✅ D. IllegalArgumentException will be thrown
❌ E. Compilation error
❌ F. None of the above

Explanation:
In the given code snippet, an Optional is created using the ofNullable method, passing a null reference. Then, the map method is called on the optional, applying the toUpperCase function to the value inside the Optional. Since the value inside the Optional is null, the map function will not be executed, and the Optional will remain empty.

The orElseThrow method is then called, which will throw an IllegalArgumentException if the Optional is empty. In this case, the Optional is indeed empty, as it was created with a null value. Therefore, the code will throw an IllegalArgumentException.

The correct answer is option D) IllegalArgumentException will be thrown.

What will be the output of the code?

❌ A. Hello null
❌ B. null 123
✅ C. Hello 123
❌ D. Compilation error
❌ E. Runtime error
❌ F. None of the above

Explanation:
1. Generic Class:
• The Container class is a generic class with a type parameter T.

2. Instances of Generic Class:
• Container<String> stringContainer = new Container<>(); creates a Container for String items.
• Container<Integer> integerContainer = new Container<>(); creates a Container for Integer items.

3. Setting Items:
• stringContainer.setItem("Hello"); sets the item of the stringContainer to "Hello".
• integerContainer.setItem(123); sets the item of the integerContainer to 123.

4. List of Containers:
• List<Container<?>> containerList = new ArrayList<>(); creates a list that can hold Container objects of any type.
• containerList.add(stringContainer); adds the stringContainer to the list.
• containerList.add(integerContainer); adds the integerContainer to the list.

5. Printing Items:
• The for loop iterates through each Container in the containerList.
• System.out.println(container.getItem()); prints the item stored in each Container.

Since stringContainer holds "Hello" and integerContainer holds 123, the output will be: 'Hello 123'. Thus, the correct answer is C.

What will be the output of the code?

❌ A. false true false true
❌ B. true true true true
❌ C. false false true true
❌ D. false false false true
✅ E. false true true true
❌ F. Error
❌ G. None of the above

Explanation:
1. String Pool and `intern()` Method:
- In Java, string literals (e.g., `"Hello, World!"`) are stored in the string pool.
- The intern() method returns a canonical representation for the string object. If the pool already contains a string equal to the current string object, the string from the pool is returned.

2. Line 1: `System.out.println(str1 == str2);`:
- str1 is a string literal stored in the string pool.
- str2 is a new string object created using the new keyword, so it is not in the string pool.
- The comparison == checks if both references point to the same object. Since str1 and str2 are different objects, the result is false.

3. Line 2: `System.out.println(str1 == str3);`:
- str3 is assigned directly to str1, so both references point to the same object in the string pool.
- Therefore, the result of str1 == str3 is true.

4. Line 3: `System.out.println(str1 == str4);`:
- str4 is str2.intern(), which returns the reference from the string pool.
- Since str1 is already in the string pool and str4 is now the interned version of str2, both point to the same object.
- Thus, str1 == str4 is true.

5. Line 4: `System.out.println(str1 == str5);`:
- str5 is the result of string concatenation using literals "Hello, " and "World!". This concatenation is resolved at compile time, and the resulting string is stored in the string pool.
- Since str1 is "Hello, World!" and str5 is also "Hello, World!" stored in the pool, str1 == str5 is true.

Output:

false  
true  
true  
true

Correct Answer: E

What will be the output of the code?

❌ A. LinkedHashMap: {B=5, A=2, C=1, E=3, D=4}; TreeMap: {B=5, D=4, E=3, A=2, C=1}
❌ B. LinkedHashMap: {B=5, A=2, C=1, D=4, E=3}; TreeMap: {B=5, A=2, C=1, D=4, E=3}
❌ C. LinkedHashMap: {A=2, B=5, C=1, D=4, E=3}; TreeMap: {C=1, A=2, E=3, D=4, B=5}
✅ D. LinkedHashMap: {A=2, B=5, C=1, D=4, E=3}; TreeMap: {B=5, D=4, E=3, A=2, C=1}
❌ E. Error
❌ F. None of the above

Explanation:
1. LinkedHashMap Behavior:
• LinkedHashMap maintains the insertion order of elements.
• Here, linkedHashMap will display entries in the exact order they were inserted: {A=2, B=5, C=1, D=4, E=3}.

2. TreeMap with Custom Comparator:
• TreeMap typically orders entries based on the natural order of keys, but here it uses a custom comparator to sort entries in descending order based on values from linkedHashMap.
• Comparator.comparingInt(linkedHashMap::get).reversed() sorts treeMap by values in descending order, resulting in {B=5, D=4, E=3, A=2, C=1}.

3. Expected Output:
• The LinkedHashMap output maintains the insertion order.
• The TreeMap output shows entries sorted by values in descending order based on linkedHashMap values.

Correct Answer: D

What will be the output of the code?

❌ A. Result1: 9 Result2: Hello, World!
✅ B. Result1: 10 Result2: Hello, World!
❌ C. Result1: 12 Result2: Hello, World!
❌ D. Result1: 10 Result2: Hello,World!
❌ E. Result1: 12 Result2: Hello,World!
❌ F. Error
❌ G. None of the above

Explanation:
1. square Function:
- Computes the square of the input: x -> x * x.

2. increment Function:
- Adds 1 to the input: x -> x + 1.

3. Function Composition (`andThen`):
- Combines square and increment:
- Input 3:
- First: 3^2 = 9.
- Then: 9 + 1 = 10.

4. Method Reference (`String::concat`):
- Concatenates strings:
concat.apply("Hello, ", "World!") -> Hello, World!.

Correct Answer: B

What will be the output of the code?

❌ A. Max Integer: 4 Max Double: 3.3
❌ B. Max Integer: 2 Max Double: 2.2
❌ C. Max Integer: 1 Max Double: 1.1
✅ D. Compilation error
❌ E. Runtime error

Explanation:
1. Method Overloading with Generics:
• There are two overloaded findMax methods, one using extends Number and the other using extends Comparable<T>.
• findMax(List<T extends Number>): Compares Number values using doubleValue() for comparison.
• findMax(List<T extends Comparable<T>>): Compares values using the compareTo method, which is available for all classes implementing Comparable.

2. Type Inference and Ambiguity:
• When the findMax method is called with List<Integer> or List<Double>, Java tries to infer which method to use.
• Both Integer and Double implement Comparable<T>, so both methods are applicable.
• This results in a method ambiguity error because Java cannot decide whether to use doubleValue() or compareTo() to compare the elements.

3. Compilation Error:
• The ambiguity occurs because the Comparable interface is implemented by both Integer and Double, which causes the compiler to be unable to choose between the two overloaded methods.

Correct answer: D

What will be the output of the code?

✅ A. Initializing Helper Ready Cleaning
❌ B. Initializing Helper Ready HelperService: Cleaning Cleaning
❌ C. Helper Ready Initializing Helper Ready Cleaning
❌ D. Compilation Error: Missing @Component annotation on MyService
❌ E. None of the above

Explanation:
1. Configuration and Bean Lifecycle:
• AppConfig is annotated with Configuration, marking it as the configuration class.
• Bean(initMethod = "init", destroyMethod = "cleanup") defines the lifecycle methods for MyService.
2. Dependency Injection:
• MyService has a Autowired field, injecting the HelperService bean. Spring automatically resolves the dependency.
3. Lifecycle Methods:
• The init method of MyService is called after the bean is instantiated.
• The cleanup method is called when the context is closed.
4. Output Order:
• Initializing is printed when init() is invoked.
• The process() method prints the message from HelperService: Helper Ready.
• Cleaning is printed during context closure.

Correct answer: A