Reference no: EM131119541

Java Quiz

Question 1

Method A invokes method A itself. This is called _________.

indirect recursion
explicit recursion
direct recursion
one-step recursion

Question 2

What are the base cases in the following recursive method?

public static void recurse(int n)
{
if (n > 0)
{
System.out.print(n % 10);
recurse(n / 10);
}
}

n < 0
n <= 0
n > 0
no base cases

Question 3

What will be displayed by the method call recurse(1234)?

public static void recurse(int n)
{
if (n <= 0)
{
System.out.print(n % 10);
recurse(n / 10);
}
}

1234
4 3 2 1
Nothing
4321

Question 4

Analyze the following recursive method and indicate which of the following will be true.

public static long factorial(int n)
{
return n * factorial(n - 1);
}

Invoking factorial(2) returns 2.
Invoking factorial(1) returns 1.
The method runs infinitely and causes a StackOverflowError.
Invoking factorial(0) returns 0.

Question 5

Fill in the code to complete the following method for computing factorial.

// Return the factorial for a specified index
public static long factorial(int n)
{
if (n == 0)
return 1;
else
return _____________;
}

n * (n - 1)
n
n * factorial(n - 1)
factorial(n - 1) * (n - 1)

Question 6

What will be displayed by the method call recurse(6)?

public static intrecurse(int n)
{
if (n <= 1)
return 1;
else
return n + recurse(n - 2);
}

13
14
11
12

Question 7

The base case _________ the recursion.

stops
breaks
pauses
starts

Question 8

What is the output of the following program?

{
public static void main(String[] args)
{
System.out.println(countDown(2, 0));
}
public static intcountDown(int n, int result)
{
if (n == 0)
return 0;
else
return countDown(n - 1, n + result);
}
}

1
3
0
2

Question 9

Which of the following statements about recursive methods is accurate?

They must have exactly 1 base case and exactly 1 recursive case
They must have at least 1 base case and at least 1 recursive case
They must have exactly 1 base case and at least 1 recursive case
They must have at least 1 base case and exactly 1 recursive case

Question 10

Which of the following is a possible disadvantage of recursion?

Recursive solutions can be less efficient than their iterative counterparts
Recursive solutions tend to have more local variables than their iterative counterparts
Recursive solutions tend to be longer than their iterative counterparts
Recursive solutions are more likely to go into infinite loops than their iterative counterparts

Question 11

To declare an interface named A with two generic types, use

public interface A(E) { ... }
public interface A<E, F> { ... }
public interface A<E> { ... }
public interface A(E, F) { ... }

Question 12

Will the following code have a runtime error?
Comparable date = new Date();
inti = date.compareTo("time");

Always
Never
Only when date contains an invalid date
Only when date is not the current date

Question 13

To create a list to store integers, use

ArrayList<Object> list = new ArrayList<Integer>();
ArrayList<Number> list = new ArrayList<Integer>();
ArrayList<int> list = new ArrayList();
ArrayList<Integer> list = new ArrayList();

Question 14

To create a generic type bounded by Number, use

<E extends Object>
<E extends Number>
<E>
<E extends Integer>

Question 15

Which of the following describes the benefit of using generic classes to implement collections?

It eliminates the need to downcast objects when they are removed from a collection
It eliminates the need to upcast objects when they are inserted into a collection
It eliminates the need to downcast objects when they are inserted into a collection
It eliminates the need to upcast objects when they are removed from a collection

Question 16

Suppose list list1 is [1, 2, 5] and list list2 is [2, 3, 6]. After list1.addAll(list2), list2 is __________.

[1, 5]
[1, 2, 3, 5, 6]
[2, 3, 6]
[1, 2, 2, 3, 5, 6]

Question 17

Suppose a list contains {red, red, red, red}. What is the list after the following code?

String element = "red";
for (inti = list.size() - 1; i>= 0; i--)
if (list.get(i).equals(element))
list.remove(element);

[red]
[red, red]
[]
[red, red, red]

Question 18

Which of the following is correct to sort the elements in a list aList?

Arrays.sort(aList)
new LinkedList<String>(new String[]{red, green, blue})
Collections.sort(aList)
aList.sort()

Question 19

Which of the following best describes all objects of type List?

They define an ordered collection that prohibits duplicates
They define an ordered collection that allows duplicates
They define an unordered collection that allows duplicates
They define an unordered collection that prohibits duplicates

Question 20

Which of the following problems would be a good candidate for using a stack?

A print spooler that dispatches jobs based on shortest job first
An inventory system that processes product records by product number
A program that is designed to evaluate expressions
A task scheduler that schedules tasks in the order that they are received.