Collectables HW

// part 1
import java.util.ArrayList;
import java.util.List;

public class ListUtils {
    public static List<Integer> getEvenNumbers(List<Integer> numbers) {
        List<Integer> evens = new ArrayList<>();
        for (int i = 0; i < numbers.size(); i++) {
            int num = numbers.get(i);
            if (num % 2 == 0) {
                evens.add(num);
            }
        }
        return evens;
    }
}
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(3);
numbers.add(2);
numbers.add(4);
ListUtils.getEvenNumbers(numbers);

[2, 4]

// part 2
import java.util.HashSet;
import java.util.Set;

public class SetUtils {
    public static Set<Integer> getIntersection(Set<Integer> set1, Set<Integer> set2) {
        Set<Integer> intersection = new HashSet<>();
        for (Integer element : set1) {
            if (set2.contains(element)) {
                intersection.add(element);
            }
        }
        return intersection;
    }
}

Set<Integer> nums = new HashSet<>();
        
nums.add(1);
nums.add(2);
nums.add(3);

Set<Integer> nums2 = new HashSet<>();
        
nums2.add(2);
nums2.add(3);
nums2.add(4);

SetUtils.getIntersection(nums, nums2);

[2, 3]

// part 3
import java.util.ArrayDeque;
import java.util.Deque;

public class DequeDemo {
    public static void simulateLine() {
        Deque<String> line = new ArrayDeque<>();

        line.addLast("Customer1");
        line.addLast("Customer2");
        line.addLast("Customer3");

        line.addFirst("VIP");

        line.removeFirst();

        System.out.println("Front of the line: " + line.peekFirst());
        System.out.println("Back of the line: " + line.peekLast());

        System.out.println("Line size: " + line.size());
    }
}

DequeDemo.simulateLine();

Front of the line: Customer1
Back of the line: Customer3
Line size: 3

part 4:

A hashset would be most efficient for its low O(1) time complexity for the add, remove, and contains methods, and lack of allowed dupes (hashsets cannot have duplicates by default).