a. We can store the duplicate elements into ArrayList, LinkedList and Vector.
b. We can store different type of data into List type collections.
c. We can traverse List type collection using Iterator and List Iterator both.
d. The entire List type collection implement the java.lang.Cloneable interface it means these are eligible for Cloning.
e. The entire List type collection implements the java.io.Serializable interface it means these are also eligible for Serialization as well.
f. All the List type collections store their elements in added order.

public interface java.util.Collection<E> extends java.lang.Iterable<E> {
public abstract int size();
public abstract boolean isEmpty();
public abstract boolean contains(java.lang.Object);
public abstract java.util.Iterator<E> iterator();
public abstract java.lang.Object[] toArray();
public abstract <T> T[] toArray(T[]);
public abstract boolean add(E);
public abstract boolean remove(java.lang.Object);
public abstract boolean containsAll(java.util.Collection<?>);
public abstract boolean addAll(java.util.Collection<? extends E>);
public abstract boolean removeAll(java.util.Collection<?>);
public boolean removeIf(java.util.function.Predicate<? super E>);
public abstract boolean retainAll(java.util.Collection<?>);
public abstract void clear();
public abstract boolean equals(java.lang.Object);
public abstract int hashCode();
public java.util.Spliterator<E> spliterator();
public java.util.stream.Stream<E> stream();
public java.util.stream.Stream<E> parallelStream();
}

public class java.util.ArrayList<E> extends java.util.AbstractList<E> implements java.util.List<E>, java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable {
transient java.lang.Object[] elementData;
public java.util.ArrayList(int);
public java.util.ArrayList();
public java.util.ArrayList(java.util.Collection<? extends E>);
public void trimToSize();
public void ensureCapacity(int);
public int size();
public boolean isEmpty();
public boolean contains(java.lang.Object);
public int indexOf(java.lang.Object);
public int lastIndexOf(java.lang.Object);
public java.lang.Object clone();
public java.lang.Object[] toArray();
public <T> T[] toArray(T[]);
E elementData(int);
public E get(int);
public E set(int, E);
public boolean add(E);
public void add(int, E);
public E remove(int);
public boolean remove(java.lang.Object);
public void clear();
public boolean addAll(java.util.Collection<? extends E>);
public boolean addAll(int, java.util.Collection<? extends E>);
protected void removeRange(int, int);
public boolean removeAll(java.util.Collection<?>);
public boolean retainAll(java.util.Collection<?>);
public java.util.ListIterator<E> listIterator(int);
public java.util.ListIterator<E> listIterator();
public java.util.Iterator<E> iterator();
public java.util.List<E> subList(int, int);
static void subListRangeCheck(int, int, int);
public void forEach(java.util.function.Consumer<? super E>);
public java.util.Spliterator<E> spliterator();
public boolean removeIf(java.util.function.Predicate<? super E>);
public void replaceAll(java.util.function.UnaryOperator<E>);
public void sort(java.util.Comparator<? super E>);
static int access$100(java.util.ArrayList);
static {};
}

public class java.util.LinkedList<E> extends java.util.AbstractSequentialList<E> implements java.util.List<E>, java.util.Deque<E>, java.lang.Cloneable, java.io.Serializable {
transient int size;
transient java.util.LinkedList$Node<E> first;
transient java.util.LinkedList$Node<E> last;
public java.util.LinkedList();
public java.util.LinkedList(java.util.Collection<? extends E>);
void linkLast(E);
void linkBefore(E, java.util.LinkedList$Node<E>);
E unlink(java.util.LinkedList$Node<E>);
public E getFirst();
public E getLast();
public E removeFirst();
public E removeLast();
public void addFirst(E);
public void addLast(E);
public boolean contains(java.lang.Object);
public int size();
public boolean add(E);
public boolean remove(java.lang.Object);
public boolean addAll(java.util.Collection<? extends E>);
public boolean addAll(int, java.util.Collection<? extends E>);
public void clear();
public E get(int);
public E set(int, E);
public void add(int, E);
public E remove(int);
java.util.LinkedList$Node<E> node(int);
public int indexOf(java.lang.Object);
public int lastIndexOf(java.lang.Object);
public E peek();
public E element();
public E poll();
public E remove();
public boolean offer(E);
public boolean offerFirst(E);
public boolean offerLast(E);
public E peekFirst();
public E peekLast();
public E pollFirst();
public E pollLast();
public void push(E);
public E pop();
public boolean removeFirstOccurrence(java.lang.Object);
public boolean removeLastOccurrence(java.lang.Object);
public java.util.ListIterator<E> listIterator(int);
public java.util.Iterator<E> descendingIterator();
public java.lang.Object clone();
public java.lang.Object[] toArray();
public <T> T[] toArray(T[]);
public java.util.Spliterator<E> spliterator();
}

public class java.util.Vector<E> extends java.util.AbstractList<E> implements java.util.List<E>, java.util.RandomAccess, jav```a.lang.Cloneable, java.io.Serializable {
protected java.lang.Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
public java.util.Vector(int, int);
public java.util.Vector(int);
public java.util.Vector();
public java.util.Vector(java.util.Collection<? extends E>);
public synchronized void copyInto(java.lang.Object[]);
public synchronized void trimToSize();
public synchronized void ensureCapacity(int);
public synchronized void setSize(int);
public synchronized int capacity();
public synchronized int size();
public synchronized boolean isEmpty();
public java.util.Enumeration<E> elements();
public boolean contains(java.lang.Object);
public int indexOf(java.lang.Object);
public synchronized int indexOf(java.lang.Object, int);
public synchronized int lastIndexOf(java.lang.Object);
public synchronized int lastIndexOf(java.lang.Object, int);
public synchronized E elementAt(int);
public synchronized E firstElement();
public synchronized E lastElement();
public synchronized void setElementAt(E, int);
public synchronized void removeElementAt(int);
public synchronized void insertElementAt(E, int);
public synchronized void addElement(E);
public synchronized boolean removeElement(java.lang.Object);
public synchronized void removeAllElements();
public synchronized java.lang.Object clone();
public synchronized java.lang.Object[] toArray();
public synchronized <T> T[] toArray(T[]);
E elementData(int);
public synchronized E get(int);
public synchronized E set(int, E);
public synchronized boolean add(E);
public boolean remove(java.lang.Object);
public void add(int, E);
public synchronized E remove(int);
public void clear();
public synchronized boolean containsAll(java.util.Collection<?>);
public synchronized boolean addAll(java.util.Collection<? extends E>);
public synchronized boolean removeAll(java.util.Collection<?>);
public synchronized boolean retainAll(java.util.Collection<?>);
public synchronized boolean addAll(int, java.util.Collection<? extends E>);
public synchronized boolean equals(java.lang.Object);
public synchronized int hashCode();
public synchronized java.lang.String toString();
public synchronized java.util.List<E> subList(int, int);
protected synchronized void removeRange(int, int);
public synchronized java.util.ListIterator<E> listIterator(int);
public synchronized java.util.ListIterator<E> listIterator();
public synchronized java.util.Iterator<E> iterator();
public synchronized void forEach(java.util.function.Consumer<? super E>);
public synchronized boolean removeIf(java.util.function.Predicate<? super E>);
public synchronized void replaceAll(java.util.function.UnaryOperator<E>);
public synchronized void sort(java.util.Comparator<? super E>);
public java.util.Spliterator<E> spliterator();
}