Question

Consider the following output and try to guess the answer

Answer
The output will be "hello". The Unicode character \u000d is a carriage return and acts as a new line character.
Thus, the commented line is interpreted as a new line of code.

Question
Try to guess the answer of the following output
String s1 = "Java";
String s2 = "Java";
StringBuilder sb1 = new StringBuilder();
sb1.append("Ja").append("va");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
System.out.println(sb1.toString() == s1);
System.out.println(sb1.toString().equals(s1));
 true is printed out exactly once.
 true is printed out exactly twice.
 true printed out exactly thrice.
 true printed out exactly four times.
 Error

Answer
The output will be "true printed out exactly four times". The == operator compares if the two references point to
the exact same object, while the equals() method checks if the contents of the two objects are equivalent. String
literals are interned in Java, so s1 and s2 refer to the same object. StringBuilder generates a new String object, so
sb1.toString() != s1, but its contents are the same as s1.

Question
Answer the following question
public class Demo {
public static void main(String args[]) {
System.out.print("a");
try {
System.out.print("b");
throw new IllegalArgumentException();
 }
catch (RuntimeException e) {
System.out.print("c");
}
finally {
System.out.print("d");
}
System.out.print("e");
}
}
 abe
 abce
 abde
 abcde
 Uncaught exception thrown

Answer
The output will be "abcde". Even though an exception is thrown in the try block, the finally block will always be
executed.

Question
Consider the following question to guess the answer:
public class Test {
public static void main(String args[]) {
int i=20+ +9- -12+ +4- -13+ +19;
System.out.println(i);
}
}
 27
 33
 66
 76
 77

Answer
The output will be "77". The unary plus and minus operators have higher precedence than the binary plus and
minus operators, and unary plus doesn't change the sign of its operand.

Question
Consider the following code to answer
public class Actors {
Public static void main(String arg[]) {
char[] ca ={0x4e, \u004e, 78};
System.out.println((ca[0] = = ca[1]) + " "+ (ca[0] = = ca[2]));
}
}
 false false
 true true
  false true
 true false
 Error

Answer
The output will be "true true". All three elements in the character array represent the same numeric value (78), so
the comparisons are true.

Question
What will be the output of the following code
public class _C {
private static int $;
public static void main(String main[]) {
String a_b;
System.out.print($);
System.out.print(a_b);
}
}
 Compile error at line 4
 Compile error at line 2
 Compile error at line 1
 Compile error at line 5
 Compile error at line 8

Answer
The output will be "Compile error at line 5". Local variables need to be initialized before they are used.

Question
What will be the answer of the given code:
switch(x) {
case x>70:
System.out.println("True");
break;
case 65<x<=70:
System.out.println("False");
break;
}
 Assertion error
 Stack overflow
 Orphaned case
 IO error
 Output of memory error

Answer
The output will be "Orphaned case". Case labels in switch statements must be constant expressions (typically
integers, enums, or string literals), not boolean expressions.

Question
Consider the following code to answer:
public class Demo {
static int x=1111;
static {
x=x-- - --x;
}
{
x=x++ + ++x;
}
public static void main(String args[]) {
System.out.println(x);
}
}
 2
 1110
 1109
 1
 11

Answer
The output will be "2". The static block is executed before the instance initializer block, and both blocks change the
value of x.

Question
What will be the output of the following code:
import java.lang.Math;
public class Example {
public static void main(String args[]) {
String computerMove;
switch ( (int)(3*Math.random()) ) {
case 0:
computerMove = "Rock";
break;
case 1:
computerMove = "Scissors";
break;
case 2:
computerMove = "Paper";
break;
}
System.out.println("Computer's move is " + computerMove);
}
}
 Paper
 Rock
 Scissors
 Syntax error
 Exception
Answer
The output could be "Paper", "Rock", or "Scissors". The switch statement randomly selects one of the three cases.

Question
Consider the following code to give the answer:
public class TestHashMap {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<String,String>(){
{
put("1", "ONE");
} {
put("2", "TWO");
}{
put("3", "THREE");
}
};
Set<String> keySet = map.keySet();
for (String string : keySet) {
System.out.println(string+" ->"+map.get(string));
}
}
}
 The use of double brace initialization is not allowed in Java
 The first set of brace creates a new anonymous inner class, and the second set of brace creates an instance initialize like static block in
class
 The second set of brace creates a new anonymous inner class, and the first set of brace creates an instance initialize like static block in
class
 Niether first set of braces creates an anonymous inner class, nor the second set of brace creates an instance initialize like static block in
class
 None of the above

Answer
The correct answer is "The first set of brace creates a new anonymous inner class, and the second set of brace
creates an instance initialize like static block in class". This pattern is known as double brace initialization.

Question
What will we get after compiling the following code?
public class ExceptionDemo {
public static void main(String args[]) {
Object x[] = new String[3];
x[0] = new Integer(0);
}
}
 Negative Array Size Exception
 Array store exception
 Null pointer exception
 Class cast exception
  Array index out of bounds exception

Answer
The output will be "Array store exception". The runtime type of the array is String[], so it cannot hold Integer
objects.

Question
Consider the situation
If we put System.exit(0) on try to catch block in such a case Will finally block execute or not? Also specify the reason
 It skips the final block
 It is an invalid situation
 The final block may or may not be executed
 JVM exit with SecurityException and final block execute
 JVM exit without SecurityException and final block will not be executed

Answer
The correct answer is "JVM exit without SecurityException and final block will not be executed". System.exit(0)
terminates the JVM immediately, so the finally block does not execute.

Question
Consider the following code to give the correct answer:
import java.util.Arrays;
public class SplitString {
public static void main(String args[]) {
String str="Java|Python|Hadoop";
String[] array = str.split("\|");
System.out.println(Arrays.toString(array));
}
}
 [Java\Python\Hadoop]
 [Java|Python|Hadoop]
 [Java\|Python\|Hadoop]
 [Java, Python, Hadoop]

Answer
The output will be "[Java, Python, Hadoop]". The split() method uses a regular expression to split the string, and |
is a metacharacter that needs to be escaped.

Question
Evaluate the following statement:
long longWithL = 1000*60*60*24*365L;
long longWithoutL = 1000*60*60*34*365;
 Compile time error
 Arithmetic exception
 31536000000 and 1726327040
 3.1536e10 and 1.72632704e9
 31536000000L and 1726327040
Answer
The correct answer is "31536000000 and 1726327040". The L suffix makes the first number a long literal, so the
computation doesn't overflow. The second number is computed as an int and overflows.

Question
Evaluate the following code and give the answer carefully:
Open Compiler
class Base{
public static void main(String[] args){
System.out.println("Hello");
}
}
public class Test extends Base{}
 Compile time error
 Runtime error
 Compiles and run with no output
 Compiles and runs printing hello
 Error at line 6

Answer
The output will be "Compiles and runs printing hello". The main method is inherited from the Base class and
executed when the Test class is run.