1Z0-811 Primitives, Strings and Operators — 40 Questions

Question 1

A developer writes: String s = "Hello"; s.concat(" World"); System.out.println(s); What is the output?

Accepted Answer

Hello. Strings in Java are immutable. The `concat()` method returns a new string but does not modify the original string `s`. Since the return value is not assigned to any variable, the original string `s` remains unchanged, so `System.out.println(s)` prints "Hello".

Answer

Compilation fails

Answer

Hello World

Answer

Hello World

Question 2

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

Accepted Answer

String s = new String("Hello");. It uses the `new` keyword to explicitly create a new String object in the heap, which is a valid way to instantiate a String. Option E is correct because it uses a string literal, which is the most common and efficient way to create a String in Java, leveraging the string constant pool.

Answer

String s = 'Hello';

Answer

String s = 123;

Answer

String s = String.valueOf("Hello");

Question 3

A banking application uses a method to calculate interest: double calculateInterest(double balance) { return balance * 0.05; }. The method is called with an int argument: int accountBalance = 1000; double interest = calculateInterest(accountBalance); System.out.println(interest); The output is 50.0, but the expected output is 50.0. However, the developer notices that if the method is changed to return int, the output becomes 50.0 as well. Which statement about implicit casting is true?

Accepted Answer

The int argument is implicitly cast to double.. When a method expecting a `double` parameter is called with an `int` argument, Java performs implicit widening primitive conversion (casting) from `int` to `double`. This is safe because `double` can represent all `int` values without loss of precision. The `int` value 1000 is automatically converted to `1000.0` before being used in the calculation.

Answer

The double result is implicitly cast to int.

Answer

The code fails to compile because of type mismatch.

Answer

The multiplication result is automatically rounded.

Question 4

Refer to the exhibit. What is the output?

Accepted Answer

false true true. The exhibit is not provided, but based on the correct answer D (false true true), a typical code snippet that produces this output is: String s1 = "true"; String s2 = new String("true"); String s3 = s2; System.out.println(s1 == s2); // false (reference comparison between literal and new object) System.out.println(s1.equals(s2)); // true (value equality) System.out.println(s3 == s2); // true (same reference). This exact ordering yields false, true, true.

Answer

false true false

Answer

true false true

Answer

true true true

Question 5

Match each primitive data type to its default value.

Accepted Answer

int: Default value is 0. Only options B and D correctly match a primitive type to its default value without redundancy or false equivalency. Option B correctly states that int defaults to 0, and option D correctly states that boolean defaults to false. Option A incorrectly pairs byte with 0 when byte's default is indeed 0, but it is considered a distractor because the question expects a one-to-one mapping and byte appears again in option E. Option C incorrectly pairs float with 0.0f, but float's default is 0.0f, making it a distractor for similar reasons. Options E and F are clearly wrong.

Answer

byte: Default value is 0

Answer

float: Default value is 0.0f

Answer

byte: Default value is false

Answer

int: Default value is 0.0f

Question 6

Which primitive type can store a single character?

Accepted Answer

char. The char primitive type is a 16-bit unsigned integer designed to hold a single Unicode character, written as a literal in single quotes (e.g., 'A'). It is the only primitive type in Java intended for character storage, with a range of 0 to 65,535 (\u0000 to \uFFFF).

Answer

String

Answer

int

Answer

Character

Question 7

What is the value of z after executing: int x = 3; int y = 2; int z = x++ * --y;

Accepted Answer

3. The expression `x++ * --y` uses post-increment on `x` and pre-decrement on `y`. Post-increment returns the original value of `x` (3) before incrementing it to 4. Pre-decrement decrements `y` from 2 to 1, then returns the new value (1). The multiplication is 3 * 1 = 3, which is assigned to `z`. So the correct answer is 3.

Answer

6

Answer

4

Answer

2

Question 8

Which THREE of the following statements about operators in Java are true?

Accepted Answer

The instanceof operator can be used to check if an object is an instance of a class.. Option A is correct because the instanceof operator performs a runtime type check, returning true when the left-hand object reference is an instance of the class or interface named on the right (or a subtype thereof). Option C is correct because the assignment operators (=, +=, -=, etc.) have the lowest precedence in Java, which is why expressions like a = b = c evaluate right-to-left and why assignments typically appear last in an expression. Option E is correct because && is the conditional-AND operator and it short-circuits: if the left operand evaluates to false, the right operand is not evaluated at all, which is essential for guarding against null dereferences or division by zero. Option B is wrong because >> is the arithmetic (signed) right shift, which sign-extends and fills with the sign bit, whereas >>> is the unsigned right shift that fills with zeros. Option D is wrong because == compares object references (identity), not content; content comparison requires equals() (or Objects.equals()).

Answer

The right shift operator (>>) always fills with zeros.

Answer

The equality operator (==) compares the content of objects.

Question 9

A method has parameters: int x, double y. It performs x += y; and returns x. What is the range behavior?

Accepted Answer

Result is truncated to int.. When the compound assignment operator += is used with an int and a double, the right-hand operand (double) is implicitly narrowed to int via a primitive narrowing conversion. This truncates the fractional part of the double value, and the result is stored as an int. The operation compiles without error and does not throw a runtime exception.

Answer

Compilation error: cannot apply += between int and double.

Answer

Lossy conversion causes runtime exception.

Answer

x is promoted to double, result is double.

Question 10

A developer wants to assign the largest possible long value to a variable. Which is correct?

Accepted Answer

long x = Long.MAX_VALUE;. Long.MAX_VALUE is the standard and readable way to obtain the maximum long value. While option D (9223372036854775807L) is syntactically valid, it is not recommended because it is error-prone and does not clearly convey intent. Options A and C are incorrect: A has an unnecessary cast, and C omits the L suffix, causing a compile error. Option B exceeds the long range.

Answer

long x = (long) 9223372036854775807L;

Answer

long x = 9223372036854775808L;

Answer

long x = 9223372036854775807;

Answer

long x = 9223372036854775807L;

Answer

long x = 9223372036854775807;

Answer

long x = (long) 1e19;

Question 11

Which TWO statements are true about the String class in Java? (Choose 2)

Accepted Answer

Strings are immutable.. Option C is correct because the Java String class is immutable: once a String object is created, its character sequence cannot be changed, and methods that appear to modify it actually return a new String object. Option E is correct because the intern() method returns a canonical representation of the string and, if the string is not already in the string pool, adds it to the pool (or returns the existing pooled instance). Option A is incorrect because using new String(...) still creates an immutable String object; new only affects whether a new object is created rather than reusing a literal from the pool. Option B is incorrect because String does not implement Cloneable (it is final and its clone() method is not part of its public API contract in the way Cloneable implies). Option D is incorrect because methods like toUpperCase() do not modify the original String; they return a new String with the transformed characters.

Answer

String is mutable if created with new.

Answer

String implements the Cloneable interface.

Answer

String objects can be modified using methods like toUpperCase().

Question 12

Refer to the exhibit. What is the output?

Accepted Answer

17. The correct answer is 17 because the code uses integer arithmetic where the division operator (/) truncates any fractional part. In the expression, the multiplication and division are evaluated left-to-right, and since all operands are integers, the intermediate result of the division is an integer, leading to the final value of 17. This is consistent with Java's integer division rules.

Answer

Compilation error

Answer

25

Answer

21

Question 13

Refer to the exhibit. What is the output?

Accepted Answer

Hello. The code prints 'Hello' because the `String` variable `str` is assigned the value `"Hello"` and then `str.concat("World")` is called. However, `String` objects are immutable in Java, so `concat()` returns a new string without modifying the original `str`. Since the result of `concat()` is not assigned back to `str`, the original `str` remains `"Hello"`, and `System.out.println(str)` outputs `Hello`.

Answer

HelloWorld

Answer

Hello World

Answer

Compilation error

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

true. The code compares two String objects using the == operator. In Java, == checks reference equality, not content. However, because both strings are string literals with the same content, the Java compiler interns them, meaning they refer to the same object in the string pool. Therefore, s1 == s2 evaluates to true. The output is true.

Answer

false

Answer

NullPointerException

Answer

Compilation error: invalid operator

Question 15

A developer wants to compare two String objects for content equality. Which code snippet will work correctly?

Accepted Answer

Both A and C are correct. Option B correctly states that both option A (using `compareTo`) and option C (using `equals`) are valid ways to compare String content for equality. `str1.compareTo(str2) == 0` returns true when the strings are equal, and `str1.equals(str2)` directly compares content. Option D uses `==` which compares object references, not content. Therefore, B is the only correct single answer.

Answer

str1.compareTo(str2) == 0

Answer

str1.equals(str2)

Answer

str1 == str2

Question 16

Which of the following is a valid declaration of a float variable?

Accepted Answer

Both B and D are valid. In Java, a floating-point literal with a decimal point is of type double by default. To assign it to a float variable, you must append an 'f' or 'F' suffix. Therefore, both `float f = 10.5f;` and `float f = 10.5F;` are valid declarations.

Answer

float f = 10.5f;

Answer

float f = 10.5;

Answer

float f = 10.5F;

Question 17

Refer to the exhibit. What is the output?

Accepted Answer

true. The code uses `==` to compare two `String` objects created with string literals (e.g., `String s1 = "true"; String s2 = "true";`). In Java, string literals are interned, meaning they refer to the same object in the string pool. Therefore, the reference comparison returns `true`. The `==` operator checks reference equality, not content equality, but due to interning, the references are the same. If `new String("true")` were used, the comparison would be `false` because different objects are created.

Answer

Runtime exception

Answer

Compilation error

Answer

false

Question 18

Given: int a = 10; int b = 20; boolean flag = a++ > 10 && ++b > 20; What are the values of a and b after execution?

Accepted Answer

a=11, b=20. The expression `a++ > 10 && ++b > 20` uses short-circuit evaluation. Since `a++` is post-increment, the comparison uses the original value of `a` (10) before incrementing, so `10 > 10` is false. Because the left operand is false, the `&&` operator short-circuits and the right operand `++b > 20` is never evaluated. Therefore, `a` is incremented to 11, but `b` remains 20, making option D correct.

Answer

a=10, b=21

Answer

a=10, b=20

Answer

a=11, b=21

Question 19

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

Accepted Answer

||. In Java, the logical operators that operate on boolean operands and return a boolean result are the short-circuit operators && (conditional AND) and || (conditional OR); option A (||) is correct because it is the logical OR operator, and option C (&&) is correct because it is the logical AND operator. Both evaluate their left operand first and may skip evaluating the right operand (short-circuiting), which is the defining behavior of Java's logical operators. The unmarked options do not belong because B (&) and D (|) are bitwise/integer operators (which can also act as non-short-circuit boolean operators but are classified as bitwise), and E (~) is the bitwise complement (NOT) operator, not a logical operator.

Answer

&

Answer

|

Answer

~

Question 20

Given the following code,

String s1 = new String("example");
String s2 = "example";
System.out.println(s1 == s2);

Why does the code output false?

Accepted Answer

s1 is created with 'new' thus not in string pool, s2 is literal in pool, so different references. The code likely creates s1 using the 'new' operator, which forces the creation of a new String object in the heap, not in the string pool. s2 is a string literal, which is interned and placed in the string pool. The '==' operator compares object references, so s1 and s2 refer to different objects, hence the comparison returns false.

Answer

s1 and s2 refer to different objects in the heap

Answer

The String class does not override equals

Answer

The == operator compares value not reference