Java ArrayList.add 的实现方法

/**

  * 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);

}