Unveränderliches Array in Java

Gibt es eine unveränderliche Alternative zu den primitiven Arrays in Java? Das Erstellen eines primitiven Arrays finalhindert einen nicht daran, so etwas zu tun

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

Ich möchte, dass die Elemente des Arrays unveränderlich sind.

Nicht mit primitiven Arrays. Sie müssen eine Liste oder eine andere Datenstruktur verwenden:

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

Meine Empfehlung ist , nicht um ein Array zu verwenden oder unmodifiableListaber zu verwenden Guava ‚s ImmutableList , die für diesen Zweck vorhanden ist .

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

Wie andere angemerkt haben, können Sie in Java keine unveränderlichen Arrays haben.

Wenn Sie unbedingt eine Methode benötigen, die ein Array zurückgibt, das das ursprüngliche Array nicht beeinflusst, müssen Sie das Array jedes Mal klonen:

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

Dies ist natürlich ziemlich teuer (da Sie jedes Mal, wenn Sie den Getter aufrufen, eine vollständige Kopie erstellen), aber wenn Sie die Schnittstelle nicht ändern können ( Listum beispielsweise eine zu verwenden) und nicht riskieren können, dass der Client Ihre Interna ändert, dann es kann notwendig sein.

Diese Technik wird als Erstellen einer defensiven Kopie bezeichnet.

Es gibt eine Möglichkeit, ein unveränderliches Array in Java zu erstellen:

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

Arrays mit 0 Elementen können (offensichtlich) nicht mutiert werden.

Dies kann tatsächlich nützlich sein, wenn Sie die List.toArrayMethode zum Konvertieren von a Listin ein Array verwenden. Da selbst ein leeres Array Speicherplatz beansprucht, können Sie diese Speicherzuordnung speichern, indem Sie ein konstantes leeres Array erstellen und es immer an die toArrayMethode übergeben. Diese Methode weist ein neues Array zu, wenn das übergebene Array nicht über genügend Speicherplatz verfügt. Wenn dies jedoch der Fall ist (die Liste ist leer), wird das übergebene Array zurückgegeben, sodass Sie dieses Array bei jedem Aufruf toArrayeines Arrays wiederverwenden können leer 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

Noch eine Antwort

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

Ab Java 9 können Sie verwenden List.of(...), JavaDoc .

Diese Methode gibt eine unveränderliche zurück Listund ist sehr effizient.

Wenn Sie (aus Leistungsgründen oder um Speicherplatz zu sparen) natives 'int' anstelle von 'java.lang.Integer' benötigen, müssen Sie wahrscheinlich Ihre eigene Wrapper-Klasse schreiben. Es gibt verschiedene IntArray-Implementierungen im Netz, aber keine (ich fand) war unveränderlich: Koders IntArray , Lucene IntArray . Es gibt wahrscheinlich andere.

Seit Guava 22 können Sie ab Paket com.google.common.primitivesdrei neue Klassen verwenden, die im Vergleich zu weniger Speicherplatz haben ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

Sie haben auch einen Baumeister. Beispiel:

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

oder, wenn die Größe zur Kompilierungszeit bekannt ist:

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

Dies ist eine weitere Möglichkeit, eine unveränderliche Ansicht eines Arrays für Java-Grundelemente zu erhalten.

Nein das ist nicht möglich. Man könnte jedoch so etwas tun:

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

Dies erfordert die Verwendung von Wrappern und ist eine Liste, kein Array, aber die nächstgelegene, die Sie erhalten.

In einigen Situationen ist die Verwendung dieser statischen Methode aus der Google Guava-Bibliothek leichter: List<Integer> Ints.asList(int... backingArray)

Beispiele:

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

Wenn Sie sowohl Veränderlichkeit als auch Boxen vermeiden möchten, gibt es keinen Ausweg. Sie können jedoch eine Klasse erstellen, die ein primitives Array enthält und über Methoden einen schreibgeschützten Zugriff auf Elemente bietet.

Mit der Methode of (E ... elements) in Java9 kann eine unveränderliche Liste mit nur einer Zeile erstellt werden:

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

Die obige Methode gibt eine unveränderliche Liste zurück, die eine beliebige Anzahl von Elementen enthält. Das Hinzufügen einer Ganzzahl zu dieser Liste würde zu einer java.lang.UnsupportedOperationExceptionAusnahme führen. Diese Methode akzeptiert auch ein einzelnes Array als Argument.

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

Es stimmt zwar, dass dies Collections.unmodifiableList()funktioniert, aber manchmal haben Sie eine große Bibliothek, in der bereits Methoden definiert sind, um Arrays zurückzugeben (z String[]. B. ). Um zu verhindern, dass sie beschädigt werden, können Sie Hilfsarrays definieren, in denen die Werte gespeichert werden:

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

Zu testen:

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

Nicht perfekt, aber zumindest haben Sie "pseudo-unveränderliche Arrays" (aus der Klassenperspektive) und dies wird den zugehörigen Code nicht beschädigen.

Nun ... Arrays sind nützlich, um sie als Konstanten (falls vorhanden) als Variantenparameter zu übergeben.