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

Question 1

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 2

What is the output of the following code? String s1 = "Hello"; String s2 = "Hello"; System.out.println(s1 == s2);

Accepted Answer

true. String literals are interned, so both references point to the same object in the string pool, and == compares references, resulting in true.

Answer

Hello

Answer

Compilation error

Answer

false

Question 3

Given: byte b = 10; b = b + 1; What is the result?

Accepted Answer

Compilation error. In Java, arithmetic operations on byte promote the result to int. Assigning an int to a byte without a cast causes a compilation error.

Answer

Runtime exception

Answer

b becomes 10

Answer

b becomes 11

Question 4

Which operator is used to compare two values for equality in Java?

Accepted Answer

==. The == operator in Java is used to compare two primitive values for equality, returning true if they are equal. For reference types, == compares object references (memory addresses), not the actual content. This is a fundamental operator defined in the Java Language Specification (JLS §15.21) for equality testing.

Answer

equals()

Answer

!=

Answer

=

Question 5

What is the value of the expression: 2 + 3 * 4 / 2 - 1?

Accepted Answer

7. Operator precedence: multiplication and division have higher precedence than addition/subtraction, and they are evaluated left-to-right. So 3*4=12, 12/2=6, 2+6=8, 8-1=7.

Answer

9

Answer

10

Answer

3

Question 6

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 7

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

Accepted Answer

byte. A is correct because `byte` is a primitive data type in Java that stores 8-bit signed integers, ranging from -128 to 127. It is one of the eight primitive types defined in the Java language specification, not an object or reference type.

Answer

String

Answer

Integer

Answer

Boolean

Question 8

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

Accepted Answer

int b = 0xA;. `0xA` is a hexadecimal integer literal in Java, representing the decimal value 10. Java allows hexadecimal literals using the prefix `0x` or `0X`, and they are valid for initializing an `int` variable.

Answer

int e = 10.0;

Answer

int c = 0b2;

Question 9

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

Accepted Answer

||. || is the logical OR operator in Java, which returns true if at least one of the two boolean operands is true. Option C is correct because && is the logical AND operator, which returns true only if both boolean operands are true. Both operators perform short-circuit evaluation, meaning the right operand is not evaluated if the result is already determined by the left operand.

Answer

&

Answer

|

Answer

~

Question 10

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 11

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

Question 12

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

Accepted Answer

50. Multiplication has higher precedence than addition: y * 2 = 40, then x + 40 = 50.

Answer

40

Answer

60

Answer

30

Question 13

A developer is implementing a login verification method that compares a user-entered password against a stored hash. The passwords are stored as String objects. Which approach ensures correct comparison?

Accepted Answer

if (enteredPassword.equals(storedHash)). Option B uses equals(), the standard method for comparing string content, correctly checking character sequences. Option A uses compareTo(), which is intended for ordering; although compareTo() == 0 indicates equality, it is not the idiomatic approach and is considered a trap. Option C uses ==, comparing references, not content. Option D uses hashCode(), which may collide and does not guarantee equality.

Answer

if (enteredPassword.compareTo(storedHash) == 0)

Answer

if (enteredPassword == storedHash)

Answer

if (enteredPassword.hashCode() == storedHash.hashCode())

Question 14

An integer counter variable is incremented in a loop that runs 3 billion times. Initially counter = 0. After the loop, the value is printed. Which code snippet correctly handles potential overflow?

Accepted Answer

long counter = 0; for(long i=0; i<3000000000L; i++) counter++; System.out.println(counter);. Uses a long variable, which can hold the value up to 9e18, avoiding overflow. Options A and B use int and will silently overflow because 3e9 exceeds Integer.MAX_VALUE (2.147e9). Option C uses Math.addExact, which throws an ArithmeticException on overflow; while this detects overflow, the question asks for handling it gracefully, and using a long is the proper approach.

Answer

int counter = 0; for(int i=0; i<3000000000L; i++) counter++; System.out.println(counter);

Answer

int counter = 0; for(int i=0; i<3000000000L; i++) counter += 1; System.out.println(counter);

Answer

int counter = 0; for(int i=0; i<3000000000L; i++) counter = Math.addExact(counter, 1); System.out.println(counter);

Question 15

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

Accepted Answer

10. Casting a double to int truncates the fractional part, so 10.5 becomes 10. Option A (10.0) is incorrect because the result is an int without decimals; Option B is the original value; Option D is incorrect because the code compiles and runs.

Answer

10.0

Answer

10.5

Answer

Compilation error