Skip to main content
Logo image

BHSawesome2 AP CSA Java 2025+

Section 4.33 Code Practice with ArrayLists

Activity 4.33.1.

Fix the following code so that it compiles. The code should instantiate an ArrayList of Strings names and fill it with the Strings from the array friends. It should then print out names.
🔗
Solution.
In line 10, change the terminating condition to i < friends.length so that you don’t go out of bounds of the array.
🔗
import java.util.*;

public class Test1
{
    public static void main(String[] args)
    {
        ArrayList<String> names = new ArrayList<String>();
        String[] friends = {"Sam", "Jessica", "Mark", "Alexis"};
        for (int i = 0; i < friends.length; i++)
        {
            names.add(friends[i]);
        }
        System.out.println(names);
    }
}
🔗
🔗

Activity 4.33.2.

Fix the following class so that it will compile and the method reverse will return an ArrayList containing Integers in the reversed order of the ArrayList parameter list. Hint: for this solution, only one line needs to be added to the for-loop inside of the reverse method.
🔗
Solution.
Change line 8 int to Integer because ArrayLists only store objects and int is a primitive. Add in line 11 reversed.add(0, element); so that each element of the ArrayList list, the parameter, is added in front of the previously added element (thereby reversing the order).
🔗
Note that there are other equally correct ways to reverse the order of the ArrayList without creating a new Array or by traversing through it backwards.
🔗
import java.util.*;

public class Test1
{
    public static ArrayList<Integer> reverse(ArrayList<Integer> list)
    {
        ArrayList<Integer> reversed = new ArrayList<Integer>();
        for (Integer element : list)
        {
            reversed.add(0, element);
        }
        return reversed;
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {1, 5, 7, 9, -2, 3, 2};
        for (int i = 0; i < nums.length; i++)
        {
            values.add(nums[i]);
        }
        ArrayList<Integer> result = reverse(values);
        System.out.println("Expected Result:\t [2, 3, -2, 9, 7, 5, 1]");
        System.out.println("Your Result:\t\t " + result);
    }
}
🔗
🔗

Activity 4.33.3.

Fix the following method printEvenIndex so that it will print out the Integers at even indices of the passed-in ArrayList list.
🔗
Solution.
In line 8, the for loop should be written as for (int i = 0; i < list.size(); i++) so that the method will traverse through all elements of the ArrayList list. In the line 10 conditional, it should be checking when the index, i is even - in other words, checking if it is divisible by 2 with no remainder: i % 2 == 0.
🔗
import java.util.*;

public class Test1
{
    public static void printEvenIndex(ArrayList<Integer> list)
    {
        for (int i = 0; i < list.size(); i++)
        {
            if (i % 2 == 0)
            {
                System.out.print(list.get(i) + ", ");
            }
        }
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {1, 5, 7, 9, -2, 3, 2};
        for (int i = 0; i < nums.length; i++)
        {
            values.add(nums[i]);
        }
        System.out.println("Expected Result:\t 1, 7, -2, 2,");
        System.out.print("Your Result:\t\t ");
        printEvenIndex(values);
    }
}
🔗
🔗

Activity 4.33.4.

Fix the following method printEvenElements so that it will print out all of the even Integers that are in the passed-in ArrayList list.
🔗
Solution.
In line 7, ArrayLists do not have a length property; instead, call the size() method to find out how long an ArrayList is.
🔗
import java.util.*;

public class Test1
{
    public static void printEvenElements(ArrayList<Integer> list)
    {
        for (int i = 0; i < list.size(); i++)
        {
            if (list.get(i) % 2 == 0)
            {
                System.out.print(list.get(i) + ", ");
            }
        }
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {1, 44, 7, 9, -16, 3, 2};
        for (int i = 0; i < nums.length; i++)
        {
            values.add(nums[i]);
        }
        System.out.println("Expected Result:\t 44, -16, 2,");
        System.out.print("Your Result:\t\t ");
        printEvenElements(values);
    }
}
🔗
🔗

Activity 4.33.5.

Rewrite the following code so that it fills the ArrayList values with the elements of the array nums using a for-each loop instead of a for loop.
🔗
Solution.
In a for-each loop you specify the type of the values in the array, a name for the current value, and then a : and then the name of the array. You then want to add each element to the values ArrayList.
🔗
import java.util.ArrayList;

public class Test1
{
    public static void main(String[] args)
    {
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {1, 44, 7, 9, -16, 3};
        for (int element : nums)
        {
            values.add(element);
        }
        System.out.println("Expected Result:\t [1, 44, 7, 9, -16, 3]");
        System.out.println("Your Result:\t\t " + values);
    }
}
🔗
🔗

Activity 4.33.6.

Finish the following method ``sumNegVal`` to return the sum of all of the negative numbers in the ArrayList ``list``, the parameter.
🔗
Solution.
Declare a variable to hold the sum and initialize it to zero. Loop through all the values in the ArrayList. If the current value is negative (less than 0) then add it to the sum. Return the sum.
🔗
import java.util.ArrayList;

public class Test1
{
    public static int sumNegValues(ArrayList<Integer> list)
    {
        int sum = 0;
        for (Integer element : list)
        {
            if (element < 0)
            {
                sum += element;
            }
        }
        return sum;
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {-2, 34, -11, 9, -6, 3};
        for (int i = 0; i < nums.length; i++)
        {
            values.add(nums[i]);
        }
        System.out.println("Expected Result:\t -19");
        System.out.print("Your Result:\t\t ");
        System.out.println(sumNegValues(values));
    }
}
🔗
🔗

Activity 4.33.7.

Finish the following method ‘’removeLongStrings’’ that checks each element of the passed in ArrayList list and removes any that are strictly longer than 4 characters.
🔗
Solution.
Loop through all of the elements of the ArrayList list. In each iteration, check if the length of each element is strictly greater > than 4; if it is, remove that element.
🔗
import java.util.ArrayList;

public class Test1
{
    public static void removeLongStrings(ArrayList<String> list)
    {
        int count = 0;
        while (count < list.size())
        {
            if (list.get(count).length() > 4)
            {
                list.remove(count);
            }
            else
            {
                count++;
            }
        }
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<String> values = new ArrayList<String>();
        String[] words = {"bathtub", "fish", "computer", "cat", "foo"};
        for (int i = 0; i < words.length; i++)
        {
            values.add(words[i]);
        }
        removeLongStrings(values);
        System.out.println("Expected Result:\t [fish, cat, foo]");
        System.out.println("Your Result:\t\t " + values);
    }
}
🔗
🔗

Activity 4.33.8.

Fill in the method shiftLeftOne below to shift all of the elements of the passed-in ArrayList list left by one. The original first element should be wrapped to the back of the list after the shift. Ex: {1, 2, 3, 4} should turn turn into {2, 3, 4, 1}
🔗
Solution.
Remove the first element of list and save it to a new variable of type Integer. Because of the nature of remove, everything else in the ArrayList will shift left accordingly. The only thing left to do after that is add this value to the back of the ArrayList.
🔗
import java.util.ArrayList;

public class Test1
{
    public static void shiftLeftOne(ArrayList<Integer> list)
    {
        Integer firstVal = list.remove(0);
        list.add(firstVal);
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {1, 2, 3, 4, 5};
        for (int i = 0; i < nums.length; i++)
        {
            values.add(nums[i]);
        }
        shiftLeftOne(values);
        System.out.println("Expected Result:\t [2, 3, 4, 5, 1]");
        System.out.println("Your Result:\t\t " + values);
    }
}
🔗
🔗

Activity 4.33.9.

Finish the method moveSmallest so that it finds the smallest value in the passed-in ArrayList list and moves it to the front of the list.
🔗
Solution.
Fill-in the for loop so that it will traverse through the entire ArrayList. The conditional should check if the current element at index i is less than the element at smallestIndex. After the for-loop has completed, the method must remove the value at smallestIndex and save it to a variable, and then add it to the front of the ArrayList
🔗
import java.util.ArrayList;

public class Test1
{
    public static void moveSmallest(ArrayList<Integer> list)
    {
        int smallestIndex = 0;
        for (int i = 0; i < list.size(); i++)
        {
            if (list.get(i) < list.get(smallestIndex))
            {
                smallestIndex = i;
            }
        }
        Integer smallest = list.remove(smallestIndex);
        list.add(0, smallest);
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<Integer> values = new ArrayList<Integer>();
        int[] nums = {3, 11, 54, 7, 1, 22};
        for (int i = 0; i < nums.length; i++)
        {
            values.add(nums[i]);
        }
        moveSmallest(values);
        System.out.println("Expected Result:\t [1, 3, 11, 54, 7, 22]");
        System.out.println("Your Result:\t\t " + values);
    }
}
🔗
🔗

Activity 4.33.10.

Finish the method findLongest to find and return the longest String in the ArrayList of Strings list.
🔗
Solution.
Declare a variable to hold the longest String. Initialize it to the empty string "". Loop through all the values in the ArrayList and compare its length to the length of longest. Return longest.
🔗
import java.util.ArrayList;

public class Test1
{
    public static String findLongest(ArrayList<String> list)
    {
        String longest = "";
        for (String element : list)
        {
            if (element.length() > longest.length())
            {
                longest = element;
            }
        }
        return longest;
    }

    public static void main(String[] args)
    {
        // instantiate ArrayList and fill with Integers
        ArrayList<String> values = new ArrayList<String>();
        String[] words = {"singapore", "cattle", "metropolitan", "turnstile"};
        for (int i = 0; i < words.length; i++)
        {
            values.add(words[i]);
        }
        System.out.println("Expected Result:\t metropolitan");
        System.out.print("Your Result:\t\t ");
        System.out.println(findLongest(values));
    }
}
🔗
🔗
You have attempted of activities on this page.
🔗
PrevTopNext