How to implement the methods addAll, removeAll, retainAll, toArray(), and toArray(T[]) of the List interface

Question

This is exercise 24_01 from "Introduction to Java Programming and Data Structures". I must implement the methods addAll, removeAll, retainAll, toArray(), and toArray(T[]) from the List interface. I am having difficulty understanding how I may implement these methods without using an iterator to access the elements of the collections. My professor suggested using an array to solve the methods. I have tried using an iterator to compare the elements, however, the system (online coursework for the book) is rejecting the import for iterator. So far I have:

public interface MyList<E> extends java.util.Collection<E> {
  

/** Add a new element at the specified index in this list */
  public void add(int index, E e);

  /** Return the element from this list at the specified index */
  public E get(int index);

  /** Return the index of the first matching element in this list.
   *  Return -1 if no match. */
  public int indexOf(Object e);

  /** Return the index of the last matching element in this list
   *  Return -1 if no match. */
  public int lastIndexOf(E e);

  /** Remove the element at the specified position in this list
   *  Shift any subsequent elements to the left.
   *  Return the element that was removed from the list. */
  public E remove(int index);

  /** Replace the element at the specified position in this list
   *  with the specified element and returns the new set. */
  public E set(int index, E e);
  
  @Override /** Add a new element at the end of this list */
  public default boolean add(E e) {
    add(size(), e);
    return true;
  }

  @Override /** Return true if this list contains no elements */
  public default boolean isEmpty() {
    return size() == 0;
  }

  @Override /** Remove the first occurrence of the element e 
   *  from this list. Shift any subsequent elements to the left.
   *  Return true if the element is removed. */
  public default boolean remove(Object e) {
    if (indexOf(e) >= 0) {
      remove(indexOf(e));
      return true;
    }
    else
      return false;
  }

  @Override
  public default boolean containsAll(Collection<?> c) {
      
            boolean contains = true;
            while(contains == true) {
            for(int i = 0; i < c.size(); i++) {
                if(indexOf() == -1) {
                    contains = false;
                }
                }
            }
            return contains;
  }
        
 

  @Override
  public default boolean addAll(Collection<? extends E> c) {
      
      

  @Override
  public default boolean removeAll(Collection<?> c) {
      Iterator<?> j = c.iterator();
      while(j.hasNext()) {
          if (indexOf(j.next()) >= 0) {
              remove(indexOf(j.next()));
          }
      }
   return true;
  }
  
  @Override
  public default boolean retainAll(Collection<?> c) {
      Iterator<?> j = c.iterator();
      Object temp = j.next();
      while(j.hasNext()) {
      if(indexOf(temp) == -1) {
          remove(indexOf(temp));
      }
    // Left as an exercise
    
  }return true;}

  @Override
  public default Object[] toArray() {
       Object[] j = new Object[this.size()];
        // Left as an exercise

     for (int i = 0; i < this.size(); i++)
                            j[i] = (Object) (this.get(i));
                    if (size() > 0) 
                           
                            return (E[]) temp;
                    
                    else 
                            return null;
                    
                    
    // Left as an exercise
    return null;
  }

  @Override
  public default <T> T[] toArray(T[] array) {
    Object[] j = new Object[this.size()];
    
     for (int i = 0; i < this.size(); i++)
         j[i] = (Object) (this.get(i));
 if (size() > 0) 
        
            return (T[]) temp;
 
 else 
         return null;
 
 
// Left as an exercise
return null;
}
 }