Integer, Double, and Boolean to wrap a primitive value in an object so that you can put it in a list. Java will also do this automatically for you if you try to add a primitive value to a list or set a primitive variable to an item of a list. This is called autoboxing and unboxing.
int value to a list, it will automatically be converted to an Integer object.
listName.add(obj). You can add an object at an index of a list using add(index,obj). This will first move any objects at that index or higher to the right one position to make room for the new object.
ArrayList<Type> name, where Type is the class name for the type of objects in the list. If you leave off the <Type> it will default to Object.
new ArrayList<Type>, where Type is the class name for the type of objects you want to store in the list. There are other classes that implement the List interface, but you only need to know the ArrayList class for the exam.
listName.get(index).
list1 is at index 0 list1.get(0). The last element in a list is at the length minus one - list1[list1.size() - 1].
ListName.remove(index). This will move all object past that index to the left one index.
listName.set(index,obj).
listName.size() to get the number of objects in the list.
Integer for int, Double for double and Boolean for boolean.
Integer into a primitive type such as an int.
setreplaces the item at the indexremoveat an index moves all items that were to the right of that index left one indexaddat an index moves everything that was at the index and greater to the right one index
ArrayList methods like the following.
List<Integer> numList = new ArrayList<Integer>();
numList.add(new Integer(1));
numList.add(new Integer(2));
numList.add(new Integer(3));
numList.set(2,new Integer(4));
numList.add(1, new Integer(5));
numList.add(new Integer(6));
System.out.println(numList);
set will replace the 3 at index 2 so this isn’t correct.add with an index of 1 and a value of 5 adds the 5 at index 1 not 3. Remember that the first index is 0.set will change the item at index 2 to 4. The add of 5 at index 1 will move everything else to the right and insert 5. The last add will be at the end of the list.add without an index adds at the end, set will replace the item at that index, add with an index will move all current values at that index or beyond to the right.List<Integer> list1 = new ArrayList<Integer>();
list1.add(new Integer(1));
list1.add(new Integer(2));
list1.add(new Integer(3));
list1.remove(1);
System.out.println(list1);
remove will remove the item at the given index.findMax method that finds and returns the largest value in an ArrayList of Integers.
countOdd that returns the number of odd numbers in an ArrayList of Integers.
hasDuplicates that returns true if there are any duplicate elements in an ArrayList of Integers.
rotateLeft that rotates the elements in an ArrayList of Integers to the left by one position.
reverse below to return an ArrayList containing Integers in the reversed order of the ArrayList parameter list. Hint: use a for loop with one line inside it to add to the new list.
names and fill it with the Strings from the array friends. It should then print out names.
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);
}
}
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.
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).
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);
}
}
printEvenIndex so that it will print out the Integers at even indices of the passed-in ArrayList list.
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);
}
}
printEvenElements so that it will print out all of the even Integers that are in the passed-in ArrayList list.
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);
}
}
values with the elements of the array nums using a for-each loop instead of a for loop.
: 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);
}
}
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));
}
}
list and removes any that are strictly longer than 4 characters.
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);
}
}
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}
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);
}
}
moveSmallest so that it finds the smallest value in the passed-in ArrayList list and moves it to the front of the list.
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);
}
}
findLongest to find and return the longest String in the ArrayList of Strings list.
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));
}
}
