1Z0-811 Primitives, Strings and Operators Practice Test 7 — 15 Questions

Question 1

A developer needs to build a SQL query string by concatenating many parts. Which approach is most efficient for repeated concatenation?

Accepted Answer

Using StringBuilder.append(). StringBuilder.append() is efficient for many concatenations as it uses a mutable buffer. StringBuffer is synchronized and slower. String concatenation with '+' creates many intermediate objects. String.concat() also creates new objects.

Answer

Using StringBuffer.append()

Answer

Using String concatenation with +=

Answer

Using String.concat()

Question 2

Evaluate the following expression: int x = 5; int y = (x > 5) ? 10 : 20; What is y?

Accepted Answer

20. The ternary operator `(x > 5) ? 10 : 20` evaluates the condition `x > 5`. Since `x` is 5, the condition is false, so the expression returns the value after the colon, which is 20. This value is assigned to `y`, making `y` equal to 20.

Answer

5

Answer

Compilation error

Answer

10

Question 3

Given: byte b = 10; b = b + 1; Which statement is true?

Accepted Answer

Compilation error because byte cannot be assigned int.. In Java, the expression `b + 1` performs binary numeric promotion, widening the `byte` operand to `int` before addition. The result is an `int` (11), which cannot be implicitly assigned back to a `byte` variable without a cast. Therefore, `b = b + 1;` causes a compilation error: 'incompatible types: possible lossy conversion from int to byte'. Option C correctly identifies this error.

Answer

The value of b becomes 11.

Answer

b is automatically widened to int then assigned back without error.

Answer

The expression b+1 results in a byte.

Question 4

Which primitive type has a default value of 0.0f?

Accepted Answer

float. In Java, the default value for a float primitive is 0.0f. This is because float is a 32-bit IEEE 754 floating-point type, and its default initialization is 0.0f (with the 'f' suffix to denote a float literal). Option A is correct because it directly matches this specification.

Answer

long

Answer

double

Answer

int

Question 5

What is the result of the following code? int a = 8; int b = 3; System.out.println(a >> 1);

Accepted Answer

4. The right shift operator `>>` shifts the bits of the integer `a` (which is 8, binary `1000`) to the right by 1 position. This discards the least significant bit and fills the most significant bit with the sign bit (0 for positive numbers), resulting in binary `0100`, which is decimal 4. Therefore, `System.out.println(a >> 1)` prints 4.

Answer

2

Answer

3

Answer

16

Question 6

Given: int x = 3 + 4 * 2; What is x?

Accepted Answer

11. Multiplication has higher precedence than addition: 4 * 2 = 8, then 3 + 8 = 11. Therefore, x is 11, making option A the correct answer.

Answer

11

Answer

24

Answer

14

Question 7

Which two of the following are valid ways to create a String object?

Accepted Answer

String s = "Hello";. A string literal, which is a valid way to create a String object. Option D uses the String constructor with a string argument, also valid. Option B assigns an integer literal to a String variable, which is not allowed. Option C attempts to cast an Integer object to String, which causes a compile-time error because Integer is not a subclass of String. Option E uses a char literal ('Hello' is invalid because char literals are single characters) and is not assignable to String.

Answer

String s = 12345;

Answer

String s = (String) new Integer(10);

Answer

String s = 'Hello';

Question 8

Which three of the following statements about primitive type conversion are true?

Accepted Answer

Implicit widening conversion is allowed from int to long.. The correct answers are B, D, and E. 
- B is correct: Implicit widening conversion from int to long is allowed because long has a larger range (64-bit vs 32-bit). 
- D is correct: A char can be assigned to an int without a cast because char is 16-bit unsigned and int is 32-bit, so the value fits without loss. 
- E is correct: Narrowing conversion from double to int requires an explicit cast because double has a larger range and fractional part cannot be automatically discarded. 
- A is false: A float cannot be implicitly converted to long because float is 32-bit floating-point; conversion would lose precision and requires an explicit cast. 
- C is false: A boolean cannot be converted to any numeric type, even with casting; boolean and numeric types are incompatible.

Answer

A float can be implicitly converted to long.

Answer

A boolean can be converted to int using casting.

Question 9

Which three of the following code snippets produce the output '5'?

Accepted Answer

System.out.println(2 + 3);. The expression `2 + 3` performs integer addition, resulting in `5`, which is then passed to `System.out.println` and printed as the string representation of the integer `5`. Option C is correct because the string literal `"5"` is printed directly. Option E is correct because the integer literal `5` is printed as its string representation.

Answer

System.out.println(2 + "3");

Answer

System.out.println("2" + 3);

Question 10

You are developing a high-frequency trading application where performance is critical. You need to parse and concatenate trade messages. The messages are received as strings and must be combined into a single output string for logging. Each message is appended to the log string. Currently, you are using String concatenation with the '+' operator inside a loop that processes up to 10,000 messages per second. However, performance monitoring shows that the application experiences frequent garbage collection pauses, affecting throughput. Which approach should you take to reduce garbage collection overhead and improve performance?

Accepted Answer

Use StringBuilder instead of String concatenation, ensuring that the StringBuilder is created with an appropriate initial capacity.. StringBuilder is designed for efficient string concatenation without synchronization overhead. Creating it with an appropriate initial capacity further reduces reallocations. StringBuffer is thread-safe but adds unnecessary overhead in a single-threaded context. String.concat() still creates new objects. Increasing heap size only delays GC, not reduce object creation.

Answer

Use the String.concat() method for each concatenation to reduce object creation.

Answer

Use StringBuffer instead of String concatenation because it is thread-safe and efficient.

Answer

Keep using the '+' operator but increase the heap size to reduce garbage collection frequency.

Question 11

You are part of a team maintaining a legacy order processing system. The system stores order totals as primitive double values. A recent bug report shows that for very large orders (around $1,000,000.00), the total after adding a tax of 8.25% is sometimes off by a few cents. The calculation is: total = orderTotal * (1 + taxRate). The taxRate is defined as double taxRate = 0.0825; The orderTotal is received as a double. The application needs exact monetary precision to two decimal places. Which solution best addresses the precision issue while minimizing changes to the existing code?

Accepted Answer

Use BigDecimal for all monetary calculations, replacing double everywhere.. BigDecimal provides exact arithmetic for monetary values. Replacing double with BigDecimal everywhere ensures precision. Math.round with scaling still uses double arithmetic before rounding, which may introduce errors. DecimalFormat only affects output, not internal calculation. Casting to float loses precision.

Answer

Use DecimalFormat with RoundingMode.HALF_EVEN to format the output.

Answer

Use Math.round(total * 100) / 100.0 to round to two decimals.

Answer

Cast the result to float and then back to double to round.

Question 12

A junior developer wrote the following code to compare two strings entered by a user: if (username == "admin") { grantAccess(); } else { denyAccess(); }. The code always denies access even when the user enters 'admin'. What is the most likely cause, and how should the code be fixed?

Accepted Answer

The strings are compared using == which checks reference equality. Use username.equals("admin") instead.. In Java, the == operator compares object references, not the actual content of strings. When comparing two String objects for logical equality, the .equals() method must be used. The code if (username == "admin") checks whether username and the string literal "admin" refer to the same memory location, which is false when username is obtained from user input (e.g., via Scanner or console), even if the characters are identical.

Answer

The input string has leading or trailing spaces. Use username.trim().equals("admin") instead.

Answer

The variable username is null, causing a NullPointerException that is caught and denied access. Add a null check.

Answer

The strings are compared using == which is case-sensitive. Use username.equalsIgnoreCase("admin") instead.

Question 13

Which two of the following are valid ways to check if two String objects contain the same characters? (Assume s1 and s2 are non-null String references.)

Accepted Answer

if (s1.compareTo(s2) == 0) { ... }. The correct ways to compare two String objects for character equality are using the equals() method (option E) or compareTo() method returning 0 (option C). Option A (equalsIgnoreCase) ignores case, so it would treat strings with different cases as equal. Option B (==) compares object references, not content. Option D compares s1 with the interned version of s2; this only works if s1 is also interned, which is not guaranteed, making it unreliable.

Answer

if (s1.equalsIgnoreCase(s2)) { ... }

Answer

if (s1 == s2) { ... }

Answer

if (s1 == s2.intern()) { ... }

Question 14

Which three of the following are valid Java operators that can be used with primitive numeric types?

Accepted Answer

&. Options A, B, and C are correct because &, ^, and | are bitwise operators that can be applied to integral primitive numeric types (byte, short, int, long, char). They operate on the binary representations of these types. Note that these operators are not applicable to floating-point types (float, double). Options D and E (&&, ||) are logical operators that work only with boolean operands, not numeric types.

Answer

||

Answer

&&

Question 15

A financial trading application processes a batch of 10 million trade transactions every night. Each transaction is a String containing trade details such as ID, symbol, quantity, and price. The current implementation uses string concatenation with the += operator in a loop to build a summary report string. The application frequently runs out of memory and takes hours to complete. The server has 16 GB of RAM and runs Java 11. The code cannot be restructured significantly due to regulatory requirements, but performance improvements are allowed. Which course of action will most effectively resolve the performance and memory issues?

Accepted Answer

Replace the String concatenation with StringBuilder.. The performance and memory issues are caused by using String concatenation (+=) inside a loop, which creates many intermediate String objects because Strings are immutable in Java. StringBuilder is mutable and designed for efficient string concatenation without creating intermediate objects, making it the optimal solution. Option A (StringBuilder) is correct. Option B (calling intern()) would not improve performance and could degrade it. Option C (increasing heap size) only postpones the OutOfMemoryError and does not fix the inefficiency. Option D (StringBuffer) is thread-safe but slower due to synchronization; it is unnecessary in this single-threaded context. Therefore, replacing concatenation with StringBuilder is the most effective resolution.

Answer

Call intern() on the concatenated result at each iteration.

Answer

Increase the JVM heap size to 32 GB to accommodate the temporary string objects.

Answer

Replace the String concatenation with StringBuffer.