/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */public boolean add(E e) {  ensureCapacityInternal(size + 1); // Increments modCount!!  elementData[size++] = e;  return true;}

/** * Inserts the specified element at the specified position in this * list. Shifts the element currently at that position (if any) and * any subsequent elements to the right (adds one to their indices). * * @param index index at which the specified element is to be inserted * @param element element to be inserted * @throws IndexOutOfBoundsException {@inheritDoc} */public void add(int index, E element) {  rangeCheckForAdd(index);  ensureCapacityInternal(size + 1); // Increments modCount!!  System.arraycopy(elementData, index, elementData, index + 1,           size - index);  elementData[index] = element;  size++;}

void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,                int dst_pos, int length, TRAPS) { assert(s->is_objArray(), "must be obj array"); if (!d->is_objArray()) {  THROW(vmSymbols::java_lang_ArrayStoreException()); } // Check is all offsets and lengths are non negative if (src_pos < 0 || dst_pos < 0 || length < 0) {  THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); } // Check if the ranges are valid if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())   || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {  THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); } // Special case. Boundary cases must be checked first // This allows the following call: copy_array(s, s.length(), d.length(), 0). // This is correct, since the position is supposed to be an 'in between point', i.e., s.length(), // points to the right of the last element. if (length==0) {  return; } if (UseCompressedOops) {  narrowOop* const src = objArrayOop(s)->obj_at_addr<narrowOop>(src_pos);  narrowOop* const dst = objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos);  do_copy<narrowOop>(s, src, d, dst, length, CHECK); } else {  oop* const src = objArrayOop(s)->obj_at_addr<oop>(src_pos);  oop* const dst = objArrayOop(d)->obj_at_addr<oop>(dst_pos);  do_copy<oop> (s, src, d, dst, length, CHECK); }}

// Either oop or narrowOop depending on UseCompressedOops.template <class T> void ObjArrayKlass::do_copy(arrayOop s, T* src,                arrayOop d, T* dst, int length, TRAPS) { BarrierSet* bs = Universe::heap()->barrier_set(); // For performance reasons, we assume we are that the write barrier we // are using has optimized modes for arrays of references. At least one // of the asserts below will fail if this is not the case. assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); assert(bs->has_write_ref_array_pre_opt(), "For pre-barrier as well."); if (s == d) {  // since source and destination are equal we do not need conversion checks.  assert(length > 0, "sanity check");  bs->write_ref_array_pre(dst, length);  Copy::conjoint_oops_atomic(src, dst, length); } else {  // We have to make sure all elements conform to the destination array  Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass();  Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass();  if (stype == bound || stype->is_subtype_of(bound)) {   // elements are guaranteed to be subtypes, so no check necessary   bs->write_ref_array_pre(dst, length);   Copy::conjoint_oops_atomic(src, dst, length);  } else {   // slow case: need individual subtype checks   // note: don't use obj_at_put below because it includes a redundant store check   T* from = src;   T* end = from + length;   for (T* p = dst; from < end; from++, p++) {    // XXX this is going to be slow.    T element = *from;    // even slower now    bool element_is_null = oopDesc::is_null(element);    oop new_val = element_is_null ? oop(NULL)                   : oopDesc::decode_heap_oop_not_null(element);    if (element_is_null ||      (new_val->klass())->is_subtype_of(bound)) {     bs->write_ref_field_pre(p, new_val);     *p = element;    } else {     // We must do a barrier to cover the partial copy.     const size_t pd = pointer_delta(p, dst, (size_t)heapOopSize);     // pointer delta is scaled to number of elements (length field in     // objArrayOop) which we assume is 32 bit.     assert(pd == (size_t)(int)pd, "length field overflow");     bs->write_ref_array((HeapWord*)dst, pd);     THROW(vmSymbols::java_lang_ArrayStoreException());     return;    }   }  } } bs->write_ref_array((HeapWord*)dst, length);}

/** * Increases the capacity to ensure that it can hold at least the * number of elements specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity */private void grow(int minCapacity) {  // overflow-conscious code  int oldCapacity = elementData.length;  int newCapacity = oldCapacity + (oldCapacity >> 1);  if (newCapacity - minCapacity < 0)    newCapacity = minCapacity;  if (newCapacity - MAX_ARRAY_SIZE > 0)    newCapacity = hugeCapacity(minCapacity);  // minCapacity is usually close to size, so this is a win:  elementData = Arrays.copyOf(elementData, newCapacity);}