Java中的不可变数组

有没有Java原始数组的不变选择？制作一个原始数组final实际上并不能阻止人们做类似的事情

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

我希望数组的元素不可更改。

不适用于原始数组。您将需要使用列表或其他数据结构：

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

我的建议是不要使用数组或an，unmodifiableList而要使用为此目的而存在的Guava的ImmutableList。

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

正如其他人指出的那样，Java中不能有不可变的数组。

如果您绝对需要一个返回不影响原始数组的数组的方法，则您需要每次都克隆该数组：

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

显然，这是相当昂贵的（因为每次调用getter时都会创建一个完整副本），但是如果您不能更改接口（List例如使用a ）并且不能冒险让客户更改内部结构，那么可能有必要。

这种技术称为制作防御性副本。

有一种方法可以在Java中创建不可变数组：

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

具有0个元素的数组（显然）不能被突变。

如果您正在使用List.toArray方法将a转换List为数组，则实际上可以派上用场。由于即使是空数组也会占用一些内存，因此您可以通过创建一个恒定的空数组并将其始终传递给该toArray方法来保存该内存分配。该方法将分配一个新的数组，如果你传递数组没有足够的空间，但如果它（列表为空），它会回报你传递的数组，让您重新使用数组调用任何时间toArray上的空的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

另一个答案

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，你可以用List.of(...)，的JavaDoc。

此方法返回一个不变的List且非常有效的方法。

如果您需要（出于性能原因或为了节省内存）本机“ int”而不是“ java.lang.Integer”，则可能需要编写自己的包装器类。网上有各种各样的IntArray实现，但是（我发现）没有一成不变的：Koders IntArray，Lucene IntArray。可能还有其他人。

从Guava 22开始，com.google.common.primitives您可以从软件包中使用三个新类，与相比，它们具有更低的内存占用量ImmutableList。

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

他们也有一个建设者。例：

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

或者，如果在编译时知道大小，则：

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

这是获取Java原语数组不变视图的另一种方法。

不，这是不可能的。但是，可以执行以下操作：

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

这需要使用包装器，并且是列表，而不是数组，但是它是您将得到的最接近的列表。

在某些情况下，使用Google Guava库中的此静态方法会减轻重量： List<Integer> Ints.asList(int... backingArray)

例子：

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

如果要避免变异和装箱，则没有开箱即用的方法。但是，您可以创建一个在其中保存基本数组并通过方法提供对元素的只读访问的类。

Java9中的of（E ... elements）方法可用于仅使用一行创建不可变列表：

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

上面的方法返回一个包含任意数量元素的不可变列表。并且将任何整数添加到此列表将导致java.lang.UnsupportedOperationException异常。此方法还接受单个数组作为参数。

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

尽管确实Collections.unmodifiableList()可以使用，但有时您可能拥有一个大型库，其中包含已经定义了用于返回数组的方法（例如String[]）。为了防止破坏它们，您实际上可以定义将存储值的辅助数组：

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

这并不完美，但是至少您拥有“伪不可变数组”（从类的角度来看），并且这不会破坏相关代码。

那么..数组对于作为常量（如果是）作为变量参数传递很有用。