Java'da değişmez dizi

Java'daki ilkel dizilere değişmez bir alternatif var mı? İlkel bir dizi yapmak finalaslında birinin böyle bir şey yapmasını engellemez

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

Dizi öğelerinin değişmez olmasını istiyorum.

İlkel dizilerle değil. Bir Liste veya başka bir veri yapısı kullanmanız gerekir:

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

Benim öneri bir dizi veya değil kullanmaktır unmodifiableListama kullanmak Guava 'nın ImmutableList bu amaç için vardır.

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

Diğerlerinin de belirttiği gibi, Java'da değişmez dizilere sahip olamazsınız.

Orijinal diziyi etkilemeyen bir dizi döndüren bir yönteme kesinlikle ihtiyacınız varsa, diziyi her seferinde klonlamanız gerekir:

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

Açıkçası bu oldukça pahalıdır (alıcıyı her aradığınızda tam bir kopya oluşturacağınız için), ancak arayüzü değiştiremiyorsanız ( Listörneğin kullanmak için) ve istemcinin dahili bilgilerinizi değiştirmesini riske atamazsanız, gerekli olabilir.

Bu tekniğe defansif bir kopya yapmak denir.

Java'da değişmez bir dizi yapmanın bir yolu vardır:

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

0 elemanlı diziler (açıkça) mutasyona uğratılamaz.

Bir diziyi List.toArraydönüştürmek için yöntem kullanıyorsanız bu aslında kullanışlı olabilir List. Boş bir dizi bile bellek aldığından, sabit bir boş dizi oluşturarak ve bunu her zaman toArrayyönteme ileterek bellek ayırmayı kaydedebilirsiniz . Eğer geçmek Dizi yeterli alan yoksa bu yöntem yeni bir dizi tahsis edecek, ancak (liste boşsa) yaparsa, onunla bu dizide aramak her zaman yeniden izin, geçtin dizi döndürür toArraybir de boş 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

Başka bir cevap

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

Java 9 itibariyle kullanabileceğiniz List.of(...), javadoc .

Bu yöntem değişmez bir sonuç verir Listve çok etkilidir.

'Java.lang.Integer' yerine (performans nedeniyle veya belleği kaydetmek için) yerel 'int' gerekiyorsa, muhtemelen kendi sarmalayıcı sınıfınızı yazmanız gerekir. İnternette çeşitli IntArray uygulamaları var, ancak hiçbiri (buldum) değişmezdi: Koders IntArray , Lucene IntArray . Muhtemelen başkaları da vardır.

Guava 22'den bu yana, paketten com.google.common.primitivesdaha düşük bellek alanına sahip üç yeni sınıf kullanabilirsiniz ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

Ayrıca bir inşaatçı var. Misal:

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

veya boyut derleme zamanında biliniyorsa:

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

Bu, Java ilkelleri için bir dizinin değişmez bir görünümünü elde etmenin başka bir yoludur.

Hayır, bu mümkün değil. Ancak, böyle bir şey yapılabilir:

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

Bu, sarmalayıcıların kullanılmasını gerektirir ve bir dizi değil, bir Liste'dir, ancak alacağınız en yakın şeydir.

Bazı durumlarda, Google Guava kitaplığındaki bu statik yöntemi kullanmak daha hafif olacaktır: List<Integer> Ints.asList(int... backingArray)

Örnekler:

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

Hem değiştirilebilirlikten hem de bokstan kaçınmak istiyorsanız, kutudan çıkmanın bir yolu yoktur. Ancak, ilkel diziyi içinde tutan ve yöntem (ler) yoluyla öğelere salt okunur erişim sağlayan bir sınıf oluşturabilirsiniz.

(E ... öğeleri) yöntemi Java9 sadece satırını kullanarak değişmez bir liste oluşturmak için kullanılabilir:

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

Yukarıdaki yöntem, rastgele sayıda öğe içeren değişmez bir liste döndürür. Ve bu listeye herhangi bir tam sayı eklemek java.lang.UnsupportedOperationExceptionistisnayla sonuçlanır . Bu yöntem aynı zamanda tek bir diziyi bağımsız değişken olarak kabul eder.

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

Çalıştığı doğru olsa da Collections.unmodifiableList(), bazen dizileri döndürmek için zaten tanımlanmış yöntemlere sahip büyük bir kütüphaneniz olabilir (örn. String[]). Bunları kırmayı önlemek için, değerleri depolayacak yardımcı diziler tanımlayabilirsiniz:

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

Test etmek için:

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

Mükemmel değil, ama en azından "sözde değişmez diziler" var (sınıf açısından) ve bu ilgili kodu bozmaz.

Diziler, varyant parametreleri olarak sabitler (eğer olduysa) olarak geçmek için kullanışlıdır.