1Z0-829 Handling Date, Time, Text, Numeric and Boolean Values Practice Test 3 — 15 Questions

Question 1

A scheduling component must determine whether the local time 02:30 exists on a particular date in the America/New_York time zone, given that daylight saving time can create gaps. Which approach correctly detects a gap in the local timeline?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Call ZonedDateTime.of(localDateTime, zoneId) and compare the resulting object's toLocalDateTime with the original local date-time; a mismatch indicates a gap.. ZonedDateTime.of resolves a local date-time against a zone's rules and silently moves times inside a spring-forward gap forward by the gap length. Comparing the resolved local date-time with the requested one exposes that shift, which is the reliable signal that the local time does not exist on that date in that zone.

Answer

Call zoneId.getRules().isDaylightSavings(instant) and treat a true result as proof that the local time does not exist.

Answer

Call localDateTime.atZone(zoneId) and check whether the returned ZonedDateTime has a null offset.

Answer

Call LocalDateTime.of(date, LocalTime.of(2, 30)).isSupported(ChronoField.INSTANT_SECONDS) and expect false for a gap.

Question 2

A subscription service must compute a renewal date exactly one month after a signup date and also report how many full days remain until renewal. The team is using java.time types and wants operations that are daylight-saving-safe and calendar-correct. Which two statements about the correct approach are true? (Choose two.)

Accepted Answer

LocalDate.plusMonths(1) clamps the day-of-month to the last valid day when the target month is shorter, so January 31 renews on February 28 or 29.. Calendar-correct month arithmetic belongs to LocalDate.plusMonths, which clamps end-of-month dates to the last valid day, and to ZonedDateTime.plus(Period), which adds in local time before resolving the offset. For reporting elapsed days, ChronoUnit.DAYS.between is the appropriate API; Period decomposes into fields and Duration measures exact elapsed time, so neither directly yields the calendar-day count the service needs.

Answer

Duration.between(startInstant, endInstant).toDays() returns the exact calendar-day difference regardless of zone.

Answer

ChronoUnit.DAYS.between(start, end) returns the number of complete 24-hour periods between two LocalDate values, adjusting for DST transitions.

Answer

Period.between(signupDate, renewalDate).getDays() reliably reports the full-day count for a one-month span.

Question 3

A developer is reviewing code that uses java.time to compute durations and periods. Which two statements about Duration and Period are correct? (Choose two.)

Accepted Answer

Duration.ofDays(1) and Duration.ofHours(24) produce equal durations.. Duration is time-based and works with objects that expose time fields, so computing the gap between two LocalTime values yields PT8H30M, and one day equals twenty-four hours in its fixed scale. Period is date-based and applies to dates, not times, and its between calculation subtracts fields without normalizing day overflow. Mixing the wrong temporal type with either class raises UnsupportedTemporalTypeException.

Answer

Duration.between(LocalDate.of(2023,1,1), LocalDate.of(2023,1,2)) returns a duration of 24 hours.

Answer

Period.ofMonths(1) can be added to a LocalTime to shift it by one month.

Answer

Period.between(LocalDate.of(2023,1,31), LocalDate.of(2023,3,1)) returns a period of 1 month and 1 day.

Question 4

Which TWO statements are true about the java.time.Duration class? (Choose two.)

Accepted Answer

Duration represents a time-based amount of time, such as hours, minutes, seconds.. The java.time.Duration class models a time-based amount of time in terms of seconds and nanoseconds, which can represent hours, minutes, seconds, and smaller units. It is designed for time-based quantities, not date-based ones like days, months, or years.

Answer

Duration.ofDays(1) returns a Duration that is daylight-saving-safe.

Answer

Duration.between(LocalDate.now(), LocalDate.now().plusDays(1)) returns a Duration of 1 day.

Answer

Duration can represent a period of months.

Question 5

Which THREE statements are true about the Boolean class? (Choose three.)

Accepted Answer

The parseBoolean(String) method returns false if the string is null or not equal to "true" (case-insensitive).. The `Boolean.parseBoolean(String)` method returns `false` for any input that is not exactly equal to `"true"` (case-insensitive), including `null`. This is specified in the Java API documentation and is a common way to safely parse boolean strings without throwing a NullPointerException.

Answer

The Boolean constructor is the preferred way to create a Boolean object.

Answer

Boolean has three possible values: true, false, and null.

Question 6

A company's Java application processes time-sensitive data from IoT sensors. The system must handle timestamps across multiple time zones. The application runs on a server set to UTC. Developers have been using java.util.Date and SimpleDateFormat for date parsing. Recently, there have been intermittent failures where timestamps from sensors in the America/New_York time zone are parsed incorrectly around daylight saving time transitions. Specifically, during the spring forward (March 12, 2023, at 2:00 AM EST to 3:00 AM EDT), timestamps like "2023-03-12 02:30:00" are being interpreted as times that do not exist, causing DateTimeParseException. The team decides to migrate to the java.time API. They need to parse sensor timestamps that include a time zone offset (e.g., "2023-03-12 02:30:00 -05:00") into an OffsetDateTime. Which course of action correctly parses the timestamp and handles the DST issue?

Accepted Answer

Use DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss XXX") and OffsetDateTime.parse(timestamp, formatter).. The timestamp includes an explicit offset (-05:00), which makes it directly parseable into an OffsetDateTime using a DateTimeFormatter with the XXX pattern for the offset. OffsetDateTime.parse() handles the offset directly without any DST ambiguity, as the offset is explicitly provided in the string, avoiding the nonexistent time issue during spring-forward transitions.

Answer

Use LocalDateTime.parse(timestamp, formatter) and then apply a ZoneOffset.

Answer

Use ZonedDateTime.parse(timestamp, formatter) with a formatter that includes time zone ID, then convert to OffsetDateTime.

Answer

Keep using SimpleDateFormat but set the time zone of the parser to America/New_York.

Question 7

Which TWO of the following are valid ways to create a LocalDate object in Java 17?

Accepted Answer

LocalDate.of(2023, Month.JANUARY, 15). Option B is correct because LocalDate.of(int year, Month month, int dayOfMonth) is a valid static factory method in java.time that accepts a Month enum constant such as Month.JANUARY, producing 2023-01-15. Option D is correct because LocalDate.parse(CharSequence) uses the ISO_LOCAL_DATE formatter by default, and "2023-01-15" matches the required yyyy-MM-dd pattern. Option A is wrong because LocalDate.from(TemporalAccessor) requires a temporal that contains date fields, and Instant only provides an instant on the time-line without a date, so it throws DateTimeException. Option C is wrong because month 13 is outside the valid range of 1-12 and LocalDate.of throws DateTimeException. Option E is wrong because LocalDate.ofEpochDay takes a long primitive, not a String, so passing "19375" does not compile.

Answer

LocalDate.from(Instant.now())

Answer

LocalDate.of(2023, 13, 1)

Answer

LocalDate.ofEpochDay("19375")

Question 8

Arrange the steps to create a custom exception class in Java in the correct order.

Accepted Answer

1. Define a class that extends Exception or RuntimeException. 2. Add constructors (default, with message, with cause). 3. Optionally override methods like getMessage() or toString().. Custom exceptions extend Exception (checked) or RuntimeException (unchecked). Constructors typically call super(message) or super(cause).

Answer

1. Add constructors (default, with message, with cause). 2. Define a class that extends Exception or RuntimeException. 3. Optionally override methods.

Answer

1. Define a class (without extending Exception or RuntimeException). 2. Add constructors that call super(message). 3. Optionally override methods.

Answer

1. Override methods like getMessage() or toString(). 2. Define a class extending Exception or RuntimeException. 3. Add constructors.

Question 9

Arrange the steps to use a lambda expression to sort a list of strings by length.

Accepted Answer

Start by creating a list of strings. Then write a lambda expression that uses Integer.compare to compare string lengths. Then pass the lambda to the Collections.sort method. Finally, print the sorted list.. Comparator is a functional interface; lambda provides concise implementation. Integer.compare() handles comparison safely.

Answer

Start by writing a lambda expression that uses Integer.compare to compare string lengths. Then create a list of strings. Then pass the lambda to the Collections.sort method. Finally, print the sorted list.

Answer

Start by creating a list of strings. Then pass the lambda to the Collections.sort method. Then write a lambda expression that uses Integer.compare to compare string lengths. Finally, print the sorted list.

Answer

Start by creating a list of strings. Then write a lambda expression that uses Integer.compare to compare string lengths. Then print the sorted list. Finally, pass the lambda to the Collections.sort method.

Question 10

A developer needs to parse a date string '2024-07-04' into a LocalDate object. Which approach is correct?

Accepted Answer

LocalDate.parse("2024-07-04"). `LocalDate.parse("2024-07-04")` uses the default ISO-8601 format (yyyy-MM-dd), which matches the given string exactly. The `LocalDate` class provides a static `parse` method that returns a `LocalDate` object without needing an explicit formatter when the input follows the standard pattern.

Answer

LocalDate.of(2024, 07, 04)

Answer

DateFormat.getDateInstance().parse("2024-07-04")

Answer

new LocalDate(2024, 7, 4)

Question 11

Which method checks if a String is empty or contains only whitespace?

Accepted Answer

isBlank(). The `isBlank()` method, introduced in Java 11, returns `true` if the string is empty or contains only whitespace characters (as defined by `Character.isWhitespace()`). This makes it the correct and most direct way to check for blank strings, unlike older approaches that require combining multiple checks.

Answer

length() == 0

Answer

isEmpty()

Answer

trim().isEmpty()

Question 12

A financial application uses BigDecimal for monetary calculations. Which rounding mode should be used to round to the nearest neighbor, and if both neighbors are equidistant, round to the even neighbor?

Accepted Answer

RoundingMode.HALF_EVEN. RoundingMode.HALF_EVEN rounds to the nearest neighbor, and when both neighbors are equidistant (i.e., the fractional part is exactly 0.5), it rounds to the even neighbor. This is the standard rounding mode for financial calculations to minimize cumulative rounding bias over many operations.

Answer

RoundingMode.HALF_UP

Answer

RoundingMode.HALF_DOWN

Answer

RoundingMode.UNNECESSARY

Question 13

A program reads user input as a string and needs to parse it into an integer, handling invalid input gracefully. Which code snippet correctly uses try-catch to parse and prints the result or 'Invalid number'?

Accepted Answer

try { int num = Integer.parseInt(input); System.out.println(num); } catch (NumberFormatException e) { System.out.println("Invalid number"); }. It uses `Integer.parseInt(input)` which throws a `NumberFormatException` for invalid input, and the catch block specifically catches that exception to print 'Invalid number'. This is the standard, idiomatic Java approach for parsing integers with error handling, as it directly addresses the requirement without unnecessary overhead or false positives.

Answer

try { int num = Integer.valueOf(input).intValue(); System.out.println(num); } catch (Exception e) { System.out.println("Invalid number"); }

Answer

int num = Integer.parseInt(input); System.out.println(num);

Answer

if (input.matches("\d+")) { int num = Integer.parseInt(input); System.out.println(num); } else { System.out.println("Invalid number"); }

Question 14

What is the result of executing the following code snippet?

BigDecimal d1 = new BigDecimal("1.00");
BigDecimal d2 = new BigDecimal("1.0");
System.out.println(d1.equals(d2));

Accepted Answer

false. The `equals` method of `BigDecimal` compares both the numeric value and the scale (number of digits after the decimal point). Since `new BigDecimal("1.00")` has a scale of 2 and `new BigDecimal("1.0")` has a scale of 1, they are not considered equal by `equals`, even though they represent the same mathematical value. Therefore, the output is `false`.

Answer

compile error

Answer

true

Answer

1