Objects and Collections - Finding the output Questions and Answers

Q: What will be the output of the program? import java.util.*; public class Example88 { public static void main(String[] args) { Map<Integer, String> m = new HashMap<Integer, String>(); for (int i = 0; i < 3; i++) m.put(i, "v" + i); m.remove(1); System.out.println(m.containsKey(1) + " " + m.size() + " " + m.get(1)); } }

Correct answer: The program prints false 2 nullThe loop puts keys 0, 1 and 2, and remove(1) takes one out. So containsKey(1) is false, the size is 2, and get(1) returns null. Note that a null from get is ambiguous on its own - it means either absent or mapped to null - which is exactly why containsKey exists as a separate method.

81.

What will be the output of the program?

import java.util.*;

public class Sketch81
{
    public static void main(String[] args)
    {
        Collection<String> c = new ArrayList<String>();
        c.add("b"); c.add("a");
        System.out.println(c instanceof List);
    }
}

A.The program prints true
B.Compilation fails.
C.A ClassCastException is thrown.
D.The program prints false

Answer: A

The variable is declared Collection, but instanceof asks about the object, which really is an ArrayList and therefore a List. Declaring a narrower interface limits which methods may be called, never what the object is. Calling get through this variable would not compile.

Discuss in Forum

82.

What will be the output of the program?

import java.util.*;

public class Item82
{
    public static void main(String[] args)
    {
        List<Character> hand = new ArrayList<Character>(
            Arrays.asList('J', 'Q', 'K', 'A'));
        Collections.swap(hand, 0, 3);
        Collections.rotate(hand, 2);
        System.out.println(hand);
    }
}

A.The program prints [A, Q, K, J]
B.The program prints [K, J, A, Q]
C.The program prints [Q, K, J, A]
D.The program prints [J, Q, K, A]

Answer: B

swap exchanges positions 0 and 3, turning [J, Q, K, A] into [A, Q, K, J]. rotate by 2 then shifts every element two places right, wrapping the tail around to the front, which gives [K, J, A, Q]. Both work in place and return nothing.

Discuss in Forum

83.

What will be the output of the program?

import java.util.*;

public class Sample83
{
    public static void main(String[] args)
    {
        List<String> src = new ArrayList<String>(
            Arrays.asList("x", "y"));
        List<String> dst = new ArrayList<String>(
            Arrays.asList("1", "2", "3"));
        Collections.copy(dst, src);
        System.out.println(dst);
    }
}

A.An IndexOutOfBoundsException is thrown.
B.The program prints [x, y]
C.The program prints [x, y, 3]
D.The program prints [1

Answer: C

copy overwrites the leading elements of the destination and leaves the rest alone, so the third entry survives. It requires the destination to be at least as long as the source and throws IndexOutOfBoundsException otherwise; it never grows the list.

Discuss in Forum

84.

What will be the output of the program?

import java.util.*;

public class Probe84
{
    public static void main(String[] args)
    {
        Map<String, Integer> inventory = new TreeMap<String, Integer>();
        inventory.put("apple", 4);
        Collection<Integer> counts = inventory.values();
        inventory.put("pear", 6);
        inventory.put("apple", 9);
        System.out.println(counts.size() + " " + counts.contains(9));
    }
}

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

Answer: D

values is a live view rather than a snapshot, so both the new entry and the replaced value show through it: the size reads 2 and the updated 9 is present. No exception arises because nothing is iterating; fail-fast behaviour only applies once an iterator is under way.

Discuss in Forum

85.

What will be the output of the program?

import java.util.*;

public class Demo85
{
    public static void main(String[] args)
    {
        List<String> l = new ArrayList<String>();
        System.out.println(l.equals(new LinkedList<String>()) + " " +
            l.equals(new HashSet<String>()));
    }
}

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

Answer: A

Two empty Lists are equal whatever their implementation class, because List equality is defined across the interface. A List is never equal to a Set, however, since neither side's contract accepts the other, so the second test is false even though both are empty.

Discuss in Forum

86.

What will be the output of the program?

import java.util.*;

public class Listing86
{
    static class Item
    {
        String sku;
        Item(String sku) { this.sku = sku; }

        public boolean equals(Object o)
        {
            return ((Item) o).sku.equals(sku);
        }

        public int hashCode() { return sku.hashCode(); }
    }

    public static void main(String[] args)
    {
        Set<Item> set = new HashSet<Item>();
        set.add(new Item("x"));
        System.out.println(set.contains("x"));
    }
}

A.The program prints true
B.A ClassCastException is thrown.
C.The program prints false
D.Compilation fails.

Answer: B

contains passes the String to Item.equals, which casts its argument to Item without an instanceof guard and throws ClassCastException. A correct equals begins by testing the type and returns false for anything else, which is why the instanceof check is not optional.

Discuss in Forum

87.

What will be the output of the program?

import java.util.*;

public class Fragment87
{
    public static void main(String[] args)
    {
        Set<String> tags = new LinkedHashSet<String>();
        Collections.addAll(tags, "red", "green");
        Iterator<String> walker = tags.iterator();
        System.out.print(walker.next());
        tags.remove("green");
        System.out.print(walker.next());
    }
}

A.red, then nothing
B.The program prints red, then green
C.red, then a ConcurrentModificationException
D.a ConcurrentModificationException before anything is printed

Answer: C

The first next runs before any change and prints red. Removing an element afterwards is a structural modification, so the next step notices the modification count has moved and throws. The check happens on each call rather than when the iterator is created, which is why part of the output appears first.

Discuss in Forum

88.

What will be the output of the program?

import java.util.*;

public class Example88
{
    public static void main(String[] args)
    {
        Map<Integer, String> m = new HashMap<Integer, String>();
        for (int i = 0; i < 3; i++) m.put(i, "v" + i);
        m.remove(1);
        System.out.println(m.containsKey(1) + " " + m.size() + " " + m.get(1));
    }
}

A.The program prints false 3 null
B.The program prints true 2 v1
C.The program prints true 3 v1
D.The program prints false 2 null

Answer: D

Correct answer: The program prints false 2 null

The loop puts keys 0, 1 and 2, and remove(1) takes one out. So containsKey(1) is false, the size is 2, and get(1) returns null. Note that a null from get is ambiguous on its own - it means either absent or mapped to null - which is exactly why containsKey exists as a separate method.

Discuss in Forum

89.

What will be the output of the program?

import java.util.*;

public class Program89
{
    public static void main(String[] args)
    {
        List<String> one = Collections.singletonList("only");
        List<String> copy = new ArrayList<String>(one);
        copy.add("more");
        System.out.println(
            one.size() + " " + copy.size() + " " + one.contains("more"));
    }
}

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

Answer: A

singletonList returns an immutable list of exactly one element, so it cannot be added to, but copying it into an ArrayList gives an ordinary list that can grow. The original stays at 1 and knows nothing of the addition. Copying is the way to build on one of these fixed collections.

Discuss in Forum

90.

What will be the output of the program?

import java.util.*;

public class Trial90
{
    public static void main(String[] args)
    {
        List<Integer> l = new ArrayList<Integer>(
            Arrays.asList(3, 1, 2));
        List<Integer> unmod = Collections.unmodifiableList(l);
        l.add(4);
        System.out.println(unmod.size());
    }
}

A.The program prints 3
B.The program prints 4
C.An UnsupportedOperationException is thrown.
D.The program prints 0

Answer: B

The wrapper is a read-only VIEW, not a frozen copy, so it forbids changes made THROUGH it while still reflecting changes made to the list underneath. The size therefore reads 4. Guaranteeing immutability means wrapping a copy that nothing else holds a reference to.

Discuss in Forum

Loading…

Topics

No topic!

Other Subjects

Tags: Objects and Collections - Finding the output Questions and Answers || Objects and Collections - Finding the output MCQ Questions and Answers || Objects and Collections - Finding the output GK Questions and Answers || Objects and Collections - Finding the output GK MCQ Questions || Objects and Collections - Finding the output Multiple Choice Questions and Answers || Objects and Collections - Finding the output GK || GK on Objects and Collections - Finding the output || Java Programming Questions and Answers || Java Programming MCQ Questions and Answers || Java Programming GK Questions and Answers || GK on Java Programming

Objects and Collections - Finding the output Questions and Answers

Topics

Other Subjects

About Us

Stay informed about all important Dates & Notifications