blocks|key|1145297|text|而不是原始数组。您将需要使用列表或其他一些数据结构：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145298|List<Integer>+items+=+Collections.unmodifiableList(Arrays.asList(0,1,2,3));|code-block|syntax|javascript|1145299|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Not with primitive arrays. You'll need to use a List or some other data structure:

<pre><code>List&lt;Integer&gt; items = Collections.unmodifiableList(Arrays.asList(0,1,2,3));
</code></pre>

blocks|key|1145490|text|我的建议是不使用数组或unmodifiableList，而是使用Guava的ImmutableList，它就是为了这个目的而存在的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1145491|ImmutableList<Integer>+values+=+ImmutableList.of(0,+1,+2,+3);|code-block|syntax|javascript|1145492|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/google/guava|1|https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/ImmutableList.html^0|B|G|W|5|0|12|D|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

My recommendation is to not use an array or an <code>unmodifiableList</code> but to use <a href="https://github.com/google/guava" rel="noreferrer">Guava</a>'s <a href="https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/ImmutableList.html" rel="noreferrer">ImmutableList</a>, which exists for this purpose.

<pre><code>ImmutableList&lt;Integer&gt; values = ImmutableList.of(0, 1, 2, 3);
</code></pre>

blocks|key|930902|text|正如其他人所指出的，在Java中不能有不可变的数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930903|如果你绝对需要一个返回一个不影响原始数组的数组的方法，那么你每次都需要克隆这个数组：|930904|public+int[]+getFooArray()+{
++return+fooArray+==+null+?+null+:+fooArray.clone();
}|code-block|syntax|javascript|930905|显然，这是相当昂贵的(因为您每次调用getter都会创建一个完整的副本)，但是如果您不能更改接口(例如使用List+)，并且不能冒险让客户端更改您的内部结构，那么它可能是必要的。|offset|length|style|CODE|930906|这种技术被称为防御性拷贝。|930907|entityMap^0|0|0|0|1H|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

As others have noted, you can't have immutable arrays in Java.

If you absolutely need a method that returns an array that doesn't influence the original array, then you'd need to clone the array each time:

<pre><code>public int[] getFooArray() {
 return fooArray == null ? null : fooArray.clone();
}
</code></pre>

Obviously this is rather expensive (as you'll create a full copy each time you call the getter), but if you can't change the interface (to use a <code>List</code> for example) and can't risk the client changing your internals, then it may be necessary.

This technique is called making a defensive copy.

blocks|key|931154|text|在Java中有一种方法可以创建一个不可变的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931155|final+String[]+IMMUTABLE+=+new+String[0];|code-block|syntax|javascript|931156|元素为0的数组(显然)不能变异。|931157|如果您使用List.toArray方法将List转换为数组，这实际上会很方便。由于即使是空数组也会占用一些内存，因此可以通过创建一个常量空数组并始终将其传递给toArray方法来节省内存分配。如果您传递的数组没有足够的空间，该方法将分配一个新的数组，但如果它有足够的空间(列表为空)，它将返回您传递的数组，从而允许您在任何时候对空List调用toArray时重用该数组。|offset|length|style|CODE|931158|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|931159|entityMap^0|0|0|0|5|C|K|4|27|7|4L|4|4R|7|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]|$K|10|L|11|M|N]|$K|12|L|13|M|N]|$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$]]

There is one way to make an immutable array in Java:

<pre><code>final String[] IMMUTABLE = new String[0];
</code></pre>

Arrays with 0 elements (obviously) cannot be mutated.

This can actually come in handy if you are using the <code>List.toArray</code> method to convert a <code>List</code> to an array. Since even an empty array takes up some memory, you can save that memory allocation by creating a constant empty array, and always passing it to the <code>toArray</code> method. That method will allocate a new array if the array you pass doesn't have enough space, but if it does (the list is empty), it will return the array you passed, allowing you to reuse that array any time you call <code>toArray</code> on an empty <code>List</code>.

<pre><code>final static String[] EMPTY_STRING_ARRAY = new String[0];

List&lt;String&gt; emptyList = new ArrayList&lt;String&gt;();
return emptyList.toArray(EMPTY_STRING_ARRAY); // returns EMPTY_STRING_ARRAY
</code></pre>

blocks|key|1145787|text|从Java9开始，您可以使用List.of(...)、JavaDoc。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1145788|这个方法返回一个不可变的List，非常有效。|1145789|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/9/docs/api/java/util/List.html#of-E...-^0|E|C|R|7|0|0|C|4|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

As of Java 9 you can use <code>List.of(...)</code>, <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html#of-E...-" rel="noreferrer">JavaDoc</a>.

This method returns an immutable <code>List</code> and is very efficient.

blocks|key|931197|text|另一个答案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931198|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"});
}|code-block|syntax|javascript|931199|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another one answer

<pre><code>static class ImmutableArray&lt;T&gt; {
 private final T[] array;

 private ImmutableArray(T[] a){
 array = Arrays.copyOf(a, a.length);
 }

 public static &lt;T&gt; ImmutableArray&lt;T&gt; from(T[] a){
 return new ImmutableArray&lt;T&gt;(a);
 }

 public T get(int index){
 return array[index];
 }
}

{
 final ImmutableArray&lt;String&gt; sample = ImmutableArray.from(new String[]{"a", "b", "c"});
}
</code></pre>

blocks|key|931035|text|如果您(出于性能原因或节省内存)需要本机'int‘而不是'java.lang.Integer'，那么您可能需要编写自己的包装类。网上有各种各样的IntArray实现，但没有一个(我发现)是不变的：Koders+IntArray、Lucene+IntArray。可能还有其他的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|931036|entityMap|0|LINK|mutability|MUTABLE|url|http://www.koders.com/java/fid2B2A9FE40DD7B59D2E3D17D07D4E0E32270B9469.aspx?s=cdef%253Atree|1|http://code.google.com/p/lucene-ext/source/browse/trunk/src/com/kamikaze/docidset/utils/IntArray.java^0|2Q|F|0|36|F|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

If you need (for performance reason or to save memory) native 'int' instead of 'java.lang.Integer', then you would probably need to write your own wrapper class. There are various IntArray implementations on the net, but none (I found) was immutable: <a href="http://www.koders.com/java/fid2B2A9FE40DD7B59D2E3D17D07D4E0E32270B9469.aspx?s=cdef%3Atree" rel="nofollow noreferrer">Koders IntArray</a>, <a href="http://code.google.com/p/lucene-ext/source/browse/trunk/src/com/kamikaze/docidset/utils/IntArray.java" rel="nofollow noreferrer">Lucene IntArray</a>. There are probably others.

blocks|key|1145363|text|不，这不可能。然而，人们可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145364|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);|code-block|syntax|javascript|1145365|这需要使用包装器，并且是一个列表，而不是一个数组，但这是最接近的结果。|1145366|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

No, this is not possible. However, one could do something like this:

<pre><code>List&lt;Integer&gt; temp = new ArrayList&lt;Integer&gt;();
temp.add(Integer.valueOf(0));
temp.add(Integer.valueOf(2));
temp.add(Integer.valueOf(3));
temp.add(Integer.valueOf(4));
List&lt;Integer&gt; immutable = Collections.unmodifiableList(temp);
</code></pre>

This requires using wrappers, and is a List, not an array, but is the closest you will get.

blocks|key|1145732|text|如果您想同时避免易变性和装箱，那么就没有办法跳出框框。但是您可以创建一个类，该类将原始数组保存在内部，并通过方法提供对元素的只读访问。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145733|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you want to avoid both mutability and boxing, there is no way out of the box. But you can create a class which holds primitive array inside and provides read-only access to elements via method(s).

blocks|key|1145772|text|虽然Collections.unmodifiableList()确实可以工作，但有时你可能有一个很大的库，里面已经定义了返回数组的方法(例如String[])。为了防止破坏它们，您可以实际定义将存储值的辅助数组：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1145773|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;
++++}
}|code-block|syntax|javascript|1145774|要测试：|1145775|++++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()));|1145776|这并不完美，但至少你有“伪不可变数组”(从类的角度来看)，这不会破坏相关代码。|1145777|entityMap^0|2|U|1Y|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

While it's true that <code>Collections.unmodifiableList()</code> works, sometimes you may have a large library having methods already defined to return arrays (e.g. <code>String[]</code>).
To prevent breaking them, you can actually define auxiliary arrays that will store the values:

<pre><code>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;
 }
}
</code></pre>

To test:

<pre><code> 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()));
</code></pre>

Not perfect, but at least you have "pseudo immutable arrays" (from the class perspective) and this will not break related code.

blocks|key|931089|text|好吧..。将数组作为常量(如果它们是)作为变量参数传递是很有用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931090|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Well.. arrays are useful to pass as constants (if they were) as variants parameters.

Is there an immutable alternative to the primitive arrays in Java? Making a primitive array <code>final</code> doesn't actually prevent one from doing something like

<pre><code>final int[] array = new int[] {0, 1, 2, 3};
array[0] = 42;
</code></pre>

I want the elements of the array to be unchangeable.

Immutable array in Java

数据结构

Java

Java中的原始数组有不可变的替代方法吗？创建一个原语数组final实际上并不能阻止你做类似这样的事情final int[] array = new int[] {0, 1, 2, 3};array[0] = 42;我希望数组的元素是不可更改的。

问Java中的不可变数组
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的不可变数组EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的不可变数组
EN