Mảng bất biến trong Java

Có một sự thay thế bất biến cho các mảng nguyên thủy trong Java không? Tạo một mảng nguyên thủy finalkhông thực sự ngăn người ta làm điều gì đó như

final int[] array = new int[] {0, 1, 2, 3};
array[0] = 42;

Tôi muốn các yếu tố của mảng là không thể thay đổi.

Không phải với mảng nguyên thủy. Bạn sẽ cần sử dụng Danh sách hoặc một số cấu trúc dữ liệu khác:

List<Integer> items = Collections.unmodifiableList(Arrays.asList(0,1,2,3));

Đề nghị của tôi là không sử dụng một mảng hoặc một unmodifiableListmà sử dụng ImmutableList của Guava , tồn tại cho mục đích này.

ImmutableList<Integer> values = ImmutableList.of(0, 1, 2, 3);

Như những người khác đã lưu ý, bạn không thể có các mảng bất biến trong Java.

Nếu bạn thực sự cần một phương thức trả về một mảng không ảnh hưởng đến mảng ban đầu, thì bạn cần sao chép mảng mỗi lần:

public int[] getFooArray() {
  return fooArray == null ? null : fooArray.clone();
}

Rõ ràng điều này khá tốn kém (vì bạn sẽ tạo một bản sao đầy đủ mỗi khi bạn gọi getter), nhưng nếu bạn không thể thay đổi giao diện ( Liství dụ sử dụng ) và không thể mạo hiểm cho khách hàng thay đổi nội bộ của bạn, thì nó có thể là cần thiết

Kỹ thuật này được gọi là tạo một bản sao phòng thủ.

Có một cách để tạo một mảng bất biến trong Java:

final String[] IMMUTABLE = new String[0];

Mảng có 0 phần tử (rõ ràng) không thể bị đột biến.

Điều này thực sự có thể có ích nếu bạn đang sử dụng List.toArrayphương thức để chuyển đổi một Listmảng. Vì ngay cả một mảng trống cũng chiếm một số bộ nhớ, bạn có thể lưu phân bổ bộ nhớ đó bằng cách tạo một mảng trống không đổi và luôn truyền nó cho toArrayphương thức. Phương thức đó sẽ phân bổ một mảng mới nếu mảng bạn vượt qua không đủ dung lượng, nhưng nếu có (danh sách trống), nó sẽ trả về mảng bạn đã truyền, cho phép bạn sử dụng lại mảng đó bất cứ khi nào bạn gọi toArrayvào trống rỗng List.

final static String[] EMPTY_STRING_ARRAY = new String[0];

List<String> emptyList = new ArrayList<String>();
return emptyList.toArray(EMPTY_STRING_ARRAY); // returns EMPTY_STRING_ARRAY

Một câu trả lời khác

static class ImmutableArray<T> {
    private final T[] array;

    private ImmutableArray(T[] a){
        array = Arrays.copyOf(a, a.length);
    }

    public static <T> ImmutableArray<T> from(T[] a){
        return new ImmutableArray<T>(a);
    }

    public T get(int index){
        return array[index];
    }
}

{
    final ImmutableArray<String> sample = ImmutableArray.from(new String[]{"a", "b", "c"});
}

Kể từ Java 9, bạn có thể sử dụng List.of(...), JavaDoc .

Phương pháp này trả về một bất biến Listvà rất hiệu quả.

Nếu bạn cần (vì lý do hiệu suất hoặc để tiết kiệm bộ nhớ) bản địa 'int' thay vì 'java.lang.Integer', thì có lẽ bạn sẽ cần phải viết lớp trình bao bọc của riêng mình. Có nhiều cách triển khai IntArray khác nhau trên mạng, nhưng không có (tôi tìm thấy) là bất biến: Koders IntArray , Lucene IntArray . Có lẽ có những người khác.

Kể từ Guava 22, từ gói com.google.common.primitivesbạn có thể sử dụng ba lớp mới, có dung lượng bộ nhớ thấp hơn so với ImmutableList.

• Bất biếnIntArray
• Bất biếnLongArray
• Bất biếnDoubleArray

Họ cũng có một người xây dựng. Thí dụ:

int size = 2;
ImmutableLongArray longArray = ImmutableLongArray.builder(size)
  .add(1L)
  .add(2L)
  .build();

hoặc, nếu kích thước được biết tại thời gian biên dịch:

ImmutableLongArray longArray = ImmutableLongArray.of(1L, 2L);

Đây là một cách khác để có được một khung nhìn bất biến của một mảng cho các nguyên hàm Java.

Không, điều này là không thể. Tuy nhiên, người ta có thể làm một cái gì đó như thế này:

List<Integer> temp = new ArrayList<Integer>();
temp.add(Integer.valueOf(0));
temp.add(Integer.valueOf(2));
temp.add(Integer.valueOf(3));
temp.add(Integer.valueOf(4));
List<Integer> immutable = Collections.unmodifiableList(temp);

Điều này đòi hỏi phải sử dụng các hàm bao, và là một Danh sách, không phải là một mảng, nhưng là gần nhất bạn sẽ nhận được.

Trong một số trường hợp, sẽ sử dụng phương pháp tĩnh này từ thư viện Google Guava: List<Integer> Ints.asList(int... backingArray)

Ví dụ:

• List<Integer> x1 = Ints.asList(0, 1, 2, 3)
• List<Integer> x1 = Ints.asList(new int[] { 0, 1, 2, 3})

Nếu bạn muốn tránh cả khả năng biến đổi và quyền anh, không có cách nào thoát khỏi hộp. Nhưng bạn có thể tạo một lớp chứa mảng nguyên thủy bên trong và cung cấp quyền truy cập chỉ đọc vào các phần tử thông qua (các) phương thức.

Phương thức (E ... phần tử) trong Java9 có thể được sử dụng để tạo danh sách bất biến chỉ bằng một dòng:

List<Integer> items = List.of(1,2,3,4,5);

Phương thức trên trả về một danh sách bất biến chứa một số phần tử tùy ý. Và thêm bất kỳ số nguyên nào vào danh sách này sẽ dẫn đến java.lang.UnsupportedOperationExceptionngoại lệ. Phương thức này cũng chấp nhận một mảng duy nhất làm đối số.

String[] array = ... ;
List<String[]> list = List.<String[]>of(array);

Mặc dù đúng là như vậy Collections.unmodifiableList(), đôi khi bạn có thể có một thư viện lớn có các phương thức đã được xác định để trả về mảng (ví dụ String[]). Để tránh phá vỡ chúng, bạn thực sự có thể xác định các mảng phụ sẽ lưu trữ các giá trị:

public class Test {
    private final String[] original;
    private final String[] auxiliary;
    /** constructor */
    public Test(String[] _values) {
        original = new String[_values.length];
        // Pre-allocated array.
        auxiliary = new String[_values.length];
        System.arraycopy(_values, 0, original, 0, _values.length);
    }
    /** Get array values. */
    public String[] getValues() {
        // No need to call clone() - we pre-allocated auxiliary.
        System.arraycopy(original, 0, auxiliary, 0, original.length);
        return auxiliary;
    }
}

Để kiểm tra:

    Test test = new Test(new String[]{"a", "b", "C"});
    System.out.println(Arrays.asList(test.getValues()));
    String[] values = test.getValues();
    values[0] = "foobar";
    // At this point, "foobar" exist in "auxiliary" but since we are 
    // copying "original" to "auxiliary" for each call, the next line
    // will print the original values "a", "b", "c".
    System.out.println(Arrays.asList(test.getValues()));

Không hoàn hảo, nhưng ít nhất bạn có "mảng giả bất biến" (theo quan điểm của lớp) và điều này sẽ không phá vỡ mã liên quan.

Chà .. mảng rất hữu ích để vượt qua như hằng số (nếu có) như các tham số biến thể.