1Z0-811 Primitives, Strings and Operators — 15 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 = (long) 1e19;

Answer

long x = 9223372036854775807;

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