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

Question 1

Which of the following statements about the String class is true?

Accepted Answer

Strings are immutable. String objects in Java are immutable, meaning once a String object is created, its value cannot be changed. Any operation that appears to modify a String, such as concatenation, actually creates a new String object. This immutability is a fundamental design choice that enables String pooling, thread safety, and efficient caching of hash codes.

Answer

Strings can be modified using the '+' operator

Answer

String objects can be created only with the 'new' keyword

Answer

String is a primitive type

Question 2

Which two of the following are primitives in Java? (Choose two.)

Accepted Answer

byte. Options A and B are correct because byte and char are both Java primitive types: byte is an 8-bit signed two's-complement integer, and char is a 16-bit unsigned Unicode character type, both defined by the Java language as primitives. The remaining options do not belong: String is a class in java.lang (a reference type, not a primitive), Integer is a wrapper class in java.lang that boxes the primitive int, and Boolean is a wrapper class that boxes the primitive boolean — note that the primitive is spelled boolean (lowercase), while Boolean (capitalized) is the wrapper class.

Answer

String

Answer

Integer

Answer

Boolean

Question 3

Which three of the following are valid ways to declare and initialize a variable of type int? (Choose three.)

Accepted Answer

int b = 0xA;. Option A (int b = 0xA;) is valid because Java supports hexadecimal integer literals prefixed with 0x, and 0xA equals decimal 10, which fits in an int. Option C (int d = 010;) is valid because a leading zero denotes an octal literal, and 010 is octal for decimal 8, a legal int value. Option E (int a = 10;) is valid because 10 is a standard decimal int literal assigned directly to an int variable. Option B (int e = 10.0;) is invalid because 10.0 is a double literal and cannot be assigned to an int without an explicit cast. Option D (int c = 0b2;) is invalid because the 0b prefix denotes a binary literal, and the digit 2 is not permitted in binary.

Answer

int e = 10.0;

Answer

int c = 0b2;

Question 4

What is the cause of the compilation error?

Accepted Answer

The value 200 exceeds the range of byte (-128 to 127). The code attempts to assign the integer literal 200 to a variable of type byte. In Java, the byte data type has a range from -128 to 127. Since 200 exceeds this range, the compiler detects a possible loss of precision and raises a compilation error. Java does not automatically narrow a larger integer literal to fit into a byte without an explicit cast.

Answer

The literal 200 is a long

Answer

The assignment operator is invalid

Answer

The variable b is not declared

Question 5

Given: int x = 10; int y = 20; What is the output of System.out.println(x + y * 2);?

Accepted Answer

50. Java operator precedence dictates that multiplication (*) has higher precedence than addition (+). Therefore, y * 2 is evaluated first: 20 * 2 = 40. Then x + 40 = 10 + 40 = 50. The output is 50.

Answer

40

Answer

60

Answer

30

Question 6

Given the code snippet: double d = 10.5; int i = (int) d; System.out.println(i); What is the output?

Accepted Answer

10. The cast (int) d performs a narrowing primitive conversion from double to int, which truncates the fractional part toward zero. For d = 10.5, truncation yields 10, and System.out.println(i) prints 10. No rounding occurs — Java's narrowing conversion discards the decimal portion entirely.

Answer

10.0

Answer

10.5

Answer

Compilation error

Question 7

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 the most efficient choice for repeated concatenation because StringBuilder is a mutable, non-synchronized sequence of characters that appends in amortized O(1) time without allocating a new String on each operation. For a single-threaded SQL-building loop, this avoids the O(n²) allocation churn of `+=` and the unnecessary synchronization overhead of StringBuffer.

Answer

Using StringBuffer.append()

Answer

Using String concatenation with +=

Answer

Using String.concat()

Question 8

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 9

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 10

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 11

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 12

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

Accepted Answer

String s = "Hello";. Option A is correct because a string literal such as "Hello" is directly assignable to a String reference; the compiler interns the literal and creates the String object. Option D is correct because the String class has a public constructor String(String original), so new String("Hello") explicitly creates a new String object. Option B is invalid because an int literal cannot be assigned to a String without conversion such as String.valueOf(12345) or Integer.toString(12345). Option C is invalid because Integer cannot be cast to String; Integer and String are unrelated reference types, so the cast would fail at compile time. Option E is invalid because 'Hello' uses single quotes, which denote a char literal, and a char literal cannot contain multiple characters or be assigned to a String.

Answer

String s = 12345;

Answer

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

Answer

String s = 'Hello';

Question 13

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

Accepted Answer

Implicit widening conversion is allowed from int to long.. Option B is correct because implicit widening conversion follows the Java primitive promotion hierarchy, where a 32-bit int safely fits into a 64-bit long without loss of information, so no cast is required. Option D is correct because char is an unsigned 16-bit type and int is a 32-bit signed type, so every possible char value (0–65535) fits within int's range, allowing assignment without an explicit cast. Option E is correct because converting double to int is a narrowing conversion that can lose the fractional part and may exceed int's range, so the compiler requires an explicit cast such as (int) to acknowledge the potential data loss. Option A is not correct because float to long is a narrowing conversion (float has a wider range and fractional precision) and requires an explicit cast, not an implicit one. Option C is not correct because boolean is not convertible to any numeric primitive type in Java, even with casting; boolean and int are incompatible types.

Answer

A float can be implicitly converted to long.

Answer

A boolean can be converted to int using casting.

Question 14

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.. Using StringBuilder with an appropriate initial capacity reduces garbage collection overhead because it avoids creating multiple intermediate String objects. StringBuilder is mutable, so appending messages modifies the same buffer, minimizing object allocation and GC pauses.

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 15

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.. double is a binary floating-point type (IEEE 754) and cannot represent most decimal fractions exactly — 0.0825 and the resulting products accumulate rounding error that surfaces as cent-level discrepancies at large magnitudes. BigDecimal uses arbitrary-precision decimal arithmetic with explicit scale and RoundingMode, giving exact monetary results. Replacing double with BigDecimal for monetary fields is the only option that fixes the root cause rather than masking it.

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.