9.19. Medium Multiple Choice QuestionsΒΆ

These problems are like those you will see on the AP CS A exam.

    8-12-1: What is printed as a result of executing the following code segment?

    List<Integer> list1 = new ArrayList<Integer>();
    list1.add(new Integer(1));
    list1.add(new Integer(2));
    list1.add(new Integer(3));
    list1.set(2, new Integer(4));
    list1.add(2, new Integer(5));
    list1.add(new Integer(6));
    System.out.println(list1);
    
  • [1, 2, 3, 4, 5]
  • The set replaces the 3 at index 2 with the 4 so this can't be right.
  • [1, 2, 4, 5, 6]
  • The add with an index of 2 and a value of 5 adds the 5 at index 2 not 3. Remember that the first index is 0.
  • [1, 2, 5, 4, 6]
  • The add method that takes just an object as a parameter adds that object to the end of the list. The set replaces the value at that index with the new value. The add with parameters of an index and an object puts the passed object at that index and moves any existing values by one index to the right (increments the index).
  • [1, 5, 2, 4, 6]
  • The add with an index of 2 and a value of 5 adds the 5 at index 2 not 1. Remember that the first index is 0.

You can step through the code above by clicking on this link Example-8-12-1.

    8-12-2: Given the following code and assume that nums initially contains [0, 0, 4, 2, 5, 0, 3], what will nums contain as a result of executing numQuest?

    private List<Integer> nums;
    
    // precondition: nums.size() > 0;
    // nums contains Integer objects
    public void numQuest()
    {
      int k = 0;
      Integer zero = new Integer(0);
      while (k < nums.size())
      {
       if (nums.get(k).equals(zero))
         nums.remove(k);
       else
          k++;
      }
    }
    
  • [0, 4, 2, 5, 3]
  • This code will loop through the array list and if the current value at the current index (k) is 0 it will remove it. When you remove a value from an array list it moves all values to the right of that one to the the left. It only increments the index when it doesn't find a zero so it work work correctly.
  • [3, 5, 2, 4, 0, 0, 0]
  • This shows all zeros at the end and this code removes 0's so this can't be right.
  • [0, 0, 0, 4, 2, 5, 3]
  • This shows all zeros at the beginning and this code removes zeros so this can't be right.
  • [4, 2, 5, 3]
  • This shows all zeros removed. Since k is only incremented if a value wasn't removed this will work correctly.
  • [0, 0, 4, 2, 5, 0, 3]
  • This shows the original values, but this code does remove some zeros so this can't be right.

You can step through the code above by clicking on this link Example-8-12-2.

    8-12-3: Which of the following best describes the behavior of process1 and process2 (shown below)?

    public static List<Integer> process1(int n)
    {
       List<Integer> someList = new ArrayList<Integer>();
       for (int k = 0; k < n; k++)
          someList.add(k);
       return someList;
    }
    
    public static List<Integer> process2(int n)
    {
       List<Integer> someList = new ArrayList<Integer>();
       for (int k = 0; k < n; k++)
          someList.add(k, k);
       return someList;
    }
    
  • Both methods produce the same result, and process1 is faster than process2.
  • In this case they do the same thing. The only difference would be if there were values in the list in process2.
  • The two methods produce different results and take the same amount of time.
  • These produce the same result on an empty list when you add to the end.
  • The two methods produce different results, and process1 is faster than process2.
  • These produce the same result on an empty list when you add to the end.
  • The two methods produce different results, and process2 is faster than process1.
  • These produce the same result on an empty list when you add to the end.
  • Both methods produce the same result and take the same amount of time.
  • The method process1 adds to the end of the list each time through the loop. The method process2 also adds to the end of the list each time through the loop. The only difference would be if there were values in the list in process2. Any existing values would be moved to the right. But, there are no existing values in the list at that index or beyond.

You can step through the code above by clicking on the link Example-8-12-3.

    8-12-4: What is printed as a result of executing the following code segment?

    List<Integer> aList = new ArrayList<Integer>();
    aList.add(new Integer(1));
    aList.add(new Integer(2));
    aList.add(1, new Integer(5));
    aList.set(1, new Integer(4));
    aList.add(new Integer(6));
    aList.add(new Integer(3));
    System.out.println(aList);
    
  • [1, 2, 5, 4, 6, 3]
  • The set replaces the 3 with the 4 so this can't be right.
  • [6, 5, 4, 3, 2, 1]
  • The add with an index of 2 and a value of 5 adds the 5 at index 2 not 3. Remember that the first index is 0.
  • [1, 2, 3, 4, 5, 6]
  • The add method that takes just a value as a parameter adds that value to the end of the list. The set replaces the value at that index with the new value. The add with parameters of an index and a value puts the passed value at that index and moves any existing values by one index to the right (increments the index).
  • [1, 4, 2, 6, 3]
  • The add with an index of 2 and a value of 5 adds the 5 at index 2 not 1. Remember that the first index is 0.
  • [1, 2, 4, 6, 3]
  • When you declare and create a collection class you can specify the type of the items in it.

You can step through the code above by clicking on the link Example-8-12-4.

    8-12-5: What is printed as a result of executing the following code segment?

    List<Integer> aList = new ArrayList<Integer>();
    aList.add(new Integer(1));
    aList.add(new Integer(2));
    aList.remove(1);
    aList.add(1, new Integer(3));
    aList.set(1, new Integer(4));
    aList.add(new Integer(5));
    System.out.println(list);
    
  • [1, 2, 3, 4, 5]
  • This would be true if the code just added each integer at the end of the list. But, that is not what it does.
  • [1, 4, 5]
  • The list is [1], then [1, 2], then [1], then [1, 3], then [1, 4], then [1, 4, 5].
  • [1, 4, 3, 5]
  • This would be true if the set was an add.
  • [2, 4, 5]
  • This would be true it it was remove(0). Remember that it removes the object at the given index.
  • [2, 4, 3, 5]
  • This would be true if the set was an add and if it was remove(0).

You can step through the code above by clicking on the link Example-8-12-5.

    8-12-6: What is printed as a result of executing the following code segment?

    List<String> list1 = new ArrayList<String>();
    list1.add("a");
    list1.add("b");
    list1.add(0,"c");
    list1.add(1, "d");
    list1.set(2, "e");
    list1.add("f");
    System.out.println(list1);
    
    What is printed as a result of executing the following code segment?
    
  • [c, d, e, b]
  • What happened to the f?
  • [c, d, e, b, f]
  • This list is [a], then [a, b], then [c, a, b], then [c, d, a, b], then [c, d, e, b], then [c, d, e, b, f]
  • [c, a, e, b, f]
  • The a is pushed to position 2 and then replaced with the e.
  • [c, d, e, a, b, f]
  • This would be true if it was list1.add(2,"e")
  • [c, a, e, d, b, f]
  • Remember that the set will replace the value at index 2.

You can step through the code above by clicking on the link Example-8-12-6.

    8-12-7: Given the list nums = [4, 2, 3, 4, 5] what is the result after executing nums.remove(4)?
  • [2, 3, 4, 5]
  • This would be true if it removed the first 4 but it removes the value at index 4.
  • [2, 3, 5]
  • This would be true if it removed all the 4 values, but it removes the value at index 4.
  • [4, 2, 3, 5]
  • This would be true if it removed the value at index 3.
  • [4, 2, 3, 4]
  • This removes the value at index 4 which is 5.

You can step through the code above by clicking on the following Example-8-12-7.

    8-12-8: What is printed as a result of executing the following code segment?

    List<String> list1 = new ArrayList<String>();
    list1.add("a");
    list1.add("b");
    list1.add(0,"c");
    list1.set(1, "d");
    list1.set(0, "e");
    list1.add("b");
    System.out.println(list1);
    
    What is printed as a result of executing the following code segment?
    
  • [e, d, b]
  • This would be true if you couldn't add a duplicate object to a list, but you can.
  • [e, d, b, b]
  • The list is [a], [a, b], [c, a, b], [c, d, b], [e, d, b], and then [e, d, b, b]
  • [e, d, a, b, b]
  • This would be true it list1.set(1,"d"); was list1.add(1,"d");
  • [e, d, a, b]
  • This would be true it list1.set(1,"d"); was list1.add(1,"d"); and if lists didn't allow duplicate objects.

You can step through the code above by clicking on the following Example-8-12-8.

    8-12-9: Assume that numList has been initialized with the following Integer objects: [0, 1, 2, 3, 4]. What is the value of numList after mystery(5) executes?

    private List<Integer> numList;
    public void mystery(int n)
    {
        for (int i = 0; i < n; i++)
        {
            Integer obj = numList.remove(0);
            numList.add(obj);
        }
    }
    
  • [4, 3, 2, 1, 0]
  • This would be true if it was numList.add(numList.size() - i, obj)
  • [1, 2, 3, 4, 0]
  • This would be true if it was mystery(1)
  • [0, 1, 2, 3, 4]
  • Each value is removed one at a time and added to the end of the list which results in the same list.
  • [2, 3, 4, 0, 1]
  • This would be true if it was mystery(2)
  • [4, 0, 1, 2, 3]
  • This would be true if it was mystery(4)

You can step through the code above by clicking on the following Example-8-12-9.

    8-12-10: Assume that numList has been initialized with the following Integer objects: [5, 7, 8, 12]. Which of the following shows the values in numList after a call to mystery(11)?

    private List<Integer> numList;
    public void mystery(int value)
    {
        int i = 0;
        while (i < numList.size() && numList.get(i) < value)
        {
            i++;
        }
        numList.add(i, value);
    }
    
  • [5, 7, 8, 12]
  • What about the 11?
  • [5, 7, 8, 11, 12]
  • This will add the value at the correct location in a list in ascending order.
  • [11, 5, 7, 8, 12]
  • This would be true if it was numList.add(0, value)
  • [5, 7, 8, 12, 11]
  • This would be true if the while loop was from 0 to one less than the size of the list.
  • [5, 7, 11, 8, 12]
  • This would be true if it was numList.add(i-1, value)

You can step through the code above by clicking on the following Example-8-12-10.

Next Section - 9.20. Hard Multiple Choice Questions