การใช้ System.arraycopy (…) จะดีกว่าสำหรับลูปสำหรับคัดลอกอาร์เรย์หรือไม่

ฉันต้องการสร้างอาร์เรย์ของวัตถุใหม่โดยรวมอาร์เรย์ขนาดเล็กสองอาร์เรย์เข้าด้วยกัน

ไม่สามารถเป็นค่าว่างได้ แต่ขนาดอาจเป็น 0

ฉันไม่สามารถเลือกระหว่างสองวิธีนี้: พวกเขาเทียบเท่าหรือมีประสิทธิภาพมากกว่า (เช่น system.arraycopy () คัดลอกทั้งชิ้น)

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

หรือ

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]        
    }
}

ความแตกต่างเพียงอย่างเดียวคือรูปลักษณ์ของรหัสหรือไม่?

แก้ไข:ขอบคุณสำหรับคำถามที่เชื่อมโยง แต่ดูเหมือนว่าจะมีการอภิปรายที่ยังไม่ได้แก้ไข:

จะเร็วกว่าจริงไหมถ้าit is not for native types: byte [], Object [], char [] ในกรณีอื่น ๆ ทั้งหมดจะมีการดำเนินการตรวจสอบประเภทซึ่งจะเป็นกรณีของฉันและจะเทียบเท่า ... ไม่?

สำหรับคำถามที่เชื่อมโยงอื่น ๆ พวกเขากล่าวว่าthe size matters a lotสำหรับขนาด> 24 system.arraycopy () ชนะสำหรับขนาดเล็กกว่า 10 คู่มือสำหรับลูปจะดีกว่า ...

ตอนนี้ฉันสับสนจริงๆ

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

ฉันรู้ว่าการทดสอบ JUnit ไม่ใช่วิธีที่ดีที่สุดสำหรับการเปรียบเทียบ แต่
testHardCopyBytes ใช้เวลา 0.157 วินาทีในการทำให้เสร็จสมบูรณ์
และ
testArrayCopyBytes ใช้เวลา 0.086 วินาทีจึงจะเสร็จสมบูรณ์

ฉันคิดว่ามันขึ้นอยู่กับเครื่องเสมือน แต่ดูเหมือนว่ามันจะคัดลอกบล็อกของหน่วยความจำแทนที่จะคัดลอกองค์ประกอบอาร์เรย์เดี่ยว สิ่งนี้จะเพิ่มประสิทธิภาพอย่างแน่นอน

แก้ไข:
ดูเหมือนว่าประสิทธิภาพของ System.arraycopy จะครอบคลุมทั้งหมด เมื่อใช้สตริงแทนไบต์และอาร์เรย์มีขนาดเล็ก (ขนาด 10) ฉันจะได้ผลลัพธ์เหล่านี้:

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

นี่คือสิ่งที่ดูเหมือนว่าเมื่ออาร์เรย์มีขนาด 0x1000000 ดูเหมือนว่า System.arraycopy จะชนะด้วยอาร์เรย์ที่ใหญ่กว่า

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

แปลกมาก!

ขอขอบคุณ Daren ที่ชี้ให้เห็นว่าการอ้างอิงคัดลอกแตกต่างกัน มันทำให้ปัญหานี้น่าสนใจขึ้นมาก!

Arrays.copyOf(T[], int)อ่านง่ายกว่า Internaly ใช้System.arraycopy()ซึ่งเป็นการเรียกแบบเนทีฟ

เร็วกว่านี้ไม่ได้แล้ว!

ขึ้นอยู่กับเครื่องเสมือน แต่ System.arraycopy ควรให้คุณได้ใกล้เคียงที่สุดกับประสิทธิภาพดั้งเดิม

ฉันทำงานเป็นนักพัฒนา java สำหรับระบบฝังตัวมา 2 ปีแล้ว (ซึ่งประสิทธิภาพเป็นสิ่งสำคัญมาก) และทุกที่ที่สามารถใช้ System.arraycopy ได้ฉันมักจะใช้มัน / เห็นว่ามันใช้ในโค้ดที่มีอยู่ มักจะชอบมากกว่าการวนซ้ำเมื่อประสิทธิภาพเป็นปัญหา หากประสิทธิภาพไม่ใช่ปัญหาใหญ่ฉันจะดำเนินการต่อ อ่านง่ายกว่ามาก

แทนที่จะพึ่งพาการคาดเดาและข้อมูลที่อาจล้าสมัยฉันใช้เกณฑ์มาตรฐานบางอย่าง คาลิปเปอร์. ในความเป็นจริงคาลิปเปอร์มาพร้อมกับตัวอย่างบางส่วนรวมถึงCopyArrayBenchmarkที่วัดคำถามนี้! สิ่งที่คุณต้องทำคือวิ่ง

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

ผลลัพธ์ของฉันอิงตาม Java HotSpot (TM) 64-Bit Server VM ของ Oracle, 1.8.0_31-b13 ซึ่งทำงานบน MacBook Pro กลางปี ​​2010 (macOS 10.11.6 พร้อม Intel Arrandale i7, 8 GiB RAM) ฉันไม่เชื่อว่าการโพสต์ข้อมูลเวลาดิบจะมีประโยชน์ แต่ฉันจะสรุปข้อสรุปด้วยการแสดงภาพประกอบที่สนับสนุน

สรุป:

• การเขียนforลูปแบบแมนนวลเพื่อคัดลอกแต่ละองค์ประกอบลงในอาร์เรย์ที่สร้างอินสแตนซ์ใหม่จะไม่มีประโยชน์ไม่ว่าจะเป็นอาร์เรย์แบบสั้นหรืออาร์เรย์แบบยาว
• Arrays.copyOf(array, array.length)และarray.clone()ทั้งสองอย่างรวดเร็วอย่างต่อเนื่อง เทคนิคทั้งสองนี้มีประสิทธิภาพเกือบเหมือนกัน คุณจะเลือกอันไหนเป็นเรื่องของรสนิยม
• System.arraycopy(src, 0, dest, 0, src.length)เกือบจะเร็วพอ ๆ กับและแต่ก็ไม่ค่อยสม่ำเสมอนัก (ดูกรณี 50000 วินาที) ด้วยเหตุนี้และความฟุ่มเฟือยของการโทรฉันจึงขอแนะนำหากคุณต้องการการควบคุมที่ดีว่าองค์ประกอบใดถูกคัดลอกไปที่ไหนArrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

นี่คือแผนการกำหนดเวลา:

การเรียกใช้เมธอดดั้งเดิมเช่นArrays.copyOf(T[], int)จะมีค่าใช้จ่ายบางส่วน แต่ก็ไม่ได้หมายความว่าจะไม่เร็วเท่าที่คุณกำลังดำเนินการโดยใช้ JNI

วิธีที่ง่ายที่สุดคือเขียนเกณฑ์มาตรฐานและทดสอบ

คุณสามารถตรวจสอบว่าArrays.copyOf(T[], int)เร็วกว่าforลูปปกติของคุณ

รหัสมาตรฐานจากที่นี่ : -

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()ใช้ JNI (Java Native Interface) เพื่อคัดลอกอาร์เรย์ (หรือบางส่วน) ดังนั้นจึงรวดเร็วอย่างเห็นได้ชัดดังที่คุณสามารถยืนยันได้ ที่นี่

เป็นไปไม่ได้ที่Arrays.copyOfจะเร็วกว่าSystem.arraycopyนี้เนื่องจากเป็นการใช้งาน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;
}

System.arraycopy()เป็นการเรียกแบบเนทีฟซึ่งคัดลอกการทำงานโดยตรงที่หน่วยความจำ สำเนาหน่วยความจำเดียวจะเร็วกว่าการวนซ้ำของคุณเสมอ