In Java, array initialization can be performed in several ways, but certain syntaxes are invalid and will cause compilation errors. Let's analyze each declaration:
* var array1 = new String[]{ "foo", "bar", "buz" };
This is a valid declaration. The var keyword allows the compiler to infer the type from the initializer. Here, new String[]{ "foo", "bar", "buz" } creates an anonymous array of String with three elements. The compiler infers array1 as String[]. This syntax is correct and compiles successfully.
* var array2[] = { "foo", "bar", "buz" };
This declaration is invalid. While var can be used for type inference, appending [] after var is not allowed.
The correct syntax would be either String[] array2 = { "foo", "bar", "buz" }; or var array2 = new String[]{
"foo", "bar", "buz" };. Therefore, this line will cause a compilation error.
* var array3 = new String[3] { "foo", "bar", "buz" };
This declaration is invalid. In Java, when specifying the size of the array (new String[3]), you cannot simultaneously provide an initializer. The correct approach is either to provide the size without an initializer (new String[3]) or to provide the initializer without specifying the size (new String[]{ "foo", "bar", "buz" }).
Therefore, this line will cause a compilation error.
* var array4 = { "foo", "bar", "buz" };
This declaration is invalid. The array initializer { "foo", "bar", "buz" } can only be used in an array declaration when the type is explicitly provided. Since var relies on type inference and there's no explicit type provided here, this will cause a compilation error. The correct syntax would be String[] array4 = { "foo",
"bar", "buz" };.
* String array5[] = new String[]{ "foo", "bar", "buz" };
This is a valid declaration. Here, String array5[] declares array5 as an array of String. The initializer new String[]{ "foo", "bar", "buz" } creates an array with three elements. This syntax is correct and compiles successfully.
Therefore, the declarations that compile successfully are array1 and array5.
References:
* Java SE 21 & JDK 21 - Local Variable Type Inference
* Java SE 21 & JDK 21 - Arrays

In the provided code, a list abc is created containing the strings "a", "b", and "c". The first forEach operation attempts to convert each element to uppercase by assigning x = x.toUpperCase();. However, this assignment only changes the local variable x within the lambda expression and does not modify the elements in the original list abc. Strings in Java are immutable, meaning their values cannot be changed once created.
Therefore, the original list remains unchanged.
The second forEach operation iterates over the original list and prints each element. Since the list was not modified, the output will be the concatenation of the original elements: abc.
To achieve the output ABC, you would need to collect the transformed elements into a new list, as shown below:
java
List<String> abc = List.of("a", "b", "c");
List<String> upperCaseAbc = abc.stream()
map(String::toUpperCase)
collect(Collectors.toList());
upperCaseAbc.forEach(System.out::print);
In this corrected version, the map operation creates a new stream with the uppercase versions of the original elements, which are then collected into a new list upperCaseAbc. The forEach operation then prints ABC.

The CopyOnWriteArrayList is a thread-safe variant of ArrayList in which all mutative operations (such as add, set, and remove) are implemented by creating a fresh copy of the underlying array. This design allows for safe iteration over the list without requiring external synchronization, as iterators operate over a snapshot of the array at the time the iterator was created. Consequently, modifications made to the list after the creation of an iterator are not reflected in that iterator.
docs.oracle.com
Evaluation of Options:
* Option A:Correct. This statement accurately describes the behavior of CopyOnWriteArrayList.
* Option B:Incorrect. CopyOnWriteArrayList is thread-safe and is designed to prevent interference among concurrent threads.
* Option C:Incorrect. Iterators of CopyOnWriteArrayList do not reflect additions, removals, or changes made to the list after the iterator was created; they operate on a snapshot of the list's state at the time of their creation.
* Option D:Incorrect. CopyOnWriteArrayList allows null elements.
* Option E:Incorrect. Element-changing operations on iterators, such as remove, set, and add, are not supported in CopyOnWriteArrayList and will throw UnsupportedOperationException.

In Java generics, wildcards are used to relax the type constraints of generic types. The extends wildcard (<?
extends Type>) denotes an upper bounded wildcard, allowing any type that is a subclass of Type. Conversely, the super wildcard (<? super Type>) denotes a lower bounded wildcard, allowing any type that is a superclass of Type.
Option A:
java
public List<? super IOException> getListSuper() {
return new ArrayList<Exception>();
}
Here, List<? super IOException> represents a list that can hold IOException objects and objects of its supertypes. Since Exception is a superclass of IOException, ArrayList<Exception> is compatible with List<?
super IOException>. Therefore, this method compiles successfully.
Option B:
java
public List<? extends IOException> getListExtends() {
return new ArrayList<FileNotFoundException>();
}
In this case, List<? extends IOException> represents a list that can hold objects of IOException and its subclasses. Since FileNotFoundException is a subclass of IOException, ArrayList<FileNotFoundException> is compatible with List<? extends IOException>. Thus, this method compiles successfully.
Option C:
java
public List<? extends IOException> getListExtends() {
return new ArrayList<Exception>();
}
Here, List<? extends IOException> expects a list of IOException or its subclasses. However, Exception is a superclass of IOException, not a subclass. Therefore, ArrayList<Exception> is not compatible with List<?
extends IOException>, and this method will not compile.
Option D:
java
public List<? super IOException> getListSuper() {
return new ArrayList<FileNotFoundException>();
}
In this scenario, List<? super IOException> expects a list that can hold IOException objects and objects of its supertypes. Since FileNotFoundException is a subclass of IOException, ArrayList<FileNotFoundException> is not compatible with List<? super IOException>, and this method will not compile.
Therefore, the methods in options A and B compile successfully, while those in options C and D do not.

In this scenario, we have a Person class that extends ListResourceBundle and a properties file named Person.
properties. Both define a resource with the key "name" but with different values:
* Person class (ListResourceBundle):Defines the key "name" with the value "Jeanne".
* Person.properties file:Defines the key "name" with the value "James".
When the ResourceBundle.getBundle("Person") method is called, the Java runtime searches for a resource bundle with the base name "Person". The search order is as follows:
* Class-Based Resource Bundle:The runtime first looks for a class named Person (i.e., Person.class).
* Properties File Resource Bundle:If the class is not found, it then looks for a properties file named Person.properties.
In this case, since the Person class is present and accessible, the runtime will load the Person class as the resource bundle. Therefore, the getBundle method returns an instance of the Person class.
Subsequently, when bundle.getString("name") is called, it retrieves the value associated with the key "name" from the Person class, which is "Jeanne".
Thus, the output of the program is:
nginx
Jeanne