1z1-830試験問題を今すぐ試そう！最新の[2025年最新] 正解回答付き [Q36-Q61]

1z1-830試験問題を今すぐ試そう！最新の[2025年最新] 正解回答付き

練習できる1z1-830には認定ガイド問題と解答とトレーニングを提供しています

質問 # 36
Which of the following suggestions compile?(Choose two.)

• A. java
  sealed class Figure permits Rectangle {}
  public class Rectangle extends Figure {
  float length, width;
  }
• B. java
  public sealed class Figure
  permits Circle, Rectangle {}
  final sealed class Circle extends Figure {
  float radius;
  }
  non-sealed class Rectangle extends Figure {
  float length, width;
  }
• C. java
  public sealed class Figure
  permits Circle, Rectangle {}
  final class Circle extends Figure {
  float radius;
  }
  non-sealed class Rectangle extends Figure {
  float length, width;
  }
• D. java
  sealed class Figure permits Rectangle {}
  final class Rectangle extends Figure {
  float length, width;
  }

正解：C、D

解説：
Option A (sealed class Figure permits Rectangle {} and final class Rectangle extends Figure {}) - Valid
* Why it compiles?
* Figure issealed, meaning itmust explicitly declareits subclasses.
* Rectangle ispermittedto extend Figure and isdeclared final, meaning itcannot be extended further.
* This followsvalid sealed class rules.
Option B (sealed class Figure permits Rectangle {} and public class Rectangle extends Figure {}) -# Invalid
* Why it fails?
* Rectangle extends Figure, but it doesnot specify if it is sealed, final, or non-sealed.
* Fix:The correct declaration must be one of the following:
java
final class Rectangle extends Figure {} // OR
sealed class Rectangle permits OtherClass {} // OR
non-sealed class Rectangle extends Figure {}
Option C (final sealed class Circle extends Figure {}) -#Invalid
* Why it fails?
* A class cannot be both final and sealedat the same time.
* sealed meansit must have permitted subclasses, but final meansit cannot be extended.
* Fix:Change final sealed to just final:
java
final class Circle extends Figure {}
Option D (public sealed class Figure permits Circle, Rectangle {} with final class Circle and non-sealed class Rectangle) - Valid
* Why it compiles?
* Figure issealed, meaning it mustdeclare its permitted subclasses(Circle and Rectangle).
* Circle is declaredfinal, so itcannot have subclasses.
* Rectangle is declarednon-sealed, meaningit can be subclassedfreely.
* This correctly followsJava's sealed class rules.
Thus, the correct answers are:A, D
References:
* Java SE 21 - Sealed Classes
* Java SE 21 - Class Modifiers

質問 # 37
Given:
java
public class Test {
public static void main(String[] args) throws IOException {
Path p1 = Path.of("f1.txt");
Path p2 = Path.of("f2.txt");
Files.move(p1, p2);
Files.delete(p1);
}
}
In which case does the given program throw an exception?

• A. Neither files f1.txt nor f2.txt exist
• B. Both files f1.txt and f2.txt exist
• C. An exception is always thrown
• D. File f1.txt exists while file f2.txt doesn't
• E. File f2.txt exists while file f1.txt doesn't

正解：C

解説：
In this program, the following operations are performed:
* Paths Initialization:
* Path p1 is set to "f1.txt".
* Path p2 is set to "f2.txt".
* File Move Operation:
* Files.move(p1, p2); attempts to move (or rename) f1.txt to f2.txt.
* File Delete Operation:
* Files.delete(p1); attempts to delete f1.txt.
Analysis:
* If f1.txt Does Not Exist:
* The Files.move(p1, p2); operation will throw a NoSuchFileException because the source file f1.
txt is missing.
* If f1.txt Exists and f2.txt Does Not Exist:
* The Files.move(p1, p2); operation will successfully rename f1.txt to f2.txt.
* Subsequently, the Files.delete(p1); operation will throw a NoSuchFileException because p1 (now f1.txt) no longer exists after the move.
* If Both f1.txt and f2.txt Exist:
* The Files.move(p1, p2); operation will throw a FileAlreadyExistsException because the target file f2.txt already exists.
* If f2.txt Exists While f1.txt Does Not:
* Similar to the first scenario, the Files.move(p1, p2); operation will throw a NoSuchFileException due to the absence of f1.txt.
In all possible scenarios, an exception is thrown during the execution of the program.

質問 # 38
Given:
java
public class Test {
static int count;
synchronized Test() {
count++;
}
public static void main(String[] args) throws InterruptedException {
Runnable task = Test::new;
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
}
}
What is the given program's output?

• A. Compilation fails
• B. It's always 1
• C. It's always 2
• D. It's either 0 or 1
• E. It's either 1 or 2

正解：A

解説：
In this code, the Test class has a static integer field count and a constructor that is declared with the synchronized modifier. In Java, the synchronized modifier can be applied to methods to control access to critical sections, but it cannot be applied directly to constructors. Attempting to declare a constructor as synchronized will result in a compilation error.
Compilation Error Details:
The Java Language Specification does not permit the use of the synchronized modifier on constructors.
Therefore, the compiler will produce an error indicating that the synchronized modifier is not allowed in this context.
Correct Usage:
If you need to synchronize the initialization of instances, you can use a synchronized block within the constructor:
java
public class Test {
static int count;
Test() {
synchronized (Test.class) {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
Runnable task = Test::new;
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
}
}
In this corrected version, the synchronized block within the constructor ensures that the increment operation on count is thread-safe.
Conclusion:
The original program will fail to compile due to the illegal use of the synchronized modifier on the constructor. Therefore, the correct answer is E: Compilation fails.

質問 # 39
Which of the following statements is correct about a final class?

• A. It cannot be extended by any other class.
• B. It must contain at least a final method.
• C. The final keyword in its declaration must go right before the class keyword.
• D. It cannot extend another class.
• E. It cannot implement any interface.

正解：A

解説：
In Java, the final keyword can be applied to classes, methods, and variables to impose certain restrictions.
Final Classes:
* Definition:A class declared with the final keyword is known as a final class.
* Purpose:Declaring a class as final prevents it from being subclassed. This is useful when you want to ensure that the class's implementation remains unchanged and cannot be extended or modified through inheritance.
Option Evaluations:
* A. The final keyword in its declaration must go right before the class keyword.
* This is correct. The syntax for declaring a final class is:
java
public final class ClassName {
// class body
}
* However, this statement is about syntax rather than the core characteristic of a final class.
* B. It must contain at least a final method.
* Incorrect. A final class can have zero or more methods, and none of them are required to be declared as final. The final keyword at the class level prevents inheritance, regardless of the methods' finality.
* C. It cannot be extended by any other class.
* Correct. The primary characteristic of a final class is that it cannot be subclassed. Attempting to do so will result in a compilation error.
* D. It cannot implement any interface.
* Incorrect. A final class can implement interfaces. Declaring a class as final restricts inheritance but does not prevent the class from implementing interfaces.
* E. It cannot extend another class.
* Incorrect. A final class can extend another class. The final keyword prevents the class from being subclassed but does not prevent it from being a subclass itself.
Therefore, the correct statement about a final class is option C: "It cannot be extended by any other class."

質問 # 40
Given:
java
ExecutorService service = Executors.newFixedThreadPool(2);
Runnable task = () -> System.out.println("Task is complete");
service.submit(task);
service.shutdown();
service.submit(task);
What happens when executing the given code fragment?

• A. It prints "Task is complete" twice and throws an exception.
• B. It prints "Task is complete" once and throws an exception.
• C. It prints "Task is complete" once, then exits normally.
• D. It prints "Task is complete" twice, then exits normally.
• E. It exits normally without printing anything to the console.

正解：B

解説：
In this code, an ExecutorService is created with a fixed thread pool of size 2 using Executors.
newFixedThreadPool(2). A Runnable task is defined to print "Task is complete" to the console.
The sequence of operations is as follows:
* service.submit(task);
This submits the task to the executor service for execution. Since the thread pool has a size of 2 and no other tasks are running, this task will be executed promptly, printing "Task is complete" to the console.
* service.shutdown();
This initiates an orderly shutdown of the executor service. In this state, the service stops accepting new tasks

質問 # 41
Given:
java
DoubleStream doubleStream = DoubleStream.of(3.3, 4, 5.25, 6.66);
Predicate<Double> doublePredicate = d -> d < 5;
System.out.println(doubleStream.anyMatch(doublePredicate));
What is printed?

• A. true
• B. Compilation fails
• C. An exception is thrown at runtime
• D. false
• E. 3.3

正解：B

解説：
In this code, there is a type mismatch between the DoubleStream and the Predicate<Double>.
* DoubleStream: A sequence of primitive double values.
* Predicate<Double>: A functional interface that operates on objects of type Double (the wrapper class), not on primitive double values.
The DoubleStream class provides a method anyMatch(DoublePredicate predicate), where DoublePredicate is a functional interface that operates on primitive double values. However, in the code, a Predicate<Double> is used instead of a DoublePredicate. This mismatch leads to a compilation error because anyMatch cannot accept a Predicate<Double> when working with a DoubleStream.
To correct this, the predicate should be defined as a DoublePredicate to match the primitive double type:
java
DoubleStream doubleStream = DoubleStream.of(3.3, 4, 5.25, 6.66);
DoublePredicate doublePredicate = d -> d < 5;
System.out.println(doubleStream.anyMatch(doublePredicate));
With this correction, the code will compile and print true because there are elements in the stream (e.g., 3.3 and 4.0) that are less than 5.

質問 # 42
Given:
java
Optional o1 = Optional.empty();
Optional o2 = Optional.of(1);
Optional o3 = Stream.of(o1, o2)
.filter(Optional::isPresent)
.findAny()
.flatMap(o -> o);
System.out.println(o3.orElse(2));
What is the given code fragment's output?

• A. 0
• B. 1
• C. Compilation fails
• D. Optional.empty
• E. 2
• F. An exception is thrown
• G. Optional[1]

正解：B

解説：
In this code, two Optional objects are created:
* o1 is an empty Optional.
* o2 is an Optional containing the integer 1.
A stream is created from o1 and o2. The filter method retains only the Optional instances that are present (i.e., non-empty). This results in a stream containing only o2.
The findAny method returns an Optional describing some element of the stream, or an empty Optional if the stream is empty. Since the stream contains o2, findAny returns Optional[Optional[1]].
The flatMap method is then used to flatten this nested Optional. It applies the provided mapping function (o -
> o) to the value, resulting in Optional[1].
Finally, o3.orElse(2) returns the value contained in o3 if it is present; otherwise, it returns 2. Since o3 contains
1, the output is 1.

質問 # 43
Given:
java
interface A {
default void ma() {
}
}
interface B extends A {
static void mb() {
}
}
interface C extends B {
void ma();
void mc();
}
interface D extends C {
void md();
}
interface E extends D {
default void ma() {
}
default void mb() {
}
default void mc() {
}
}
Which interface can be the target of a lambda expression?

• A. B
• B. C
• C. None of the above
• D. D
• E. A
• F. E

正解：C

解説：
In Java, a lambda expression can be used where a target type is a functional interface. A functional interface is an interface that contains exactly one abstract method. This concept is also known as a Single Abstract Method (SAM) type.
Analyzing each interface:
* Interface A: Contains a single default method ma(). Since default methods are not abstract, A has no abstract methods.
* Interface B: Extends A and adds a static method mb(). Static methods are also not abstract, so B has no abstract methods.
* Interface C: Extends B and declares two abstract methods: ma() (which overrides the default method from A) and mc(). Therefore, C has two abstract methods.
* Interface D: Extends C and adds another abstract method md(). Thus, D has three abstract methods.
* Interface E: Extends D and provides default implementations for ma(), mb(), and mc(). However, it does not provide an implementation for md(), leaving it as the only abstract method in E.
For an interface to be a functional interface, it must have exactly one abstract method. In this case, E has one abstract method (md()), so it qualifies as a functional interface. However, the question asks which interface can be the target of a lambda expression. Since E is a functional interface, it can be the target of a lambda expression.
Therefore, the correct answer is D (E).

質問 # 44
Given a properties file on the classpath named Person.properties with the content:
ini
name=James
And:
java
public class Person extends ListResourceBundle {
protected Object[][] getContents() {
return new Object[][]{
{"name", "Jeanne"}
};
}
}
And:
java
public class Test {
public static void main(String[] args) {
ResourceBundle bundle = ResourceBundle.getBundle("Person");
String name = bundle.getString("name");
System.out.println(name);
}
}
What is the given program's output?

• A. James
• B. Jeanne
• C. MissingResourceException
• D. JamesJeanne
• E. Compilation fails
• F. JeanneJames

正解：B

解説：
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

質問 # 45
Given:
java
public class ThisCalls {
public ThisCalls() {
this(true);
}
public ThisCalls(boolean flag) {
this();
}
}
Which statement is correct?

• A. It throws an exception at runtime.
• B. It compiles.
• C. It does not compile.

正解：C

解説：
In the provided code, the class ThisCalls has two constructors:
* No-Argument Constructor (ThisCalls()):
* This constructor calls the boolean constructor with this(true);.
* Boolean Constructor (ThisCalls(boolean flag)):
* This constructor attempts to call the no-argument constructor with this();.
This setup creates a circular call between the two constructors:
* The no-argument constructor calls the boolean constructor.
* The boolean constructor calls the no-argument constructor.
Such a circular constructor invocation leads to a compile-time error in Java, specifically "recursiveconstructor invocation." The Java Language Specification (JLS) states:
"It is a compile-time error for a constructor to directly or indirectly invoke itself through a series of one or more explicit constructor invocations involving this." Therefore, the code will not compile due to this recursive constructor invocation.

質問 # 46
A module com.eiffeltower.shop with the related sources in the src directory.
That module requires com.eiffeltower.membership, available in a JAR located in the lib directory.
What is the command to compile the module com.eiffeltower.shop?

• A. css
  CopyEdit
  javac --module-source-path src -p lib/com.eiffel.membership.jar -s out -m com.eiffeltower.shop
• B. bash
  CopyEdit
  javac -source src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop
• C. css
  CopyEdit
  javac --module-source-path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop
• D. css
  CopyEdit
  javac -path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop

正解：C

解説：
Comprehensive and Detailed In-Depth Explanation:
Understanding Java Module Compilation (javac)
Java modules are compiled using the javac command with specific options to specify:
* Where the source files are located (--module-source-path)
* Where required dependencies (external modules) are located (-p / --module-path)
* Where the compiled output should be placed (-d)
Breaking Down the Correct Compilation Command
css
CopyEdit
javac --module-source-path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop
* --module-source-path src # Specifies the directory where module sources are located.
* -p lib/com.eiffel.membership.jar # Specifies the module path (JAR dependency in lib).
* -d out # Specifies the output directory for compiled .class files.
* -m com.eiffeltower.shop # Specifies the module to compile (com.eiffeltower.shop).

質問 # 47
Given:
java
double amount = 42_000.00;
NumberFormat format = NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.
SHORT);
System.out.println(format.format(amount));
What is the output?

• A. 42000E
• B. 42 k
• C. 42 000,00 €
• D. 0

正解：B

解説：
In this code, a double variable amount is initialized to 42,000.00. The NumberFormat.
getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.SHORT) method is used to obtain a compact number formatter for the French locale with the short style. The format method is then called to format the amount.
The compact number formatting is designed to represent numbers in a shorter form, based on the patterns provided for a given locale. In the French locale, the short style represents thousands with a lowercase 'k'.
Therefore, 42,000 is formatted as 42 k.
* Option Evaluations:
* A. 42000E: This format is not standard in the French locale for compact number formatting.
* B. 42 000,00 €: This represents the number as a currency with two decimal places, which is not the compact form.
* C. 42000: This is the plain number without any formatting, which does not match the compact number format.
* D. 42 k: This is the correct compact representation of 42,000 in the French locale with the short style.
Thus, option D (42 k) is the correct output.

質問 # 48
What does the following code print?
java
import java.util.stream.Stream;
public class StreamReduce {
public static void main(String[] args) {
Stream<String> stream = Stream.of("J", "a", "v", "a");
System.out.print(stream.reduce(String::concat));
}
}

• A. Java
• B. Optional[Java]
• C. Compilation fails
• D. null

正解：B

解説：
In this code, a Stream of String elements is created containing the characters "J", "a", "v", and "a". The reduce method is then used with String::concat as the accumulator function.
The reduce method with a single BinaryOperator parameter performs a reduction on the elements of the stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any. In this case, it concatenates the strings in the stream.
Since the stream contains elements, the reduction operation concatenates them to form the string "Java". The result is wrapped in an Optional, resulting in Optional[Java]. The print statement outputs this Optional object, displaying Optional[Java].

質問 # 49
Given:
java
try (FileOutputStream fos = new FileOutputStream("t.tmp");
ObjectOutputStream oos = new ObjectOutputStream(fos)) {
fos.write("Today");
fos.writeObject("Today");
oos.write("Today");
oos.writeObject("Today");
} catch (Exception ex) {
// handle exception
}
Which statement compiles?

• A. oos.write("Today");
• B. fos.write("Today");
• C. oos.writeObject("Today");
• D. fos.writeObject("Today");

正解：C

解説：
In Java, FileOutputStream and ObjectOutputStream are used for writing data to files, but they have different purposes and methods. Let's analyze each statement:
* fos.write("Today");
The FileOutputStream class is designed to write raw byte streams to files. The write method in FileOutputStream expects a parameter of type int or byte[]. Since "Today" is a String, passing it directly to fos.
write("Today"); will cause a compilation error because there is no write method in FileOutputStream that accepts a String parameter.
* fos.writeObject("Today");
The FileOutputStream class does not have a method named writeObject. The writeObject method is specific to ObjectOutputStream. Therefore, attempting to call fos.writeObject("Today"); will result in a compilation error.
* oos.write("Today");
The ObjectOutputStream class is used to write objects to an output stream. However, it does not have a write method that accepts a String parameter. The available write methods in ObjectOutputStream are for writing primitive data types and objects. Therefore, oos.write("Today"); will cause a compilation error.
* oos.writeObject("Today");
The ObjectOutputStream class provides the writeObject method, which is used to serialize objects and write them to the output stream. Since String implements the Serializable interface, "Today" can be serialized.
Therefore, oos.writeObject("Today"); is valid and compiles successfully.
In summary, the only statement that compiles without errors is oos.writeObject("Today");.
References:
* Java SE 21 & JDK 21 - ObjectOutputStream
* Java SE 21 & JDK 21 - FileOutputStream

質問 # 50
Which two of the following aren't the correct ways to create a Stream?

• A. Stream stream = Stream.ofNullable("a");
• B. Stream stream = Stream.of();
• C. Stream stream = new Stream();
• D. Stream stream = Stream.empty();
• E. Stream stream = Stream.generate(() -> "a");
• F. Stream<String> stream = Stream.builder().add("a").build();

正解：C、F

質問 # 51
Consider the following methods to load an implementation of MyService using ServiceLoader. Which of the methods are correct? (Choose all that apply)

• A. MyService service = ServiceLoader.load(MyService.class).findFirst().get();
• B. MyService service = ServiceLoader.services(MyService.class).getFirstInstance();
• C. MyService service = ServiceLoader.getService(MyService.class);
• D. MyService service = ServiceLoader.load(MyService.class).iterator().next();

正解：A、D

解説：
The ServiceLoader class in Java is used to load service providers implementing a given service interface. The following methods are evaluated for their correctness in loading an implementation of MyService:
* A. MyService service = ServiceLoader.load(MyService.class).iterator().next(); This method uses the ServiceLoader.load(MyService.class) to create a ServiceLoader instance for MyService.
Calling iterator().next() retrieves the next available service provider. If no providers are available, a NoSuchElementException will be thrown. This approach is correct but requires handling the potential exception if no providers are found.
* B. MyService service = ServiceLoader.load(MyService.class).findFirst().get(); This method utilizes the findFirst() method introduced in Java 9, which returns an Optional describing the first available service provider. Calling get() on the Optional retrieves the service provider if present; otherwise, a NoSuchElementException is thrown. This approach is correct and provides a more concise way to obtain the first service provider.
* C. MyService service = ServiceLoader.getService(MyService.class);
The ServiceLoader class does not have a method named getService. Therefore, this method is incorrect and will result in a compilation error.
* D. MyService service = ServiceLoader.services(MyService.class).getFirstInstance(); The ServiceLoader class does not have a method named services or getFirstInstance. Therefore, this method is incorrect and will result in a compilation error.
In summary, options A and B are correct methods to load an implementation of MyService using ServiceLoader.

質問 # 52
Given:
java
record WithInstanceField(String foo, int bar) {
double fuz;
}
record WithStaticField(String foo, int bar) {
static double wiz;
}
record ExtendingClass(String foo) extends Exception {}
record ImplementingInterface(String foo) implements Cloneable {}
Which records compile? (Select 2)

• A. WithStaticField
• B. WithInstanceField
• C. ExtendingClass
• D. ImplementingInterface

正解：A、D

解説：
In Java, records are a special kind of class designed to act as transparent carriers for immutabledata. They automatically provide implementations for equals(), hashCode(), and toString(), and their fields are final and private by default.
* Option A: ExtendingClass
* Analysis: Records in Java implicitly extend java.lang.Record and cannot extend any other class because Java does not support multiple inheritance. Attempting to extend another class, such as Exception, will result in a compilation error.
* Conclusion: Does not compile.
* Option B: WithInstanceField
* Analysis: Records do not allow the declaration of instance fields outside of their components.
The declaration of double fuz; is not permitted and will cause a compilation error.
* Conclusion: Does not compile.
* Option C: ImplementingInterface
* Analysis: Records can implement interfaces. In this case, ImplementingInterface implements Cloneable, which is valid.
* Conclusion: Compiles successfully.

質問 # 53
How would you create a ConcurrentHashMap configured to allow a maximum of 10 concurrent writer threads and an initial capacity of 42?
Which of the following options meets this requirement?

• A. var concurrentHashMap = new ConcurrentHashMap();
• B. var concurrentHashMap = new ConcurrentHashMap(42);
• C. None of the suggestions.
• D. var concurrentHashMap = new ConcurrentHashMap(42, 10);
• E. var concurrentHashMap = new ConcurrentHashMap(42, 0.88f, 10);

正解：E

解説：
In Java, the ConcurrentHashMap class provides several constructors that allow for the customization of its initial capacity, load factor, and concurrency level. To configure a ConcurrentHashMap with an initial capacity of 42 and a concurrency level of 10, you can use the following constructor:
java
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) Parameters:
* initialCapacity: The initial capacity of the hash table. This is the number of buckets that the hash table will have when it is created. In this case, it is set to 42.
* loadFactor: A measure of how full the hash table is allowed to get before it is resized. The default value is 0.75, but in this case, it is set to 0.88.
* concurrencyLevel: The estimated number of concurrently updating threads. This is used as a hint for internal sizing. In this case, it is set to 10.
Therefore, to create a ConcurrentHashMap with an initial capacity of 42, a load factor of 0.88, and a concurrency level of 10, you can use the following code:
java
var concurrentHashMap = new ConcurrentHashMap<>(42, 0.88f, 10);
Option Evaluations:
* A. var concurrentHashMap = new ConcurrentHashMap(42);: This constructor sets the initial capacity to 42 but uses the default load factor (0.75) and concurrency level (16). It does not meet the requirement of setting the concurrency level to 10.
* B. None of the suggestions.: This is incorrect because option E provides the correct configuration.
* C. var concurrentHashMap = new ConcurrentHashMap();: This uses the default constructor, which sets the initial capacity to 16, the load factor to 0.75, and the concurrency level to 16. It does not meet the specified requirements.
* D. var concurrentHashMap = new ConcurrentHashMap(42, 10);: This constructor sets the initial capacity to 42 and the load factor to 10, which is incorrect because the load factor should be a float value between 0 and 1.
* E. var concurrentHashMap = new ConcurrentHashMap(42, 0.88f, 10);: This correctly sets the initial capacity to 42, the load factor to 0.88, and the concurrency level to 10, meeting all the specified requirements.
Therefore, the correct answer is option E.

質問 # 54
Which of the following methods of java.util.function.Predicate aredefault methods?

• A. not(Predicate<? super T> target)
• B. isEqual(Object targetRef)
• C. negate()
• D. or(Predicate<? super T> other)
• E. and(Predicate<? super T> other)
• F. test(T t)

正解：C、D、E

解説：
* Understanding java.util.function.Predicate<T>
* The Predicate<T> interface represents a function thattakes an input and returns a boolean(true or false).
* It is often used for filtering operations in functional programming and streams.
* Analyzing the Methods:
* and(Predicate<? super T> other)#Default method
* Combines two predicates usinglogical AND(&&).
java
Predicate<String> startsWithA = s -> s.startsWith("A");
Predicate<String> hasLength3 = s -> s.length() == 3;
Predicate<String> combined = startsWithA.and(hasLength3);
* #isEqual(Object targetRef)#Static method
* Not a default method, because it doesnot operate on an instance.
java
Predicate<String> isEqualToHello = Predicate.isEqual("Hello");
* negate()#Default method
* Negates a predicate (! operator).
java
Predicate<String> notEmpty = s -> !s.isEmpty();
Predicate<String> isEmpty = notEmpty.negate();
* #not(Predicate<? super T> target)#Static method (introduced in Java 11)
* Not a default method, since it is static.
* or(Predicate<? super T> other)#Default method
* Combines two predicates usinglogical OR(||).
* #test(T t)#Abstract method
* Not a default method, because every predicatemust implement this method.
Thus, the correct answers are:and(Predicate<? super T> other), negate(), or(Predicate<? super T> other) References:
* Java SE 21 - Predicate Interface
* Java SE 21 - Functional Interfaces

質問 # 55
Given:
java
var now = LocalDate.now();
var format1 = new DateTimeFormatter(ISO_WEEK_DATE);
var format2 = DateTimeFormatter.ISO_WEEK_DATE;
var format3 = new DateFormat(WEEK_OF_YEAR_FIELD);
var format4 = DateFormat.getDateInstance(WEEK_OF_YEAR_FIELD);
System.out.println(now.format(REPLACE_HERE));
Which variable prints 2025-W01-2 (present-day is 12/31/2024)?

• A. format1
• B. format3
• C. format2
• D. format4

正解：C

解説：
In this code, now is assigned the current date using LocalDate.now(). The goal is to format this date to the ISO week date format, which represents dates in the YYYY-'W'WW-E pattern, where:
* YYYY: Week-based year
* 'W': Literal 'W' character
* WW: Week number
* E: Day of the week
Given that the present day is December 31, 2024, this date falls in the first week of the week-based year 2025.
Therefore, the ISO week date representation would be 2025-W01-2, where '2' denotes Tuesday.
Among the provided formatters:
* format1: This line attempts to create a DateTimeFormatter using a constructor, which is incorrect because DateTimeFormatter does not have a public constructor that accepts a pattern directly. This would result in a compilation error.
* format2: This is correctly assigned the predefined DateTimeFormatter.ISO_WEEK_DATE, which formats dates in the ISO week date format.
* format3: This line attempts to create a DateFormat instance using a field, which is incorrect because DateFormat does not have such a constructor. This would result in a compilation error.
* format4: This line attempts to get a DateFormat instance using an integer field, which is incorrect because DateFormat.getDateInstance() does not accept such parameters. This would result in a compilation error.
Therefore, the only correct and applicable formatter is format2. Using format2 in the now.format() method will produce the desired output: 2025-W01-2.

質問 # 56
Which of the following statements are correct?

• A. You can use 'final' modifier with all kinds of classes
• B. You can use 'private' access modifier with all kinds of classes
• C. You can use 'public' access modifier with all kinds of classes
• D. You can use 'protected' access modifier with all kinds of classes
• E. None

正解：E

解説：
1. private Access Modifier
* The private access modifiercan only be used for inner classes(nested classes).
* Top-level classes cannot be private.
* Example ofinvaliduse:
java
private class MyClass {} // Compilation error
* Example ofvaliduse (for inner class):
java
class Outer {
private class Inner {}
}
2. protected Access Modifier
* Top-level classes cannot be protected.
* protectedonly applies to members (fields, methods, and constructors).
* Example ofinvaliduse:
java
protected class MyClass {} // Compilation error
* Example ofvaliduse (for methods/fields):
java
class Parent {
protected void display() {}
}
3. public Access Modifier
* Atop-level class can be public, butonly one public class per file is allowed.
* Example ofvaliduse:
java
public class MyClass {}
* Example ofinvaliduse:
java
public class A {}
public class B {} // Compilation error: Only one public class per file
4. final Modifier
* finalcan be used with classes, but not all kinds of classes.
* Interfaces cannot be final, because they are meant to be implemented.
* Example ofinvaliduse:
java
final interface MyInterface {} // Compilation error
Thus,none of the statements are fully correct, making the correct answer:None References:
* Java SE 21 - Access Modifiers
* Java SE 21 - Class Modifiers

質問 # 57
Given:
java
String s = " ";
System.out.print("[" + s.strip());
s = " hello ";
System.out.print("," + s.strip());
s = "h i ";
System.out.print("," + s.strip() + "]");
What is printed?

• A. [,hello,hi]
• B. [ , hello ,hi ]
• C. [ ,hello,h i]
• D. [,hello,h i]

正解：D

解説：
In this code, the strip() method is used to remove leading and trailing whitespace from strings. The strip() method, introduced in Java 11, is Unicode-aware and removes all leading and trailing characters that are considered whitespace according to the Unicode standard.
docs.oracle.com
Analysis of Each Statement:
* First Statement:
java
String s = " ";
System.out.print("[" + s.strip());
* The string s contains four spaces.
* Applying s.strip() removes all leading and trailing spaces, resulting in an empty string.
* The output is "[" followed by the empty string, so the printed result is "[".
* Second Statement:
java
s = " hello ";
System.out.print("," + s.strip());
* The string s is now " hello ".
* Applying s.strip() removes all leading and trailing spaces, resulting in "hello".
* The output is "," followed by "hello", so the printed result is ",hello".
* Third Statement:
java
s = "h i ";
System.out.print("," + s.strip() + "]");
* The string s is now "h i ".
* Applying s.strip() removes the trailing spaces, resulting in "h i".
* The output is "," followed by "h i" and then "]", so the printed result is ",h i]".
Combined Output:
Combining all parts, the final output is:
css
[,hello,h i]

質問 # 58
Which of the followingisn'ta correct way to write a string to a file?

• A. None of the suggestions
• B. java
  try (PrintWriter printWriter = new PrintWriter("file.txt")) {
  printWriter.printf("Hello %s", "James");
  }
• C. java
  try (FileWriter writer = new FileWriter("file.txt")) {
  writer.write("Hello");
  }
• D. java
  Path path = Paths.get("file.txt");
  byte[] strBytes = "Hello".getBytes();
  Files.write(path, strBytes);
• E. java
  try (FileOutputStream outputStream = new FileOutputStream("file.txt")) { byte[] strBytes = "Hello".getBytes(); outputStream.write(strBytes);
  }
• F. java
  try (BufferedWriter writer = new BufferedWriter("file.txt")) {
  writer.write("Hello");
  }

正解：F

解説：
(BufferedWriter writer = new BufferedWriter("file.txt") is incorrect.)
Theincorrect statementisoption Bbecause BufferedWriterdoes nothave a constructor that accepts a String (file name) directly. The correct way to use BufferedWriter is to wrap it around a FileWriter, like this:
java
try (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) { writer.write("Hello");
}
Evaluation of Other Options:
Option A (Files.write)# Correct
* Uses Files.write() to write bytes to a file.
* Efficient and concise method for writing small text files.
Option C (FileOutputStream)# Correct
* Uses a FileOutputStream to write raw bytes to a file.
* Works for both text and binary data.
Option D (PrintWriter)# Correct
* Uses PrintWriter for formatted text output.
Option F (FileWriter)# Correct
* Uses FileWriter to write text data.
Option E (None of the suggestions)# Incorrect becauseoption Bis incorrect.

質問 # 59
Given:
java
Object myVar = 0;
String print = switch (myVar) {
case int i -> "integer";
case long l -> "long";
case String s -> "string";
default -> "";
};
System.out.println(print);
What is printed?

• A. It throws an exception at runtime.
• B. integer
• C. Compilation fails.
• D. string
• E. nothing
• F. long

正解：C

解説：
* Why does the compilation fail?
* TheJava switch statement does not support primitive type pattern matchingin switch expressions as of Java 21.
* The case pattern case int i -> "integer"; isinvalidbecausepattern matching with primitive types (like int or long) is not yet supported in switch statements.
* The error occurs at case int i -> "integer";, leading to acompilation failure.
* Correcting the Code
* Since myVar is of type Object,autoboxing converts 0 into an Integer.
* To make the code compile, we should use Integer instead of int:
java
Object myVar = 0;
String print = switch (myVar) {
case Integer i -> "integer";
case Long l -> "long";
case String s -> "string";
default -> "";
};
System.out.println(print);
* Output:
bash
integer
Thus, the correct answer is:Compilation fails.
References:
* Java SE 21 - Pattern Matching for switch
* Java SE 21 - switch Expressions

質問 # 60
Given:
java
List<String> frenchAuthors = new ArrayList<>();
frenchAuthors.add("Victor Hugo");
frenchAuthors.add("Gustave Flaubert");
Which compiles?

• A. Map<String, ? extends List<String>> authorsMap2 = new HashMap<String, ArrayList<String>> (); java authorsMap2.put("FR", frenchAuthors);
• B. var authorsMap3 = new HashMap<>();
  java
  authorsMap3.put("FR", frenchAuthors);
• C. Map<String, List<String>> authorsMap4 = new HashMap<String, ArrayList<String>>(); java authorsMap4.put("FR", frenchAuthors);
• D. Map<String, List<String>> authorsMap5 = new HashMap<String, List<String>>(); java authorsMap5.put("FR", frenchAuthors);
• E. Map<String, ArrayList<String>> authorsMap1 = new HashMap<>();
  java
  authorsMap1.put("FR", frenchAuthors);

正解：B、C、D

解説：
* Option A (Map<String, ArrayList<String>> authorsMap1 = new HashMap<>();)
* #Compilation Fails
* frenchAuthors is declared as List<String>,notArrayList<String>.
* The correct way to declare a Map that allows storing List<String> is to use List<String> as the generic type,notArrayList<String>.
* Fix:
java
Map<String, List<String>> authorsMap1 = new HashMap<>();
authorsMap1.put("FR", frenchAuthors);
* Reason:The type ArrayList<String> is more specific than List<String>, and this would cause a type mismatcherror.
* Option B (Map<String, ? extends List<String>> authorsMap2 = new HashMap<String, ArrayList<String>>();)
* #Compilation Fails
* ? extends List<String>makes the map read-onlyfor adding new elements.
* The line authorsMap2.put("FR", frenchAuthors); causes acompilation errorbecause wildcard (?
extends List<String>) prevents modifying the map.
* Fix:Remove the wildcard:
java
Map<String, List<String>> authorsMap2 = new HashMap<>();
authorsMap2.put("FR", frenchAuthors);
* Option C (var authorsMap3 = new HashMap<>();)
* Compiles Successfully
* The var keyword allows the compiler to infer the type.
* However,the inferred type is HashMap<Object, Object>, which may cause issues when retrieving values.
* Option D (Map<String, List<String>> authorsMap4 = new HashMap<String, ArrayList<String>
>();)
* Compiles Successfully
* Valid declaration:HashMap<K, V> can be assigned to Map<K, V>.
* Using new HashMap<String, ArrayList<String>>() with Map<String, List<String>> isallowed due to polymorphism.
* Correct syntax:
java
Map<String, List<String>> authorsMap4 = new HashMap<String, ArrayList<String>>(); authorsMap4.put("FR", frenchAuthors);
* Option E (Map<String, List<String>> authorsMap5 = new HashMap<String, List<String>>();)
* Compiles Successfully
* HashMap<String, List<String>> isa valid instantiation.
* Correct usage:
java
Map<String, List<String>> authorsMap5 = new HashMap<>();
authorsMap5.put("FR", frenchAuthors);
Thus, the correct answers are:C, D, E
References:
* Java SE 21 - Generics and Type Inference
* Java SE 21 - var Keyword

質問 # 61
......

試験準備には欠かさない！トップクラスのOracle 1z1-830試験アプリ学習ガイド練習問題最新版：https://jp.fast2test.com/1z1-830-premium-file.html