Zeit, die Komplexität des Systems.arraycopy(...)?

Ich habe einige der Untersuchung, und später beschlossen, einen test schreiben, code, hier ist was ich habe.

Mein Test-code ist unten angegeben:

import org.junit.Test;

public class ArrayCopyTest {

  @Test
  public void testCopy() {
    for (int count = 0; count < 3; count++) {
      int size = 0x00ffffff;
      long start, end;
      Integer[] integers = new Integer[size];
      Integer[] loopCopy = new Integer[size];
      Integer[] systemCopy = new Integer[size];

      for (int i = 0; i < size; i++) {
        integers[i] = i;
      }

      start = System.currentTimeMillis();
      for (int i = 0; i < size; i++) {
        loopCopy[i] = integers[i];
      }
      end = System.currentTimeMillis();
      System.out.println("for loop: " + (end - start));

      start = System.currentTimeMillis();
      System.arraycopy(integers, 0, systemCopy, 0, size);
      end = System.currentTimeMillis();
      System.out.println("System.arrayCopy: " + (end - start));
    }
  }

}

Es erzeugt das Ergebnis unten gezeigt

for loop: 47
System.arrayCopy: 24

for loop: 31
System.arrayCopy: 22

for loop: 36
System.arrayCopy: 22

So, Bragboy korrekt ist.

Hier einige relevante Quellcode von OpenJDK 8 (openjdk-8-src-b132-03_mar_2014). Ich fand es mit Hilfe von Java-native-Methode source code (Hinweis: die Anweisungen sind verwirrend; ich suchte die Quelle für die relevanten IDS). Ich denke, Kapitän Ford Kommentar korrekt ist; d.h., es gibt (viele) Fälle, in denen die Iteration jedes element ist nicht nötig. Beachten Sie, dass nicht der Iteration jedes element nicht unbedingt bedeutet O(1), es bedeutet einfach nur "schneller". Ich denke, dass Sie unabhängig ist, wird ein array kopieren muss grundsätzlich O(x), auch wenn x nicht die Anzahl der Elemente im array zu verwenden; d.h., Sie jedoch tun es, das kopieren wird teurer mit mehr Elementen in dem array, und wenn Sie eine Sehr Große Auswahl, es wird ein Linear Lange Zeit. Nachteil: ich weiß nicht für bestimmte, dass dies der eigentliche source-code für die Java ausgeführt werden; nur, dass dies die nur Umsetzung die ich finden konnte, in die OpenJDK-8-Quelle. Ich denke, dass dies ist ein cross-Plattform-Implementierung, aber ich könnte falsch sein-ich definitiv noch nicht herausgefunden, wie um diesen code zu erstellen. Siehe auch: Unterschiede zwischen Oracle JDK und Open JDK. Das folgende stammt aus: /openjdk/hotspot/src/share/vm/oops/objArrayKlass.cpp

//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 = *from;
        } 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);
}