为了减少可变性，我们是否应该使用
public void setValues(String[] newVals) {
this.vals = ( newVals == null ? null : newVals.clone() );
}
或者
public void setValues(String[] newVals) {
this.vals = ( newVals == null ? null : Arrays.copyOf(newVals, newVals.length) );
}
使用 jmh，我得到了类似的结果，除了clone似乎稍微好一点。
我对性能进行了快速测试：clone，System.arrayCopy并且Arrays.copyOf具有非常相似的性能（jdk 1.7.06，服务器 vm）。
JIT之后的详细信息（以毫秒为单位）：
克隆：68
arrayCopy：68
Arrays.copyOf：68
测试代码：
public static void main(String[] args) throws InterruptedException,
IOException {
int sum = 0;
int[] warmup = new int[1];
warmup[0] = 1;
for (int i = 0; i < 15000; i++) { // triggers JIT
sum += copyClone(warmup);
sum += copyArrayCopy(warmup);
sum += copyCopyOf(warmup);
}
int count = 10_000_000;
int[] array = new int[count];
for (int i = 0; i < count; i++) {
array[i] = i;
}
// additional warmup for main
for (int i = 0; i < 10; i++) {
sum += copyArrayCopy(array);
}
System.gc();
// copyClone
long start = System.nanoTime();
for (int i = 0; i < 10; i++) {
sum += copyClone(array);
}
long end = System.nanoTime();
System.out.println("clone: " + (end - start) / 1000000);
System.gc();
// copyArrayCopy
start = System.nanoTime();
for (int i = 0; i < 10; i++) {
sum += copyArrayCopy(array);
}
end = System.nanoTime();
System.out.println("arrayCopy: " + (end - start) / 1000000);
System.gc();
// copyCopyOf
start = System.nanoTime();
for (int i = 0; i < 10; i++) {
sum += copyCopyOf(array);
}
end = System.nanoTime();
System.out.println("Arrays.copyOf: " + (end - start) / 1000000);
// sum
System.out.println(sum);
}
private static int copyClone(int[] array) {
int[] copy = array.clone();
return copy[copy.length - 1];
}
private static int copyArrayCopy(int[] array) {
int[] copy = new int[array.length];
System.arraycopy(array, 0, copy, 0, array.length);
return copy[copy.length - 1];
}
private static int copyCopyOf(int[] array) {
int[] copy = Arrays.copyOf(array, array.length);
return copy[copy.length - 1];
}
还请考虑使用“clone()”的安全性。一类众所周知的攻击使用带有恶意代码覆盖对象的“clone()”方法的类。例如，CVE-2012-0507（Mac OS 上的“闪回”攻击）基本上通过将“.clone()”调用替换为“.copyOf”调用来解决。
关于“clone()”过时的更多讨论可以在 StackOverflow 上找到：object cloning with out implementation cloneable interface
我写了一个简单的程序来检查差异。
public static void main(String[] args) throws IOException, InterruptedException,
PrinterException
{
//Verify array remains immutable.
String[] str = {"a","b","c"};
String[] strings = str.clone();
//change returned array
strings[2]= "d";
System.out.println(Arrays.toString(str));
System.out.println(Arrays.toString(strings));
String[] stringsCopy = Arrays.copyOf(str, str.length);
stringsCopy[2]= "d";
System.out.println(Arrays.toString(str));
System.out.println(Arrays.toString(stringsCopy));
//peformance
long before = System.currentTimeMillis();
for(int i=0;i<Integer.MAX_VALUE;i++)
{
str.clone();
}
System.out.println("Time Required for Clone: "+ (System.currentTimeMillis()-before));
//peformance
long beforeCopy = System.currentTimeMillis();
for(int i=0;i<Integer.MAX_VALUE;i++)
{
Arrays.copyOf(str, str.length);
}
System.out.println("Time Required for Copy of: "+ (System.currentTimeMillis()-beforeCopy));
}
它输出
[a, b, c]
[a, b, d]
[a, b, c]
[a, b, d]
Time Required for Clone: 26288
Time Required for Copy of: 25413
因此，如果您看到这两种情况String[]都是不可变的并且性能几乎相同，那么认为 Arrays.copyOf() 在我的机器上稍快一些。
更新
我更改了程序以创建大数组 [100 个字符串] 而不是小数组。
String[] str = new String[100];
for(int i= 0; i<str.length;i++)
{
str[i]= Integer.toString(i);
}
并在copy of方法之前移动clone方法。结果如下。
Time Required for Copy of: 415095
Time Required for Clone: 428501
这又是相同的。Please do not ask me to run the test again as it takes a while:(
更新 2
对于字符串数组1000000和迭代次数10000
Time Required for Copy of: 32825
Time Required for Clone: 30138
copy of花费的时间比clone
在可变性方面，它们将提供完全相同的数据——浅拷贝。