Java.lang Class - Finding the output Questions and Answers

Q: What will be the output of the program? public class Program52 { public static void main(String... args) { System.out.println(Math.sqrt(-1) + " " + Math.pow(2, 10)); } }

Correct answer: NaN 1024.0The square root of a negative number is not a domain error in floating point - Math.sqrt returns NaN rather than throwing, since the IEEE 754 arithmetic Java uses defines that result. Math.pow returns a double whatever its arguments, so 2 to the 10 prints as 1024.0 and not 1024. Both details matter to the exact output.

Q: What will be the output of the program? public class Case54 { public static void main(String[] args) throws Exception { int flags = 20; int top = Integer.highestOneBit(flags); int bottom = Integer.lowestOneBit(flags); System.out.println("top=" + top); System.out.println("bottom=" + bottom); } }

Correct answer: top=16 then bottom=4Twenty in binary is 10100. highestOneBit returns the value of the most significant set bit, which is 16, and lowestOneBit the value of the least significant set bit, which is 4. Both return the *value* of the bit rather than its position, which is why the answer is 16 and 4 rather than 4 and 2.

51.

What will be the output of the program?

public class Example51
{
    void run()
    {
        String out = String.format("%05.2f", 3.14159);
        System.out.println(out + " " + out.length());
    }

    public static void main(String[] args)
    {
        new Example51().run();
    }
}

A.The program prints 03.142 6
B.The program prints 3.14 4
C.The program prints 03.14 5
D.The program prints 3.141 5

Answer: C

The format asks for a fixed-point number two places after the decimal point, in a field five characters wide, zero padded. That gives 03.14, which is five characters including the point. Without the 0 flag the padding would have been spaces.

Discuss in Forum

52.

What will be the output of the program?

public class Program52
{
    public static void main(String... args)
    {
        System.out.println(Math.sqrt(-1) + " " + Math.pow(2, 10));
    }
}

A.NaN 1024
B.The program prints -1.0 1024.0
C.An ArithmeticException is thrown.
D.NaN 1024.0

Answer: D

Correct answer: NaN 1024.0

The square root of a negative number is not a domain error in floating point - Math.sqrt returns NaN rather than throwing, since the IEEE 754 arithmetic Java uses defines that result. Math.pow returns a double whatever its arguments, so 2 to the 10 prints as 1024.0 and not 1024. Both details matter to the exact output.

Discuss in Forum

53.

What will be the output of the program?

public class Trial53
{
    Trial53()
    {
        int dividend = -7, divisor = 2;
        int floored = Math.floorDiv(dividend, divisor);
        int wrappedMod = Math.floorMod(dividend, divisor);
        System.out.println(floored + " and " + wrappedMod);
    }

    public static void main(String[] args)
    {
        new Trial53();
    }
}

A.The program prints -4 and 1
B.The program prints -4 and -1
C.The program prints -3 and 1
D.The program prints -3 and -1

Answer: A

floorDiv rounds toward negative infinity, giving -4 where ordinary division truncates to -3, and floorMod returns a result with the sign of the divisor, giving 1 rather than -1. The pair exists precisely because the built-in operators behave the other way.

Discuss in Forum

54.

What will be the output of the program?

public class Case54
{
    public static void main(String[] args) throws Exception
    {
        int flags = 20;
        int top = Integer.highestOneBit(flags);
        int bottom = Integer.lowestOneBit(flags);
        System.out.println("top=" + top);
        System.out.println("bottom=" + bottom);
    }
}

A.top=4 then bottom=16
B.top=16 then bottom=4
C.top=20 then bottom=1
D.top=16 then bottom=1

Answer: B

Correct answer: top=16 then bottom=4

Twenty in binary is 10100. highestOneBit returns the value of the most significant set bit, which is 16, and lowestOneBit the value of the least significant set bit, which is 4. Both return the *value* of the bit rather than its position, which is why the answer is 16 and 4 rather than 4 and 2.

Discuss in Forum

55.

What will be the output of the program?

public class Sketch55
{
    private static void report()
    {
        byte b = (byte) 200;
        short s = (short) 70000;
        System.out.println(b + " " + s);
    }

    public static void main(String[] args)
    {
        report();
    }
}

A.The program prints 127 32767
B.The program prints 200 70000
C.The program prints -56 4464
D.The program prints -56 -4464

Answer: C

Both casts discard the high bits rather than clamping to the maximum. 200 does not fit in a signed byte and wraps to -56, and 70000 wraps to 4464 in a short. Narrowing never saturates in Java, which is why an explicit cast is required.

Discuss in Forum

56.

What will be the output of the program?

public class Item56
{
    void execute()
    {
        System.out.println(Double.compare(0.0, -0.0) + " " + (0.0 == -0.0));
    }

    public static void main(String[] args)
    {
        Item56 demo = new Item56();
        demo.execute();
    }
}

A.The program prints 1 false
B.The program prints 0 false
C.The program prints 0 true
D.The program prints 1 true

Answer: D

The primitive comparison treats the two zeros as equal, so it is true. Double.compare deliberately does not: it orders negative zero below positive zero so that sorting and collections behave consistently, and returns 1. Equal but not identical.

Discuss in Forum

57.

What will be the output of the program?

public class Sample57
{
    public static void main(String[] args)
    {
        Integer a = new Integer(5);
        Integer b = new Integer(5);
        System.out.println((a == b) + " " + a.equals(b) + " " + (a.intValue() == b.intValue()));
    }
}

A.The program prints false true true
B.The program prints false false true
C.The program prints true true false
D.The program prints true true true

Answer: A

Using the constructor always creates a new object, so the identity test is false whatever the value and the cache never applies. equals compares the wrapped values and is true, as is comparing the unboxed ints. This is why valueOf is preferred over the constructor.

Discuss in Forum

58.

What will be the output of the program?

public class Probe58
{
    static void show()
    {
        System.out.println(Integer.decode("0x1f") + " " + Integer.parseInt("1f", 16));
    }

    public static void main(String[] args)
    {
        show();
    }
}

A.The program prints 1f 31
B.The program prints 31 31
C.The program prints 0x1f 31
D.An exception is thrown.

Answer: B

decode understands the 0x prefix and reads the rest as hexadecimal, giving 31. parseInt has no prefix handling but accepts an explicit radix, so 1f base 16 is also 31. Passing 0x1f to parseInt without a radix would throw NumberFormatException.

Discuss in Forum

59.

What will be the output of the program?

public class Demo59
{
    void run()
    {
        String phrase = "hello world";
        boolean allLower = phrase.matches("[a-z ]+");
        String masked = phrase.replaceAll("o", "0");
        System.out.println(allLower);
        System.out.println(masked);
    }

    public static void main(String[] args)
    {
        new Demo59().run();
    }
}

A.false, then hello world
B.false, then hell0 w0rld
C.true, then hell0 w0rld
D.true, then hello world

Answer: C

The pattern allows lower case letters and spaces and must match the whole string, which it does, so matches is true. replaceAll substitutes every o, giving hell0 w0rld. Note matches anchors implicitly, unlike find in a Matcher.

Discuss in Forum

60.

What will be the output of the program?

public class Snippet60
{
    public static void main(String... args)
    {
        String literal = "report";
        StringBuilder builder = new StringBuilder("rep");
        String pooled = builder.append("ort").toString().intern();
        System.out.println(literal == pooled);
    }
}

A.Compilation fails.
B.The result varies between runs.
C.The program prints false
D.The program prints true

Answer: D

The builder produces a brand new String at runtime, which would fail an identity test against the literal. intern is what rescues it: the method returns the pooled instance for that text, and the pool already holds the literal. So both variables end up referencing the same object and the test is true. Dropping the intern call makes it false.

Discuss in Forum

Loading…

Topics

Other Subjects

Tags: Java.lang Class - Finding the output Questions and Answers || Java.lang Class - Finding the output MCQ Questions and Answers || Java.lang Class - Finding the output GK Questions and Answers || Java.lang Class - Finding the output GK MCQ Questions || Java.lang Class - Finding the output Multiple Choice Questions and Answers || Java.lang Class - Finding the output GK || GK on Java.lang Class - Finding the output || Java Programming Questions and Answers || Java Programming MCQ Questions and Answers || Java Programming GK Questions and Answers || GK on Java Programming

Java.lang Class - Finding the output Questions and Answers

Topics

Other Subjects

About Us

Stay informed about all important Dates & Notifications