Array yang tidak dapat diubah di Jawa

Apakah ada alternatif abadi untuk array primitif di Jawa? Membuat array primitif finalsebenarnya tidak mencegah seseorang melakukan sesuatu seperti

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

Saya ingin elemen array tidak dapat diubah.

Tidak dengan array primitif. Anda harus menggunakan Daftar atau struktur data lain:

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

Rekomendasi saya adalah untuk tidak menggunakan array atau unmodifiableListtetapi untuk menggunakan Guava 's ImmutableList , yang ada untuk tujuan ini.

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

Seperti yang telah dicatat orang lain, Anda tidak dapat memiliki array yang tidak dapat diubah di Jawa.

Jika Anda benar-benar membutuhkan metode yang mengembalikan array yang tidak mempengaruhi array asli, maka Anda harus mengkloning array setiap kali:

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

Jelas ini agak mahal (karena Anda akan membuat salinan lengkap setiap kali Anda memanggil getter), tetapi jika Anda tidak dapat mengubah antarmuka (untuk menggunakan List misalnya) dan tidak dapat mengambil risiko klien mengubah internal Anda, maka mungkin perlu.

Teknik ini disebut membuat salinan defensif.

Ada satu cara untuk membuat array yang tidak dapat diubah di Jawa:

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

Array dengan 0 elemen (jelas) tidak dapat dimutasi.

Ini sebenarnya bisa berguna jika Anda menggunakan List.toArraymetode untuk mengonversi Listsebuah array. Karena bahkan array kosong membutuhkan beberapa memori, Anda dapat menyimpan alokasi memori itu dengan membuat array kosong konstan, dan selalu meneruskannya ke toArraymetode. Metode itu akan mengalokasikan array baru jika array yang Anda lewati tidak memiliki cukup ruang, tetapi jika itu (daftar itu kosong), itu akan mengembalikan array yang Anda lewati, memungkinkan Anda untuk menggunakan kembali array itu setiap kali Anda memanggil toArraysebuah mengosongkan 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

Satu lagi jawaban

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

Pada Java 9 Anda dapat menggunakan List.of(...), JavaDoc .

Metode ini mengembalikan kekal Listdan sangat efisien.

Jika Anda perlu (karena alasan kinerja atau untuk menghemat memori) asli 'int' bukan 'java.lang.Integer', maka Anda mungkin perlu menulis kelas pembungkus Anda sendiri. Ada berbagai implementasi IntArray di internet, tetapi tidak ada (saya menemukan) tidak berubah: Koders IntArray , Lucene IntArray . Mungkin ada yang lain.

Sejak Guava 22, dari paket com.google.common.primitivesAnda dapat menggunakan tiga kelas baru, yang memiliki jejak memori lebih rendah dibandingkan dengan ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

Mereka juga memiliki pembangun. Contoh:

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

atau, jika ukurannya diketahui pada waktu kompilasi:

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

Ini adalah cara lain untuk mendapatkan tampilan array yang tidak berubah dari Java primitif.

Tidak, ini tidak mungkin. Namun, orang dapat melakukan sesuatu seperti ini:

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

Ini membutuhkan menggunakan pembungkus, dan merupakan Daftar, bukan array, tetapi yang terdekat Anda akan dapatkan.

Dalam beberapa situasi, akan lebih ringan untuk menggunakan metode statis ini dari perpustakaan Google Guava: List<Integer> Ints.asList(int... backingArray)

Contoh:

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

Jika Anda ingin menghindari sifat berubah-ubah dan tinju, tidak ada jalan keluar dari kotak. Tapi Anda bisa membuat kelas yang menyimpan larik primitif di dalamnya dan menyediakan akses hanya baca ke elemen melalui metode.

Metode (elemen ... elemen) di Java9 dapat digunakan untuk membuat daftar tetap menggunakan hanya satu baris:

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

Metode di atas mengembalikan daftar yang tidak berubah yang mengandung sejumlah elemen yang berubah-ubah. Dan menambahkan bilangan bulat ke daftar ini akan menghasilkan java.lang.UnsupportedOperationExceptionpengecualian. Metode ini juga menerima satu array sebagai argumen.

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

Meskipun benar itu Collections.unmodifiableList()berfungsi, kadang-kadang Anda mungkin memiliki perpustakaan besar yang memiliki metode yang sudah didefinisikan untuk mengembalikan array (misalnya String[]). Untuk mencegahnya, Anda dapat mendefinisikan array bantu yang akan menyimpan nilai:

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

Untuk menguji:

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

Tidak sempurna, tetapi setidaknya Anda memiliki "pseudo immutable array" (dari perspektif kelas) dan ini tidak akan merusak kode terkait.

Nah .. array berguna untuk dilewatkan sebagai konstanta (jika mereka) sebagai parameter varian.