.toArray (new MyClass [0]) hoặc .toArray (new MyClass [myList.size ()])?

Giả sử tôi có một ArrayList

ArrayList<MyClass> myList;

Và tôi muốn gọi tớiArray, có lý do hiệu suất để sử dụng

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

kết thúc

MyClass[] arr = myList.toArray(new MyClass[0]);

?

Tôi thích kiểu thứ hai, vì nó ít dài dòng hơn và tôi cho rằng trình biên dịch sẽ đảm bảo mảng trống không thực sự được tạo, nhưng tôi đã tự hỏi liệu điều đó có đúng không.

Tất nhiên, trong 99% trường hợp, nó không tạo ra sự khác biệt theo cách này hay cách khác, nhưng tôi muốn giữ một phong cách nhất quán giữa mã thông thường của tôi và các vòng lặp bên trong được tối ưu hóa của tôi ...

Ngược lại, phiên bản nhanh nhất, trên Hotspot 8, là:

MyClass[] arr = myList.toArray(new MyClass[0]);

Tôi đã chạy một điểm chuẩn vi mô bằng cách sử dụng jmh các kết quả và mã bên dưới, cho thấy phiên bản có mảng trống luôn vượt trội so với phiên bản có mảng được chỉ định. Lưu ý rằng nếu bạn có thể sử dụng lại một mảng hiện có kích thước chính xác, kết quả có thể khác.

Kết quả điểm chuẩn (điểm tính bằng micrô giây, nhỏ hơn = tốt hơn):

Benchmark                      (n)  Mode  Samples    Score   Error  Units
c.a.p.SO29378922.preSize         1  avgt       30    0.025 ▒ 0.001  us/op
c.a.p.SO29378922.preSize       100  avgt       30    0.155 ▒ 0.004  us/op
c.a.p.SO29378922.preSize      1000  avgt       30    1.512 ▒ 0.031  us/op
c.a.p.SO29378922.preSize      5000  avgt       30    6.884 ▒ 0.130  us/op
c.a.p.SO29378922.preSize     10000  avgt       30   13.147 ▒ 0.199  us/op
c.a.p.SO29378922.preSize    100000  avgt       30  159.977 ▒ 5.292  us/op
c.a.p.SO29378922.resize          1  avgt       30    0.019 ▒ 0.000  us/op
c.a.p.SO29378922.resize        100  avgt       30    0.133 ▒ 0.003  us/op
c.a.p.SO29378922.resize       1000  avgt       30    1.075 ▒ 0.022  us/op
c.a.p.SO29378922.resize       5000  avgt       30    5.318 ▒ 0.121  us/op
c.a.p.SO29378922.resize      10000  avgt       30   10.652 ▒ 0.227  us/op
c.a.p.SO29378922.resize     100000  avgt       30  139.692 ▒ 8.957  us/op

Để tham khảo, mã:

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
public class SO29378922 {
  @Param({"1", "100", "1000", "5000", "10000", "100000"}) int n;
  private final List<Integer> list = new ArrayList<>();
  @Setup public void populateList() {
    for (int i = 0; i < n; i++) list.add(0);
  }
  @Benchmark public Integer[] preSize() {
    return list.toArray(new Integer[n]);
  }
  @Benchmark public Integer[] resize() {
    return list.toArray(new Integer[0]);
  }
}

Bạn có thể tìm thấy kết quả tương tự, phân tích đầy đủ và thảo luận trong bài đăng trên blog Mảng về trí tuệ của người xưa . Tóm lại: trình biên dịch JVM và JIT chứa một số tối ưu hóa cho phép nó tạo và khởi tạo một mảng có kích thước chính xác mới và không thể sử dụng các tối ưu hóa đó nếu bạn tự tạo mảng.

Kể từ ArrayList trong Java 5 , mảng sẽ được điền nếu nó có kích thước phù hợp (hoặc lớn hơn). hậu quả là

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

sẽ tạo một đối tượng mảng, điền vào nó và trả về "mảng". Mặt khác

MyClass[] arr = myList.toArray(new MyClass[0]);

sẽ tạo ra hai mảng. Cái thứ hai là một mảng MyClass có chiều dài 0. Vì vậy, có một tạo đối tượng cho một đối tượng sẽ bị ném đi ngay lập tức. Theo như mã nguồn cho thấy trình biên dịch / JIT không thể tối ưu hóa cái này để nó không được tạo. Ngoài ra, sử dụng đối tượng có độ dài bằng không dẫn đến việc truyền (s) trong phương thức toArray () -.

Xem nguồn của ArrayList.toArray ():

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Sử dụng phương pháp đầu tiên để chỉ có một đối tượng được tạo và tránh các vật đúc (ngầm nhưng vẫn đắt tiền).

Từ JetBrains Intellij Idea kiểm tra:

Có hai kiểu để chuyển đổi một bộ sưu tập thành một mảng: sử dụng một mảng có kích thước sẵn (như c.toArray (Chuỗi mới [c.size ()]) ) hoặc sử dụng một mảng trống (như c.toArray (Chuỗi mới [ 0]) .

Trong các phiên bản Java cũ hơn sử dụng mảng có kích thước trước được khuyến nghị, vì lệnh gọi phản chiếu cần thiết để tạo một mảng có kích thước phù hợp khá chậm. Tuy nhiên, do các bản cập nhật muộn của OpenJDK 6, cuộc gọi này đã được thực hiện, làm cho hiệu suất của phiên bản mảng trống giống nhau và đôi khi còn tốt hơn so với phiên bản có kích thước trước. Ngoài ra, việc truyền mảng có kích thước trước rất nguy hiểm cho bộ sưu tập đồng thời hoặc đồng bộ vì cuộc đua dữ liệu có thể xảy ra giữa cuộc gọi kích thước và cuộc gọi toArray có thể dẫn đến vô hiệu hóa thêm ở cuối mảng, nếu bộ sưu tập bị thu hẹp đồng thời trong quá trình hoạt động.

Việc kiểm tra này cho phép tuân theo kiểu thống nhất: sử dụng một mảng trống (được khuyến nghị trong Java hiện đại) hoặc sử dụng một mảng có kích thước sẵn (có thể nhanh hơn trong các phiên bản Java cũ hơn hoặc các JVM không dựa trên HotSpot).

Các JVM hiện đại tối ưu hóa việc xây dựng mảng phản chiếu trong trường hợp này, do đó sự khác biệt về hiệu năng là rất nhỏ. Đặt tên cho bộ sưu tập hai lần trong mã soạn sẵn như vậy không phải là một ý tưởng hay, vì vậy tôi nên tránh phương pháp đầu tiên. Một ưu điểm khác của thứ hai là nó hoạt động với các bộ sưu tập đồng bộ và đồng thời. Nếu bạn muốn thực hiện tối ưu hóa, hãy sử dụng lại mảng trống (mảng trống là bất biến và có thể được chia sẻ) hoặc sử dụng trình lược tả (!).

toArray kiểm tra rằng mảng được truyền có kích thước phù hợp (nghĩa là đủ lớn để phù hợp với các yếu tố trong danh sách của bạn) và nếu vậy, sử dụng nó. Do đó, nếu kích thước của mảng cung cấp nhỏ hơn yêu cầu, một mảng mới sẽ được tạo theo phản xạ.

Trong trường hợp của bạn, một mảng có kích thước bằng 0, là bất biến, do đó có thể được nâng lên một biến cuối cùng một cách an toàn, điều này có thể làm cho mã của bạn sạch hơn một chút, tránh tạo ra mảng trên mỗi lệnh gọi. Một mảng mới sẽ được tạo bên trong phương thức, vì vậy đó là một tối ưu hóa dễ đọc.

Có thể cho rằng phiên bản nhanh hơn là vượt qua mảng có kích thước chính xác, nhưng trừ khi bạn có thể chứng minh mã này là nút cổ chai hiệu năng, hãy ưu tiên khả năng đọc cho hiệu năng thời gian chạy cho đến khi được chứng minh khác đi.

Trường hợp đầu tiên là hiệu quả hơn.

Đó là bởi vì trong trường hợp thứ hai:

MyClass[] arr = myList.toArray(new MyClass[0]);

thời gian chạy thực sự tạo ra một mảng trống (với kích thước bằng 0) và sau đó bên trong phương thức toArray tạo ra một mảng khác để phù hợp với dữ liệu thực tế. Việc tạo này được thực hiện bằng cách sử dụng sự phản chiếu bằng mã sau đây (lấy từ jdk1.5.0_10):

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.
    newInstance(a.getClass().getComponentType(), size);
System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Bằng cách sử dụng biểu mẫu đầu tiên, bạn tránh được việc tạo mảng thứ hai và cũng tránh được mã phản chiếu.

Cái thứ hai không thể đọc được, nhưng có rất ít cải tiến đến mức không đáng. Phương pháp đầu tiên nhanh hơn, không có nhược điểm khi chạy, vì vậy đó là những gì tôi sử dụng. Nhưng tôi viết nó theo cách thứ hai, bởi vì nó nhanh hơn để gõ. Sau đó, IDE của tôi đánh dấu nó như một cảnh báo và đề nghị sửa nó. Với một lần nhấn phím, nó chuyển đổi mã từ loại thứ hai sang loại thứ nhất.

Sử dụng 'toArray' với mảng có kích thước chính xác sẽ hoạt động tốt hơn vì thay thế sẽ tạo ra mảng có kích thước bằng 0 sau đó là mảng có kích thước chính xác. Tuy nhiên, như bạn nói sự khác biệt có thể là không đáng kể.

Ngoài ra, lưu ý rằng trình biên dịch javac không thực hiện bất kỳ tối ưu hóa nào. Ngày nay, tất cả các tối ưu hóa được thực hiện bởi trình biên dịch JIT / HotSpot khi chạy. Tôi không biết về bất kỳ tối ưu hóa nào xung quanh 'toArray' trong bất kỳ JVM nào.

Sau đó, câu trả lời cho câu hỏi của bạn chủ yếu là vấn đề về phong cách nhưng vì tính nhất quán nên tạo thành một phần của bất kỳ tiêu chuẩn mã hóa nào bạn tuân thủ (cho dù là tài liệu hay cách khác).

mã mẫu cho số nguyên:

Integer[] arr = myList.toArray(new integer[0]);