Handling Date, Time, Text, Numeric and Boolean Values practice questions

if (flag = null) flag = Boolean.FALSE;

Why wrong: Assignment instead of comparison; also unboxing null throws NPE.

if (flag.equals(Boolean.FALSE)) flag = null;

Why wrong: Throws NullPointerException if flag is null; logic reversed.

OffsetDateTime.of(LocalDateTime.now(), ZoneOffset.from(ZonedDateTime.now(zone)))

Why wrong: Complicated and incorrect; ZoneOffset.from() may throw DateTimeException.

LocalDate.now(zone).atStartOfDay(zone).toOffsetDateTime()

Why wrong: atStartOfDay() returns start of day, not current time.

LocalDateTime.now().atZone(zone).toOffsetDateTime()

Why wrong: LocalDateTime.now() uses system default zone, not the given zone.

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US); nf.setMinimumFractionDigits(2);

Why wrong: Incorrect. Setting minimum fraction digits does not affect the rounding mode; it defaults to HALF_EVEN.

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US); nf.setMaximumFractionDigits(2);

Why wrong: Incorrect. Setting maximum fraction digits does not affect the rounding mode; it defaults to HALF_EVEN.

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US);

Why wrong: Incorrect. While getCurrencyInstance provides two decimal places, it defaults to HALF_EVEN rounding, not half-up.

It returns an Instant representing 2023-12-31T23:59:59Z, ignoring the leap second.

Why wrong: Leap second is not ignored; it is handled.

It throws a DateTimeParseException because 60 seconds is invalid.

Why wrong: Instant.parse handles leap seconds.

It returns null because the string is invalid.

Why wrong: It returns an Instant, not null.

LocalDate.parse("2023-01-15", DateTimeFormatter.ofPattern("yyyy-mm-dd"))

Why wrong: Incorrect. The pattern uses lowercase 'mm' for minutes instead of uppercase 'MM' for month, causing a parsing error.

MonthDay.parse("2023-01-15")

Why wrong: Incorrect. MonthDay.parse() expects a format like '--01-15' without a year, so it fails on a full date string.

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

Why wrong: Duration is fixed 24 hours, not DST-aware.

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

Why wrong: Duration.between requires temporals that support seconds; LocalDate does not.

Duration can represent a period of months.

Why wrong: Period represents months, not Duration.

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

Why wrong: Boolean constructor is deprecated; valueOf is preferred.

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

Why wrong: Boolean is an object wrapper; it can be null, but the boolean primitive has only two values.

null is printed.

Why wrong: An exception is thrown, not null.

2023-03-12T03:30:00-04:00[America/New_York]

Why wrong: Would be if the time existed after spring forward? Actually 02:30 would become 03:30? But parsing fails.

2023-03-12T02:30:00-05:00[America/New_York]

Why wrong: Would be before spring forward, but the time is after 2:00.

0.125

Why wrong: Percent instance multiplies by 100.

%12.50

Why wrong: US locale places percent sign after the number.

12.5%

Why wrong: Minimum fraction digits override default; two digits required.

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

Why wrong: LocalDateTime has no offset; would not correctly represent the instant.

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

Why wrong: ZonedDateTime.parse expects zone ID, not offset; and may still throw exception for invalid local times.

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

Why wrong: SimpleDateFormat does not handle DST gaps properly.

LocalDate.from(Instant.now())

Why wrong: Cannot derive LocalDate from Instant directly.

LocalDate.of(2023, 13, 1)

Why wrong: Month 13 is invalid.

LocalDate.ofEpochDay("19375")

Why wrong: ofEpochDay expects long, not String.

Wrap the parse call in a synchronized block

Why wrong: Thread-safe but causes contention, reducing performance.

Use a ThreadLocal<SimpleDateFormat> to give each thread its own instance

Why wrong: A ThreadLocal<SimpleDateFormat> eliminates shared mutable state between threads, which would fix the thread-safety issue if the requirement were to continue using SimpleDateFormat. However, the stem specifies parsing into an Instant, and SimpleDateFormat cannot produce an Instant directly—it produces a java.util.Date, which lacks nanosecond precision and the UTC context that Instant requires. The correct fix is to switch to java.time.format.DateTimeFormatter with a pattern like "yyyy-MM-dd'T'HH:mm:ss.SSSX" and call parse(CharSequence, Instant::from), which is inherently thread-safe and yields an Instant. This option is tempting because ThreadLocal is a standard workaround for non-thread-safe SimpleDateFormat in legacy code, and it would work if the target type were Date rather than Instant.

Create a new SimpleDateFormat instance for each parse call

Why wrong: Avoids thread safety but creates many objects, hurting performance.

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

Why wrong: This is incorrect because you cannot add constructors without first defining the class. The class must exist before you can add any members to it.

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

Why wrong: This is incorrect because the class must extend Exception or RuntimeException to be a custom exception. Without inheritance, it is just a regular class, not a throwable exception type.

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

Why wrong: This is incorrect because method overriding can only be done after the class is defined and constructors are typically added before overriding methods, as constructors are essential for exception instantiation.

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.

Why wrong: This is incorrect because the lambda is defined before the list exists. While it's syntactically allowed, logically you need the list first to know what to sort.

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.

Why wrong: This is incorrect because you cannot pass a lambda to sort before it has been written. The lambda must be defined before it can be used.

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.

Why wrong: This is incorrect because printing the list before sorting would output the unsorted list. The sort must occur before any output that depends on ordering.

volatile: Prevents a field from being serialized.

Why wrong: Incorrect — this describes transient, not volatile.

transient: Ensures thread safety for a variable.

Why wrong: Incorrect — transient does not affect thread safety; that is the purpose of volatile or synchronized.

@Override: RUNTIME

Why wrong: Incorrect — @Override has retention policy SOURCE, not RUNTIME, as it is not needed at runtime.

@Deprecated: SOURCE

Why wrong: Incorrect — @Deprecated has retention policy RUNTIME, not SOURCE, because deprecation information is needed at runtime.

LocalDate.of(2024, 07, 04)

Why wrong: Incorrect: Leading zeros are allowed but method expects int values; however parse is the standard approach.

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

Why wrong: Incorrect: DateFormat returns a java.util.Date, not LocalDate, and is outdated.

new LocalDate(2024, 7, 4)

Why wrong: Incorrect: LocalDate has no public constructor; use of() or parse() instead.

length() == 0

Why wrong: Incorrect: Only checks if the string is empty, not whitespace-only.

isEmpty()

Why wrong: Incorrect: isEmpty() only returns true if length is 0, not for whitespace-only strings.

trim().isEmpty()

Why wrong: Incorrect: This works but is not a direct method and is less efficient.

"line1\nline2"

Why wrong: Incorrect: This is a regular string with escape sequence, not a text block.

'line1\nline2'

Why wrong: Incorrect: Single quotes are not valid for strings in Java.

"""line1\nline2"""

Why wrong: Incorrect: Text blocks must start on a new line after the opening delimiter; escapes are not needed.