Free 1Z0-819 sample questions

Correct answer: ```java public UserDetails getUser(String userId) { // Input validation is handled by a framework annotation return userRepository.findById(userId); }```

This code snippet is vulnerable to Insecure Direct Object Reference (IDOR). It directly uses the user-provided `userId` to fetch data from the database without verifying that the authenticated user is authorized to access that specific user's data. An attacker could simply change the `userId` in the URL to access another user's information. The other options show proper input validation or correct authorization checks.

Correct answer: True

This statement is true. The Java Language Specification dictates that in a `try-with-resources` statement, resources are closed in the opposite order in which they were initialized. This is analogous to how `finally` blocks would be nested, ensuring that resources that depend on other resources are closed first.

Correct answer: ```java long totalTime = executor.invokeAll(tasks).stream() .mapToLong(future -> { try { return future.get(); } catch (Exception e) { throw new RuntimeException(e); } }) .sum(); ```

The `executor.invokeAll(tasks)` method returns a `List >`. To process the results, you must stream this list. The `Future::get` method is a blocking call that throws checked exceptions (`InterruptedException`, `ExecutionException`), which cannot be used directly in a standard `map` operation without handling. The correct approach is to use a lambda block within `mapToLong` (for efficiency) that wraps the `future.get()` call in a `try-catch` block and re-throws any exception as an unchecked exception, or handles it appropriately. This option correctly demonstrates this pattern.

Correct answer: NumberFormat nf = NumberFormat.getCurrencyInstance(locale); return nf.format(amount);

`NumberFormat` is an abstract class and cannot be instantiated directly with `new`. The correct way to obtain a locale-specific formatter, especially for currency, is by using the static factory method `NumberFormat.getCurrencyInstance(locale)`. This ensures that the correct currency symbol, grouping separators, and decimal separators are used according to the rules of the specified `Locale`.

Correct answer: electronic:mobile

This question tests the difference between method overriding (dynamic dispatch) and field hiding (static dispatch). When `device.getType()` is called, polymorphism ensures the overridden method in the `Phone` class is executed, returning "mobile". However, when `device.type` is accessed, the reference type (`Device`) determines which field is used, not the object type (`Phone`). Therefore, the `type` field from the `Device` class is accessed, which is "electronic".

Correct answer: orders.stream().collect(Collectors.groupingBy(Order::getCustomer));

The `Collectors.groupingBy()` collector is specifically designed for this purpose. It takes a classification function (in this case, `Order::getCustomer`) and groups the elements of the stream into a `Map`. The keys of the map are the results of applying the classification function, and the values are `List`s of the stream elements that produced each key.

Correct answers: @Retention(RetentionPolicy.RUNTIME); @Documented

To make an annotation available at runtime through reflection, its retention policy must be set to `RetentionPolicy.RUNTIME`. To ensure the annotation is included in the output of documentation tools like Javadoc, the `@Documented` meta-annotation must be applied.

Correct answer: java.lang.Iterable

The `for-each` loop (or enhanced for loop) in Java works with any object whose class implements the `java.lang.Iterable` interface. This interface has a single abstract method, `iterator()`, which must return an instance of `java.util.Iterator`. The loop then uses this iterator to traverse the elements.

Correct answer: A followed by a `ConcurrentModificationException`.

It is illegal to modify a collection (e.g., by calling `list.remove(s)`) while iterating over it using an enhanced for-loop or a standard iterator, except through the `Iterator`'s own `remove` method. The code will print "A", then attempt to remove it. On the next iteration, the iterator's `hasNext()` or `next()` method will detect that the underlying collection has been structurally modified and will throw a `ConcurrentModificationException` to prevent unpredictable behavior.

Correct answer: Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@host:1521:sid", "scott", "tiger");

Since JDBC 4.0, it is no longer necessary to explicitly load the driver class using `Class.forName()`. The `DriverManager` can discover and load drivers automatically from the classpath. The most direct and modern way to establish a connection is to call `DriverManager.getConnection(url, user, password)`.