code: public boolean addAll(int index, Collection<? extends E> c) {
          try {
              boolean modified = false;
              ListIterator<E> e1 = listIterator(index);
              Iterator<? extends E> e2 = c.iterator();
              while (e2.hasNext()) {
                  e1.add(e2.next());
                  modified = true;
              }
              return modified;
          } catch (NoSuchElementException exc) {
              throw new IndexOutOfBoundsException("Index: "+index);
          }
      }
docs: Inserts all of the elements in the specified collection into this
  list at the specified position (optional operation).  Shifts the
  element currently at that position (if any) and any subsequent
  elements to the right (increases their indices).  The new elements
  will appear in this list in the order that they are returned by the
  specified collection's iterator.  The behavior of this operation is
  undefined if the specified collection is modified while the
  operation is in progress.  (Note that this will occur if the specified
  collection is this list, and it's nonempty.)
  
  <p>This implementation gets an iterator over the specified collection and
  a list iterator over this list pointing to the indexed element (with
  <tt>listIterator(index)</tt>).  Then, it iterates over the specified
  collection, inserting the elements obtained from the iterator into this
  list, one at a time, using <tt>ListIterator.add</tt> followed by
  <tt>ListIterator.next</tt> (to skip over the added element).
  
  <p>Note that this implementation will throw an
  <tt>UnsupportedOperationException</tt> if the list iterator returned by
  the <tt>listIterator</tt> method does not implement the <tt>add</tt>
  operation.
  
  @throws UnsupportedOperationException {@inheritDoc}
  @throws ClassCastException            {@inheritDoc}
  @throws NullPointerException          {@inheritDoc}
  @throws IllegalArgumentException      {@inheritDoc}
  @throws IndexOutOfBoundsException     {@inheritDoc}