Sử dụng System.arraycopy (…) có tốt hơn vòng lặp for để sao chép mảng không?

Question 1

Tôi muốn tạo một mảng đối tượng mới kết hợp hai mảng nhỏ hơn.

Chúng không được rỗng, nhưng kích thước có thể bằng 0.

Tôi không thể chọn giữa hai cách này: chúng tương đương hay một cách hiệu quả hơn (ví dụ: system.arraycopy () sao chép toàn bộ khối)?

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
System.arraycopy(publicThings, 0, things, 0, publicThings.length);
System.arraycopy(privateThings, 0, things,  publicThings.length, privateThings.length);

hoặc là

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
for (int i = 0; i < things.length; i++) {
    if (i<publicThings.length){
        things[i] = publicThings[i]
    } else {
        things[i] = privateThings[i-publicThings.length]        
    }
}

Sự khác biệt duy nhất là giao diện của mã?

CHỈNH SỬA: cảm ơn vì câu hỏi được liên kết, nhưng dường như họ vẫn còn một cuộc thảo luận chưa được giải quyết:

Nó có thực sự nhanh hơn không nếu it is not for native types: byte [], Object [], char []? trong tất cả các trường hợp khác, kiểm tra kiểu được thực hiện, đó sẽ là trường hợp của tôi và như vậy sẽ tương đương ... không?

Trên một câu hỏi được liên kết khác, họ nói rằng the size matters a lot, đối với kích thước> 24 system.arraycopy () thắng, đối với nhỏ hơn 10, vòng lặp hướng dẫn sử dụng sẽ tốt hơn ...

Giờ tôi thực sự bối rối.

Question 2

public void testHardCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    for(int i = 0; i < out.length; i++)
    {
        out[i] = bytes[i];
    }
}

public void testArrayCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    System.arraycopy(bytes, 0, out, 0, out.length);
}

Tôi biết các bài kiểm tra JUnit không thực sự là tốt nhất để đo điểm chuẩn, nhưng
testHardCopyBytes mất 0,157 giây để hoàn thành
và
testArrayCopyBytes mất 0,086 giây để hoàn thành.

Tôi nghĩ rằng nó phụ thuộc vào máy ảo, nhưng có vẻ như nó sao chép các khối bộ nhớ thay vì sao chép các phần tử mảng đơn lẻ. Điều này hoàn toàn sẽ làm tăng hiệu suất.

CHỈNH SỬA:
Có vẻ như hiệu suất của System.arraycopy đang ở khắp nơi. Khi Chuỗi được sử dụng thay vì byte và các mảng nhỏ (kích thước 10), tôi nhận được các kết quả sau:

    String HC:  60306 ns
    String AC:  4812 ns
    byte HC:    4490 ns
    byte AC:    9945 ns

Đây là giao diện của nó khi mảng có kích thước 0x1000000. Có vẻ như System.arraycopy chắc chắn thắng với các mảng lớn hơn.

    Strs HC:  51730575 ns
    Strs AC:  24033154 ns
    Bytes HC: 28521827 ns
    Bytes AC: 5264961 ns

Thật kỳ lạ!

Cảm ơn, Daren, đã chỉ ra rằng các tham chiếu sao chép khác nhau. Nó làm cho vấn đề này trở nên thú vị hơn nhiều!

Question 3

Arrays.copyOf(T[], int)dễ đọc hơn. Internaly mà nó sử dụng System.arraycopy()là một cuộc gọi riêng.

Bạn không thể lấy nó nhanh hơn!

Question 4

Nó phụ thuộc vào máy ảo, nhưng System.arraycopy sẽ cung cấp cho bạn hiệu suất gốc gần nhất mà bạn có thể.

Tôi đã làm việc 2 năm với tư cách là nhà phát triển java cho các hệ thống nhúng (nơi hiệu suất là ưu tiên lớn) và ở mọi nơi có thể sử dụng System.arraycopy, tôi hầu như đã sử dụng nó / thấy nó được sử dụng trong mã hiện có. Nó luôn được ưu tiên hơn các vòng lặp khi hiệu suất là một vấn đề. Tuy nhiên, nếu hiệu suất không phải là một vấn đề lớn, tôi sẽ đi với vòng lặp. Dễ đọc hơn nhiều.

Question 5

Thay vì dựa vào suy đoán và thông tin có thể đã lỗi thời, tôi đã chạy một số điểm chuẩn bằng cách sử dụng thước cặp. Trên thực tế, Calibre đi kèm với một số ví dụ, bao gồm một ví dụ CopyArrayBenchmarkđo chính xác câu hỏi này! Tất cả những gì bạn phải làm là chạy

mvn exec:java -Dexec.mainClass=com.google.caliper.runner.CaliperMain -Dexec.args=examples.CopyArrayBenchmark

Kết quả của tôi dựa trên máy chủ ảo Java HotSpot (TM) 64-Bit của Oracle, 1.8.0_31-b13, chạy trên MacBook Pro giữa năm 2010 (macOS 10.11.6 với Intel Arrandale i7, RAM 8 GiB). Tôi không tin rằng việc đăng dữ liệu thời gian thô sẽ hữu ích. Thay vào đó, tôi sẽ tóm tắt các kết luận với các hình ảnh hỗ trợ.

Tóm tắt:

Viết một forvòng lặp thủ công để sao chép từng phần tử vào một mảng mới được khởi tạo không bao giờ có lợi, cho dù đối với mảng ngắn hay mảng dài.
Arrays.copyOf(array, array.length)và array.clone()cả hai đều nhanh chóng. Hai kỹ thuật này gần giống nhau về hiệu suất; cái nào bạn chọn là một vấn đề của hương vị.
System.arraycopy(src, 0, dest, 0, src.length)gần như nhanh bằng và , nhưng không hoàn toàn nhất quán như vậy. (Xem trường hợp trong 50000 s.) Do đó, và tính chi tiết của cuộc gọi, tôi khuyên bạn nên nếu bạn cần kiểm soát tốt các phần tử được sao chép ở đâu.Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

Đây là các âm mưu thời gian:

Question 6

Việc thực thi các phương thức gốc giống như Arrays.copyOf(T[], int)có một số chi phí nhưng không có nghĩa là nó không nhanh vì bạn đang thực thi nó bằng JNI.

Cách đơn giản nhất là viết điểm chuẩn và bài kiểm tra.

Bạn có thể kiểm tra xem nó Arrays.copyOf(T[], int)nhanh hơn forvòng lặp bình thường của bạn .

Mã điểm chuẩn từ đây : -

public void test(int copySize, int copyCount, int testRep) {
    System.out.println("Copy size = " + copySize);
    System.out.println("Copy count = " + copyCount);
    System.out.println();
    for (int i = testRep; i > 0; --i) {
        copy(copySize, copyCount);
        loop(copySize, copyCount);
    }
    System.out.println();
}

public void copy(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        System.arraycopy(src, 1, dst, 0, copySize);
        dst[copySize] = src[copySize] + 1;
        System.arraycopy(dst, 0, src, 0, copySize);
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Arraycopy: " + (end - begin) / 1e9 + " s");
}

public void loop(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        for (int i = copySize - 1; i >= 0; --i) {
            dst[i] = src[i + 1];
        }
        dst[copySize] = src[copySize] + 1;
        for (int i = copySize - 1; i >= 0; --i) {
            src[i] = dst[i];
        }
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Man. loop: " + (end - begin) / 1e9 + " s");
}

public int[] newSrc(int arraySize) {
    int[] src = new int[arraySize];
    for (int i = arraySize - 1; i >= 0; --i) {
        src[i] = i;
    }
    return src;
}

System.arraycopy()sử dụng JNI (Java Native Interface) để sao chép một mảng (hoặc các phần của nó), vì vậy nó rất nhanh, như bạn có thể xác nhận tại đây

Question 7

Không thể Arrays.copyOfnhanh hơn System.arraycopyvì đây là việc triển khai copyOf:

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

Question 8

System.arraycopy()là một cuộc gọi riêng thực hiện thao tác sao chép trực tiếp tại bộ nhớ. Bản sao bộ nhớ đơn sẽ luôn nhanh hơn vòng lặp for của bạn