Niezmienna tablica w Javie

Czy istnieje niezmienna alternatywa dla pierwotnych tablic w Javie? Tworzenie prymitywnej tablicy w finalrzeczywistości nie uniemożliwia zrobienia czegoś takiego

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

Chcę, aby elementy tablicy były niezmienne.

Nie z prymitywnymi tablicami. Będziesz musiał użyć listy lub innej struktury danych:

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

Moja rada jest taka, aby nie używać tablica czy unmodifiableListjednak używać Guava „s ImmutableList , która istnieje do tego celu.

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

Jak zauważyli inni, w Javie nie można mieć niezmiennych tablic.

Jeśli absolutnie potrzebujesz metody zwracającej tablicę, która nie wpływa na oryginalną tablicę, musisz sklonować tablicę za każdym razem:

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

Oczywiście jest to dość kosztowne (ponieważ utworzysz pełną kopię za każdym razem, gdy wywołasz getter), ale jeśli nie możesz zmienić interfejsu (aby użyć Listna przykład) i nie możesz ryzykować, że klient zmieni twoje wewnętrzne, to może to być konieczne.

Ta technika nazywa się robieniem kopii obronnej.

Istnieje jeden sposób na utworzenie niezmiennej tablicy w Javie:

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

Tablice z elementami 0 (oczywiście) nie mogą być mutowane.

Może się to przydać, jeśli używasz List.toArraymetody do konwersji a Listna tablicę. Ponieważ nawet pusta tablica zajmuje trochę pamięci, możesz zapisać tę alokację pamięci, tworząc stałą pustą tablicę i zawsze przekazując ją do toArraymetody. Że metoda będzie przydzielić nową tablicę jeśli tablica zdać nie ma wystarczająco dużo miejsca, ale jeśli to robi (lista jest pusta), zwróci macierz, którą przeszedł, co pozwala na ponowne użycie tej tablicy każdej chwili zadzwonić toArrayna zasadzie pusty 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

Jeszcze jedna odpowiedź

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

Jak Java 9 można użyć List.of(...), Javadoc .

Ta metoda zwraca niezmienną Listi jest bardzo wydajna.

Jeśli potrzebujesz (ze względu na wydajność lub w celu zaoszczędzenia pamięci) natywnego „int” zamiast „java.lang.Integer”, prawdopodobnie będziesz musiał napisać własną klasę opakowującą. W sieci są różne implementacje IntArray, ale żadna (znalazłem) nie była niezmienna: Koders IntArray , Lucene IntArray . Prawdopodobnie są inni.

Od Guava 22, z pakietu com.google.common.primitivesmożna użyć trzech nowych klas, które mają mniejszy ślad pamięci w porównaniu do ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

Mają też budowniczego. Przykład:

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

lub, jeśli rozmiar jest znany w czasie kompilacji:

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

To kolejny sposób na uzyskanie niezmiennego widoku tablicy dla prymitywów języka Java.

Nie, to niemożliwe. Można jednak zrobić coś takiego:

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

Wymaga to użycia opakowań i jest listą, a nie tablicą, ale jest najbliższą, jaką otrzymasz.

W niektórych sytuacjach lżejsze będzie użycie tej statycznej metody z biblioteki Google Guava: List<Integer> Ints.asList(int... backingArray)

Przykłady:

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

Jeśli chcesz uniknąć zarówno zmienności, jak i boksu, nie ma wyjścia z pudełka. Ale możesz stworzyć klasę, która zawiera wewnątrz pierwotną tablicę i zapewnia dostęp tylko do odczytu do elementów za pośrednictwem metod.

Metoda of (E ... elements) w Javie9 może służyć do tworzenia niezmiennej listy przy użyciu tylko linii:

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

Powyższa metoda zwraca niezmienną listę zawierającą dowolną liczbę elementów. Dodanie dowolnej liczby całkowitej do tej listy spowodowałoby java.lang.UnsupportedOperationExceptionwyjątek. Ta metoda akceptuje również pojedynczą tablicę jako argument.

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

Chociaż prawdą jest, że to Collections.unmodifiableList()działa, czasami możesz mieć dużą bibliotekę z już zdefiniowanymi metodami zwracania tablic (np String[].). Aby zapobiec ich uszkodzeniu, możesz faktycznie zdefiniować tablice pomocnicze, które będą przechowywać wartości:

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

Testować:

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

Nie jest to doskonałe, ale przynajmniej masz „pseudo niezmienne tablice” (z punktu widzenia klasy) i to nie zepsuje powiązanego kodu.

No cóż ... tablice są przydatne do przekazywania jako stałe (jeśli były) jako parametry wariantów.